Mistrz Frogger

11

Gra

Większość z nas wie o Frogger , arkadowej grze z lat 80., w której celem jest bezpieczne przeskoczenie żaby przez ruchliwą autostradę i staw pełen niebezpieczeństw, aby bezpiecznie dotrzeć do domu.

Kilka miesięcy temu wydano wyzwanie opracowania klonu Frogger. Ale po co klonować Frogger, kiedy możesz grać w Frogger? :)

Rozważ następującą uproszczoną siatkę gry:

 XXXXXXXXXXXXXXXXXXXXXXX  North Safe Zone
 -----------------------
|                       | <<<<       Express Lane West        (Lane 1)
|                       |     >      Gridlock East            (Lane 2)
|                       |   <<       Freeflowing Traffic West (Lane 3)
|                       |    <       Gridlock West            (Lane 4)
|                       |     >>>>   Express Lane East        (Lane 5)
 -----------------------
 XXXXXXXXXXX@XXXXXXXXXXX  South Safe Zone
 \__________ __________/
            '
  23 cells horizontally

Mamy pięć pasów ruchu, każdy o szerokości 23 komórek i dwie bezpieczne strefy (w których żaba może bezpiecznie poruszać się w lewo i w prawo), również o szerokości 23 komórek. Możesz zignorować prawą i lewą granicę, ponieważ służą one przejrzystości obrazu.

Nasza żaba zaczyna się w bezpiecznej południowej strefie, w środkowej (12.) komórce, jak @pokazano na powyższym rysunku.

Czas w grze podzielony jest na dyskretne kroki zwane ramkami. Froggy jest szybką żabą i może przeskakiwać jedną komórkę w dowolnym kierunku (w górę, w dół, w prawo, w lewo) na klatkę. Może również zdecydować, że pozostanie nieruchomy dla dowolnej klatki. Ruch na pięciu pasach ruchu odbywa się ze stałymi prędkościami w następujący sposób:

  • ruch na linii ekspresowej na zachód (linia 1) przesuwa 2 komórki w lewo w każdej ramce
  • ruch na wschodnim pasie siatki (pas 2) przesuwa 1 komórkę w prawo co drugą klatkę
  • ruch na zachodnim pasie ruchu o swobodnym przepływie (pas 3) przesuwa 1 komórkę w lewo na każdą ramkę
  • ruch na zachodnim pasie siatki (linia 4) przesuwa się o 1 komórkę w lewo co drugą klatkę
  • ruch na linii ekspresowej wschód (linia 5) przesuwa 2 komórki w prawo w każdej ramce

Sam ruch jest jednoznacznie zdefiniowany dla ok. 3000 kroków czasowych w tym pliku tekstowym . „Ruch drogowy” obejmuje pojazdy i przestrzenie między pojazdami. Każda postać, która nie jest spacją, jest częścią pojazdu. Plik tekstowy zawiera pięć wierszy odpowiadających pięciu pasom ruchu (w tej samej kolejności).

W przypadku zachodnich pasów na początku ramki 0 (początek gry) uważamy, że pierwszy pojazd na linii znajduje się tuż za prawą krawędzią pola gry.

W przypadku pasów ruchu na wschód ciąg znaków należy uznać za „do tyłu” w tym sensie, że pojazdy pojawiają się na końcu ciągu. Na początku ramki 0 uważamy, że pierwszy pojazd na tych pasach znajduje się tuż za lewą krawędzią pola gry.

Rozważ jako przykład:

Traffic Lane 1:  [|==|  =
Traffic Lane 2:  |) =  o
Traffic Lane 3:  (|[]-[]:
Traffic Lane 4:  <| (oo|
Traffic Lane 5:  |==|] :=)

Następnie pojawi się plansza gry:

Start of Frame 0       XXXXXXXXXXXXXXXXXXXXXXX
                                              [|==|  =
                |) =  o
                                              (|[]-[]:
                                              <| (oo|
              |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 1       XXXXXXXXXXXXXXXXXXXXXXX
                                            [|==|  =
                |) =  o
                                             (|[]-[]:
                                              <| (oo|
                |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 2       XXXXXXXXXXXXXXXXXXXXXXX
                                          [|==|  =
                 |) =  o
                                            (|[]-[]:
                                             <| (oo|
                  |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Start of Frame 3       XXXXXXXXXXXXXXXXXXXXXXX
                                        [|==|  =
                 |) =  o
                                           (|[]-[]:
                                             <| (oo|
                    |==|] :=)
                       XXXXXXXXXXXXXXXXXXXXXXX

Po tym, jak cały ruch na linii zostanie „wyczerpany” (tzn. Łańcuch się skończy), uważamy, że wszystkie znaki w łańcuchu są spacjami.

Nasza żaba jest zgnieciona, jeśli wystąpi którykolwiek z poniższych:

  • żaba zajmuje komórkę zajmowaną przez pojazd, na dowolnej ramie
  • żaba pozostaje nieruchoma na linii szybkiego ruchu, a pojazd o szerokości 1 komórki przechodzi nad nim w tej ramce
  • żaba skacze na wschód „przez” pojazd jadący na zachód lub skacze na zachód przez pojazd jadący na wschód
  • żaba wyskakuje poza siatkę 7 (linia) o 23 (komórka) na dowolnej klatce

Pamiętaj, że są to jedyne warunki, w których żaba jest wyciskana. W szczególności dozwolona jest żaba skacząca wraz z „ruchem”, podobnie jak żaba skacząca do lub z komórki na ekspresowym pasie, który jest omijany przez pojazd o szerokości 1 w tej samej ramie.

Cel i punktacja

Celem wyzwania programowania jest poprowadzenie żaby tak często, jak to możliwe, zanim ostatni pojazd opuści pole gry . Oznacza to, że program kończy się natychmiast po zakończeniu ramki X , gdzie rama X jest pierwszą ramką, która przenosi siatkę do stanu, w którym nie ma już więcej pojazdów.

Wyjście Twojego programu powinno być ciągiem (lub plikiem tekstowym) zawierającym sekwencję ruchów żaby przy użyciu następującego kodowania:

<   frog moves left
>   frog moves right
^   frog moves up
v   frog moves down
.   frog remains stationary

Na przykład ciąg znaków <<^.^wskazuje, że żaba przesuwa się dwukrotnie w lewo, następnie w górę, następnie zatrzymuje się na jedną klatkę, a następnie przesuwa się ponownie w górę.

Jeden punkt jest przyznawany za każdym razem, gdy żaba przechodzi z bezpiecznej strefy południowej do bezpiecznej strefy północnej, a jeden punkt jest przyznawany za każdym razem, gdy żaba przechodzi z bezpiecznej strefy północnej do bezpiecznej strefy południowej.

Kilka ważnych zasad:

  1. Żaba nie może być zgnieciona.
  2. Proszę zamieścić swoje rozwiązanie (sekwencję ruchów) wraz z kodem programu, albo w pliku tekstowym (np. Za pomocą pastebin.com).
  3. Nasza żaba jest przewidywalna i wstępnie rozpoznawalna, dlatego Twój program może wykorzystywać dowolne dane o ruchu w dowolnej ramce podczas wyszukiwania rozwiązań. Obejmuje to dane dotyczące ruchu, który nie dotarł jeszcze do planszy odtwarzania.
  4. Siatka się nie zawija. Wyjście z siatki spowoduje zgniecenie żaby i dlatego nie jest dozwolone.
  5. W żadnym momencie ruch nie „resetuje się”, a żaba nie „teleportuje się”. Symulacja jest ciągła.
  6. Żaba może powrócić do bezpiecznej strefy południowej po wyjściu z niej, ale nie jest to liczone jako punkt. Podobnie dla północnej strefy bezpieczeństwa.
  7. Zwycięzcą konkursu jest program, który generuje sekwencję ruchów zapewniającą największą liczbę skrzyżowań.
  8. W przypadku jakichkolwiek dodatkowych pytań lub wątpliwości prosimy o kontakt w sekcji komentarzy.

Aby uzyskać dodatkową zachętę, dodam nagrodę +100 powtórzeń do zwycięskiego programu, gdy będę mógł to zrobić.

Bonusy

+ 2,5% do wyniku podstawowego * (do + 10%) za każdy róg siatki gry, której dotyka żaba. Cztery rogi siatki są skrajnie lewą i prawą komórką dwóch bezpiecznych stref.

+ 25% do wyniku podstawowego *, jeśli sekwencja ruchów utrzymuje żabę w granicach +/- 4 komórek po lewej lub prawej stronie komórki początkowej dla całej symulacji (może oczywiście swobodnie poruszać się pionowo).

Brak premii za punktację, ale specjalne rekwizyty w PO trafią do każdego, kto opublikuje szybki i brudny walidator rozwiązania, abym nie musiał go programować. ;) Walidator po prostu zaakceptuje sekwencję ruchów, zapewni jej zgodność z prawem (zgodnie z przepisami i plikiem ruchu) i zgłosi swój wynik (tj. Całkowitą liczbę przejazdów).

* Całkowity wynik jest równy wynikowi podstawowemu powiększonemu o bonus, zaokrąglony w dół do najbliższej liczby całkowitej.

Żaba powodzenia!

COTO
źródło
Do każdego, kto chce opublikować weryfikator rozwiązania: Proszę nie publikować go jako odpowiedzi .
Geobits
W rzeczy samej. Link do kodu w komentarzu lub jako uzupełnienie rozwiązania byłby preferowanym sposobem przesłania walidatora.
COTO,
Czy pierwsza klatka, w której posuwają się wolne linie, jest taka sama jak pierwsza klatka, w której poruszają się pozostałe linie, czy jedna klatka później?
feersum
Czy można również zdobyć punkty, osiągając endzone na pierwszej ramce, w której wszystkie samochody wyczyściły pole?
feersum
@feersum: Wolne pasy przechodzą o jedną klatkę później. Pozostają one nieruchome w pierwszej klatce, jak pokazano w przykładzie. Jeśli chodzi o ocenę żaby na ostatniej klatce: tak, jest to możliwe. Jeśli żaba przesunęła się do bezpiecznej strefy na tej samej ramie, na której ostatni pojazd opuszcza boisko, zdobywa się jeden punkt.
COTO,

Odpowiedzi:

5

C ++: 176

Wynik:

176
^^^^^^>vvvvvv>^^^^>^^>>>>>>><<<.vv>v<<<.vvv<<<<<<^.^.^.^.>.>^^<.>>>>>>v>v>.>v<<<<v.<.vv<<<<<^^.<^<<<<<<^.^^>>>>vv>.>.v<v.vv>>^>>^<^<<<<<<<^>.>^^<<<.>>>>>vv>v<vvv<<<<<^^.<^^^^.....vv>.>.>.>v<<vvv<<>>>>^>^<.<.^^>^^>>>>vv.>v<vv.v^>^<.<.<^<^>.>^^>>>>vv.v<<<<<<.vvv<<<<^^^<<v^^.>.^^..>>>>>>vv>.>.v.vvv>>>^>^^<<<<<<<<<^>.>^^>>>>vvv<<v.<.vv<<<<<<>>>>>^^^<<<^^^<<>>vv>.v<<>vvv<<><>>>>>>>^>^^<^^^<.>>>>>>>>vv>.>v<<<vvv<<<<<^^^<<v.<.<^<<^.^<<^...>>>>>>>>>>>>>vv>v<vvv<<<<<<<<^>^.<.^^>.>^^<<<<<<<..>>>>vv>.vvvv<<<<>^.v>>>^^.^^>^<^<>>>>>>>>>vv>vvvv<<<<^^^<^>^<<^.>>vv>v<vvv<<<<<<<>>>>>>>^>^^^.^^>>>>>vvv<<vvv<<<^^^^^^<vvv<<<<<<<vvv<<<>>>>>>>>^^.<.<.^.^.^<^<>>>>>>>>>>vvv<<.vvv<<<^^<^<<^^<<^<<<>>>>vv>.vvvv>>^>>^<.<.<^<<<<<.^^<<^.......>vv.>.>.>v<vvv>>>>>>^>^.<.<^<.^^^<.>>>>>>>vvv<<<v.<vv<<<^^<.<.<.<^<<<^>^^..........v<vvvv>v>>>>>^>>^^^>^^>>>vv>v<vvv<<<<<<<<>^^.<.<^<^^^<.........>vv.>.vvvv>>>>^^<.<.<^^^<^<<.v<v>.>.>.>.>.>.>.vvv.v<<<<<^^<^<^>.>.>.>.^<^.>>>>>>>>vv>v<<vvv<<>>>>>^^^.^.>^<^<<<<<<<<.vv.>.v<<<.vvv<>>>>>^>^.<.<.<.<^^.^<<^<.....>>vvv<.>>vvv<<<>>>>>>>>^^^<<<.^.>.>^^.>>>>>vv.>v<vvv<<<>>>>>>^>^<^<<^.^^<vvv<<<<<vv.v<>>>>>>>>>>^>^.^^>^^<<<<.>vv.>.vvvv>^>>^.<.<.<^<<<^>^^>>>vv>v<<<<<vvv<<<>>>>>^^<.<.<.<.<^<^>.^^.>>>>>vv>v<>vvv<<<<<<<^>^.<^<<<<<<<^^^.>>>>>vv>v<>vvv>>>^^<.<^<<<^>^^.>>>>vv>.v<<vvv<<<<<^^^<<<<<^>.^^<>>>>>>>vv>.>v<<vvv<<<<<<<>>>^>>.>^^^.>^^<>>>>>>vv>vv.<.<.vv>>>>^^<.<.<.<^<<^.>^^.>>>>>vv.>.>v<<vvv<<>>>>>^^<.<.<.^^>.>.>^^<<<<<<<<.>>>>>>vv>v<<v.<.<vv<<<<^^.<^<<<.^^^<.vv.>v<vvv<<<>>>>>>^>^<^<<^.^<^<<.>>vv>.>.>.>vvvv>>>>>>^>^^^^^<<<.vvv<<<<<<vvv>>>>>^>^<.<^<<^.>.>.^^>>>>vv>.>v<<<<<<vvv<<<<^^^<.^.>^^>>>>vvv<<v.vv<<<^>>^^<<<.^^<<^>>>>>>>>>vvv.v.vv<>>>>>^>^^<<<<<<<<<<<<<<<<^^^..>>>>>vv>.>.>.>v<<v.<.<.vv<<<<<^^^<^>.^^...>>>>>>>>vv.v<.vvv>>>^>^<.<^^^^>>>vv>v<<<vvv<<<<>>>>>>^>^.<.<^<^>.>^^.>>>>>vv.v<<<<<<<<vvv<<<<^^<^<<<<<><^>.>^^>>>>vv.>.>.vvv.v>>>>>>>^^<.<^<<^^^>>>vv>.>.>.>.>v<<v.<.<vv>>>>^^^<<<<<.^.>^^>>>vv>.>v<vvv<<<<^^<.<.<.^^>^^>>>vv>.>.v<<<v.<vv<<<<^^.<^<<<^^^>>>>vvvvvv<<<<<<<<>^^.^>>^^^<>>>>>>>vvv<<<v.vv>>>>>^>>^^<<<<<^>.^^>>>>vv>.>v<<<<vvv<<<^^<.<.<.<^<<<<<^>^^>>>>vv.>vv.v.v<^>.>^.<.^^^^>>>>vv>.>.>.v<<<<<<vvv>>>>^^<.<.<^<<^^<^>>>>>>vv>v<<.vvv^>^^<<<^>^^<<<<<<.vvv<<vv>.v>>>>>>^>.>^^<<<<<^>.>.>.>.>.^^>>>>vv>.>.>v<<<<<vvv<<<<^^<^<<^.^^>>>>vv>.>.>.>v<vvv<<<<<^^.<.<^<<^^^>>>>>>>>>>>vv>.>.>.>.>vvvv<<<<^^.<.<^<^^^<<<<<<vvv<v.<vv<<<<^v>>>>>>>>>>^^^<.^.>.>.^^>>>>vvv<<<<<<<vvv<<<<<<<>^^.<^<.^^^.>>>>vv>v<vvv<>>>>^^.<.^.^.>.^<^>>>>>>>>vvvv.<.<vv<<<<^^^<<<<<^>.^^<.vv>.v<<vvv<<><>>>>>^>>^.<^<^^^<<<.>>vv>.>v<<<<v.vv>^>>^.<^^.^^.>>>>>vv>.>.>.v<v.<vv<<<<<^.^^^.>^^<>>>>>>vv>.v<<<v.<vv<<<<>>>>>>>>>>>^^<.<.<.<.<^<<^^<^<<<>>>>>>>vv>v<<<vv.v>>>>>>>>^>^<.<^<<<<<<<<<<<.^.>^^<<<vvv.v.<vv<<<^.>>^.<^^.>.>^^<<......vv.v>vvv>>>^.v^>>^^<<^^^<.>>>>>>>vvv<v.<.<.vv<<<<^^<.<.<.^^^^<.>>>>>>>>vvv<v.<vv^.>^^<<^^^vv>vvvv^>>>>>>>^^^^^vvvvvv^^^^^^vvvvvv>>>>

Istnieje ponad 8 milionów kombinacji stanów pozycji X czas X zestaw odwiedzonych rogów, więc można je wyczerpująco przeszukać w mniej niż 1 sekundę. Jeśli w kodzie nie ma błędów, jego pokonanie powinno być niemożliwe. Optymalną strategią było użycie całej planszy, ponieważ pozwala żabce przejść 160 razy drogę, w porównaniu do około 120, gdy jest ograniczona do centrum. Odwiedzanie zakrętów nie kosztowało żadnych przejazdów, ponieważ ruch był tak duży.

/* feersum  2014/9
 /codegolf/37975/frogger-champion */

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>
#include <cstring>

#define B(F, CST, X, Y) best[ ((F)*NCST + (CST)) * BS + (Xmax-Xmin+1) * ((Y)-Ymin) + (X)-Xmin]
#define TL(i) ((int)t[i].length())
#define ABSPEED(I) (speed[i]<0?-speed[i]:speed[i])
#define errr(X) { cout<<"ERROR!!!!!!!!"; return X; }

#define DRAW 0
#if DRAW
    #include <unistd.h>
#endif


using namespace std;

int bc(int cs) {
    int c = 0;
    while(cs) {
        c += cs&1;
        cs >>= 1;
    }
    return c;
}

int main()
{
    const bool bonusTwentyfive = false;
    const int COLS = 23, T_ROWS = 5, YGS = T_ROWS + 2, XGS = COLS + 2;
    string t[5];
    int speed[] = {-4, 1, -2, -1, 4};
    ifstream f("t.txt");
    for(int i = 0; i < T_ROWS; i++)
        getline(f, t[i]);
    if(f.fail())
        return 1;
    f.close();
//for(int i = 0; i < 5; i ++)t[i]="xxx";

    char g[XGS][YGS];

    int mov[][3] = { {-1,  0, '<'},
                     {+1,  0, '>'},
                     { 0, -1, '^'},
                     { 0, +1, 'v'},
                     { 0,  0, '.'} };


    int Ymin = 0, Ymax = YGS-1;


    const int Xstart = 11, Xmaxmove = bonusTwentyfive ? 4 : 10;
    const int Xmin = Xstart - Xmaxmove, Xmax = Xstart + Xmaxmove;

    const int NCST = bonusTwentyfive ? 1 : 1<<4;

    int maxfr = 0;
    for(int i = 0; i < T_ROWS; i++) {
        if(speed[i] < 0) {
            for(int m = 0, n = t[i].length()-1; m < n; ++m,--n)
                swap(t[i][m], t[i][n]);
        }
        int carslen = TL(i);
        for(char*c = &t[i][speed[i]>0?TL(i)-1:0]; carslen; carslen--, speed[i]>0?--c:++c)
            if(*c != ' ')
                break;
        if(carslen)
            maxfr = max(maxfr, ( (carslen + COLS) * 2 + ABSPEED(i)-1 ) / ABSPEED(i));
    }
    const int BS = (Xmax-Xmin+1)*(Ymax-Ymin+1);
    int *best = new int[(maxfr+1)*NCST*BS];
    memset(best, 0xFF, (maxfr+1)*NCST*BS*sizeof(int));
    memset(g, ' ', sizeof(g));
    B(0, 0, Xstart, Ymax) = 0;

    for(int fr = 0; fr < maxfr; fr++) {
        for(int r = 0; r < T_ROWS; r++) {
            for(int x = 0; x < XGS; x++) {
                int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                g[x][r+1] = ind >= 0 && ind < TL(r) ? t[r][ind] : ' ';
            }
        }
        for(int x = Xmin; x <= Xmax; x++) {
            for(int y = Ymin; y <= Ymax; y++) {
                if(g[x][y] != ' ')
                    continue;
                for(unsigned m = 0; m < sizeof(mov)/sizeof(mov[0]); m++) {
                    int X = x + mov[m][0], Y = y + mov[m][1];
                    if(X < Xmin || X > Xmax || Y < Ymin || Y > Ymax)
                        continue;
                    if(!(mov[m][0]|mov[m][1]) && y > 0 && y > T_ROWS && g[x][y-speed[y-1]/4] != ' ')
                        continue;

                    int csor = ((X==Xmin|X==Xmax)&(Y==Ymin|Y==Ymax)&!bonusTwentyfive) << ((X==Xmax) + 2*(Y==Ymax));

                    for(int cs = 0; cs < NCST; cs++) {
                        int N = B(fr, cs, x, y);
                        if(!~N)
                            continue;
                        if((!(N&1) && y == 1 && Y == 0) ||
                              (N&1 && y == T_ROWS && Y == T_ROWS+1))
                            ++N;
                        if(N > B(fr+1, cs|csor, X, Y))
                            B(fr+1, cs|csor, X, Y) = N;
                    }


                }
            }
        }
    }

    int score = 0, xb, yb, cb, nb;
    for(int x = Xmin; x <= Xmax; x++) {
        for(int y = Ymin; y <= Ymax; y++) {
            for(int cs = 0; cs < NCST; cs++) {
                if(B(maxfr, cs, x, y) * (40 + bc(cs)) / 40 >= score) {
                    score = B(maxfr, cs, x, y) * (40 + bc(cs)) / 40;
                    xb = x, yb = y, cb = cs, nb = B(maxfr, cs, x, y);
                }
            }
        }
    }
    char *mvs = new char[maxfr+1];
    mvs[maxfr] = 0;

    for(int fr = maxfr-1; fr >= 0; --fr) {
        for(int r = 0; r < T_ROWS; r++) {
            for(int x = 0; x < XGS; x++) {
                int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                g[x][r+1] = ind >= 0 && ind < TL(r) ? t[r][ind] : ' ';
            }
        }
        for(int x = Xmin; x <= Xmax; x++) {
            for(int y = Ymin; y <= Ymax; y++) {
                if(g[x][y] != ' ')
                    continue;

                for(unsigned m = 0; m < sizeof(mov)/sizeof(mov[0]); m++) {
                    int X = x + mov[m][0], Y = y + mov[m][1];
                    if(X < Xmin || X > Xmax || Y < Ymin || Y > Ymax)
                        continue;
                    if(!(mov[m][0]|mov[m][1]) && y > 0 && y > T_ROWS && g[x][y-speed[y-1]/4] != ' ')
                        continue;

                    int csor = ((X==Xmin|X==Xmax)&(Y==Ymin|Y==Ymax)&!bonusTwentyfive) << ((X==Xmax) + 2*(Y==Ymax));

                    for(int cs = 0; cs < NCST; cs++) {
                        int N = B(fr, cs, x, y);
                        if(!~N)
                            continue;
                        if((!(N&1) && y == 1 && Y == 0) ||
                              (N&1 && y == T_ROWS && Y == T_ROWS+1))
                            ++N;
                        if(X==xb && Y==yb && N == nb && (cs|csor) == cb) {
                            mvs[fr] = mov[m][2];
                            xb = x, yb = y, nb = B(fr, cs, x, y), cb = cs;
                            goto fr_next;
                        }
                    }
                }
            }
        }
        errr(3623);
        fr_next:;
    }

    if((xb-Xstart)|(yb-Ymax)|nb)
        errr(789);
    #if DRAW

        for(int fr = 0; fr <= maxfr; ++fr) {
            memset(g, ' ', sizeof(g));
            for(int r = 0; r < T_ROWS; r++) {
                for(int x = 0; x < XGS; x++) {
                    int ind = speed[r] > 0 ? TL(r)-1 + x - fr*speed[r]/2 : x - (XGS-1) - fr*speed[r]/2;
                    ind >= 0 && ind < TL(r) ? g[x][r+1] = t[r][ind] : ' ';
                }
            }
            g[xb][yb] = 'F';
            for(int y = 0; y < YGS; y++) {
                for(int x = 0; x < XGS; x++)
                    cout<<g[x][y];
                cout<<endl;
            }
            cout<<string(XGS,'-')<<endl;
            usleep(55*1000);
            for(int i = 0; i < 5; i++) {
                if(mvs[fr] == mov[i][2]) {
                    xb += mov[i][0];
                    yb += mov[i][1];
                    break;
                }
            }
        }

    #endif
    cout<<score<<endl;
    cout<<mvs<<endl;
}
feersum
źródło
1
Nie jestem pewien, jak definiujesz „stany”. Jeśli weźmiemy pod uwagę stan systemu jako profil czasowy ruchu żaby, istnieje około 5 ^ 3000 stanów, odpowiadających profilowi ​​ruchu dla 5 ^ 3000 możliwych wejść (pięć możliwych wejść na ~ 3000 klatek). Oczywiście tylko niewielka ich część okaże się dopuszczalna, ale liczba dopuszczalnych stanów byłaby niemożliwa do przeszukania o setki rzędów wielkości. Kiedy prześlesz swoją ostateczną odpowiedź, prześlij wraz z nią listę ruchów.
COTO,
Ponadto, w przypadku, gdy nie jest to jasne, zauważ, że żaba może skakać w lewo i prawo podczas ruchu, o ile nie zostanie naruszona żadna z „zgniecionych” zasad. Nie jesteś ograniczony do czekania na okna, w których żaba może przeskakiwać w pionie bez ruchu bocznego.
COTO,
@ COTO W moich obliczeniach „stanów” zapomniałem o ważnej rzeczy, a mianowicie o liczbie przejazdów do tej pory, dlatego starałem się podać jaśniejsze wyjaśnienie. Specyfikacja była dość dobrze napisana. Wygląda na to, że za pierwszym razem poprawnie zinterpretowałem wszystkie te szczególne problemy.
feersum
Obliczam optimum jako 162 + 10% = 178 skrzyżowań, ale twoje jest wystarczająco blisko. Naprawdę nie chciałem, aby okazało się, że jest to siła brutalna, ale najwyraźniej powinienem przemyśleć ten problem. Uczciwie przyznam ci 100 powtórzeń.
COTO,
Najwyraźniej muszę czekać 24 godziny, zanim przyznam „nagrodę”. Z jakiego powodu: kto wie. SE nie może żądać punktualnego nagradzania odpowiedzi. Gdybyśmy to zrobili, terroryści wygraliby. : O
COTO,