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!


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;
}

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,
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.