Zasięg terenu


12

Turowe gry taktyczne, takie jak Advance Wars, Wargroove i Fire Emblem, składają się z kwadratowej siatki o zróżnicowanym terenie z jednostkami o różnych klasach ruchu, wymagającymi różnych kosztów dla każdego rodzaju terenu. Będziemy badać podzbiór tego problemu.

Wyzwanie

Twoim zadaniem jest ustalenie, czy do jednej lokalizacji można dotrzeć z innej, biorąc pod uwagę siatkę kosztów terenu i prędkość ruchu.

Jednostki mogą poruszać się ortogonalnie tylko wtedy, gdy koszt przejścia na kwadrat jest wartością odpowiedniej komórki na siatce (ruszenie jest bezpłatne). Na przykład przejście z komórki o wartości 3 na komórkę o wartości 1 kosztuje 1 ruch, ale przejście w drugą stronę wymaga 3. Niektóre kwadraty mogą być niedostępne.

Przykład

1 [1] 1  1  1
1  2  2  3  1
2  3  3  3  4
1  3 <1> 3  4

Przejście z [1]do <1>wymaga minimum 7 punktów ruchu, przesuwając się w prawo o jedno pole, a następnie o trzy w dół. Tak więc, jeśli podano 6 lub mniej jako prędkość ruchu, powinieneś dać odpowiedź fałszywą.

Przykładowe przypadki testowe

Będą one używać współrzędnych zero-indeksowanych od lewej do góry (wiersz, kolumna) zamiast komórek w nawiasach początkowych i końcowych, aby ułatwić analizę. Nieosiągalne komórki będą reprezentowane przezX

Przypadek 1a

1 1 2 1 X
1 2 2 1 1
2 1 1 2 1
X X X 1 2
Speed: 5
From (2, 3) to (0, 1)

Output: True

Przypadek 1b

1 1 2 1 X
1 2 2 1 1
2 1 1 2 1
X X X 1 2
Speed: 4
From (2, 3) to (0, 1)

Output: False

Przypadek 1c

1 1 2 1 X
1 2 2 1 1
2 1 1 2 1
X X X 1 2
Speed: 5
From (0, 1) to (2, 3)

Output: False

Przypadek 2a

3 6 1 1 X 4 1 2 1 X
5 1 2 2 1 1 1 X 1 5
2 1 1 1 2 1 1 1 X 1
2 1 1 3 1 2 3 4 1 2
1 1 2 1 1 4 1 1 1 2
3 2 3 5 6 1 1 X 1 4
Speed: 7
From (3, 4) to (2, 1)

Output: True

Przypadek 2b

3 6 1 1 X 4 1 2 1 X
5 1 2 2 1 1 1 X 1 5
2 1 1 1 2 1 1 1 X 1
2 1 1 3 1 2 3 4 1 2
1 1 2 1 1 4 1 1 1 2
3 2 3 5 6 1 1 X 1 4
Speed: 4
From (3, 4) to (2, 1)

Output: False

Przypadek 2c

3 6 1 1 X 4 1 2 1 X
5 1 2 2 1 1 1 X 1 5
2 1 1 1 2 1 1 1 X 1
2 1 1 3 1 2 3 4 1 2
1 1 2 1 1 4 1 1 1 2
3 2 3 5 6 1 1 X 1 4
Speed: 7
From (1, 8) to (2, 7)

Output: True

Przypadek 3a

2 1 1 2
2 3 3 1
Speed: 3
From (0, 0) to (1, 1)

Output: False

Przypadek 3b

2 1 1 2
2 3 3 1
Speed: 3
From (1, 1) to (0, 0)

Output: True

Reguły, założenia i uwagi

  • Standardowe luki są zabronione, wejścia / wyjścia mogą mieć dowolny dogodny format
  • Możesz założyć, że wszystkie współrzędne są na siatce
  • Prędkość ruchu nigdy nie przekroczy 100
  • Niedostępne komórki mogą być reprezentowane przez bardzo duże liczby (np. 420, 9001, 1 milion) lub przez 0 lub zero, w zależności od tego, co jest dla ciebie najwygodniejsze.
  • Wszystkie dane wejściowe będą składać się z dodatnich liczb całkowitych (chyba że użyjemy null lub 0 do reprezentowania nieosiągalnych komórek)

1
@LuisfelipeDejesusMunoz „Będą używać współrzędnych zero-indeksowanych (wiersz, kolumna) u góry po lewej stronie”
Beefster

Mówisz, że I / O może być w dowolnym dogodnym formacie. Czy obejmuje to na przykład listę / tablicę z wymiarami? Uważam , że jest to zwykle dozwolone, ale zdecydowanie oszczędza dużo bajtów podczas analizowania łańcucha.
dfeuer

@dfeuer, tak, oczywiście
Beefster

Pobrałem zaawansowane wojny na emulatorze telefonu ... Jestem tak smutny, że zmusza cię to do zrobienia 13 poziomów samouczków ... Chciałem bardzo go odtworzyć, ale moja cierpliwość jest cienka jak papier dla samouczków samouczków na starych systemach.
Magic Octopus Urn

Odpowiedzi:


2

Zapytanie TSQL, 205 191 bajtów

Dane wejściowe to zmienna tabelowa @t

@ x = start xpos, @ y = start ypos @ i = koniec xpos, @ j = koniec ypos @ = prędkość

DECLARE @t table(x int,y int,v int)
INSERT @t
values
(0,0,1),(0,1,1),(0,2,2),(0,3,1),(0,4,null),
(1,0,1),(1,1,2),(1,2,2),(1,3,1),(1,4,1),
(2,0,2),(2,1,1),(2,2,1),(2,3,2),(2,4,1),
(3,0,null),(2,1,null),(2,2,null),(2,3,1),(2,4,2)

DECLARE @x INT=2,@y INT=3,@i INT=0,@j INT=1,@ INT=5;

WITH C as(SELECT @y f,@x r,@ s
UNION ALL
SELECT f+a,r+b,s-v FROM C
JOIN(values(1,0),(0,1),(-1,0),(0,-1))x(a,b)ON
s>0JOIN @t
ON f+a=x and r+b=y)SELECT
max(iif(S>=0and f=@j and r=@i,1,0))FROM c

Wypróbuj wersję online bez golfa


0

Python 2 , 220 bajtów

def f(m,a,w,h,r,c,R,C):
 T=[w*[999]for _ in' '*h];T[r][c]=0;P=[(r,c)];j,k=1,0
 for u,v in P:exec"U,V=u+j,v+k;j,k=-k,j\nif h>U>-1<V<w:q=T[U][V];T[U][V]=min(T[u][v]+m[U][V],q);P+=[(U,V)]*(q>T[U][V])\n"*4
 return a>=T[R][C]

Wypróbuj online!

Bierze tablicę mliczb całkowitych, a 'X'jako większy niż wartość 100 ;, prędkości a, mo szerokości wi wysokości h; i zwraca, gdzie możemy zacząć od zindeksowanej komórki wiersza / kolumny (r,c)i przejść do ostatniej komórki (R,C).

Algorytm jest zmodyfikowanym wypełnieniem zalewowym. Nieco golfowy kod:

def f(m,a,w,h,r,c,R,C):
 T = [w*[999]for _ in ' '*h] # make an array same size as m, with all 
                             #   values 999, whose values will represent
                             #   the cost of getting to each cell.
 T[r][c] = 0                 # set the starting location to a cost of 0
 P = [(r,c)]                 # initialize a set of cells whose neighbors'
                             #   cost might need to be be updated
 j,k = 1,0                   # and also j,k which will take on values:
                             #  (1,0), (0,1), (-1,0), (0,1), used to 
                             #  probe orthogonal neighbors
 for u,v in P:               # scan the cells in P
    for _ in '1234':         # look at each of 4 orthogonal positions
        U,V = u+j,v+k        # U and V get the indexes of a neighbor 
                             #   of the current cell.
        j,k = -k,j           # this 'rotates' the j,k pairing.
        if h>U>-1<V<w:       # if the coordinates are in bounds...
            q = T[U][V]      # save the current 'cost' of getting to cell (U,V)
                             # see if we can reduce that cost, which is calculated 
                             #   by taking the cost of the currently scanned cell 
                             #   + the value from m for the neighbor cell. 
            T[U][V] = min(T[u][v]+m[U][V] ,q)
                             # if we can reduce the cost, add the neighbor
                             #   to P because **it's** neighbors might,
                             #   in turn, need updating.
            P += [(U,V)]*(q>T[U][V])
 return a>=T[R][C]           # return if speed is enough for the cost.

0

JavaScript (ES7),  116  113 bajtów

(matrix)([endRow, endCol])(speed, startRow, startCol)01

m=>e=>o=g=(s,y,x)=>m.map((r,Y)=>r.map((v,X)=>r[s<v|(x-X)**2+(y-Y)**2-1||g(s-v,Y,X,r[X]=1/0),X]=v),o|=y+[,x]==e)|o

Wypróbuj online!

Skomentował

m =>                        // m[] = matrix
e =>                        // e[] = target coordinates
  o =                       // o   = success flag, initialized to a non-numeric value
  g = (                     // g   = recursive depth-first search function taking:
    s,                      //   s    = speed
    y, x                    //   y, x = starting coordinates
  ) =>                      //
    m.map((r, Y) =>         // for each row r[] at position Y in m[]:
      r.map((v, X) =>       //   for each value v at position X in r[]:
        r[                  //     this statement ultimately updates r[X]:
          s < v |           //       abort if s is less than v
          (x - X) ** 2 +    //       or the quadrance between (x, y)
          (y - Y) ** 2 - 1  //       and (X, Y) is not equal to 1
          || g(             //       otherwise, do a recursive call to g:
               s - v,       //         subtract v from s
               Y, X,        //         pass (Y, X) as the new coordinates
               r[X] = 1 / 0 //         temporarily make this cell unreachable
             ),             //       end of recursive call 
          X                 //       restore r[X] ...
        ] = v               //     ... to its original value
      ),                    //   end of inner map()
      o |= y + [, x] == e   //   set the flag o if (y + ',' + x) matches (e + '')
    ) | o                   // end of outer map(); return o

0

Galaretka , 59 bajtów

+2¦µ_2ịæ.ؽœị$Ʋ+5ịƲ$4¦01Ñḣ3Ḋ⁼/Ɗ?ḣ2=/ẸƊoF<0ẸƊƊ?
çⱮØ.,U$;N$¤Ẹ

Wypróbuj online!

Niezbyt szybko; wypróbowuje wszystkie ścieżki, aż jednostki prędkości zostaną wyczerpane, nawet cofając się o krok. Pozwala to jednak uniknąć konieczności sprawdzania, czy miejsca są odwiedzane. Dane wejściowe są dostarczane jako[nrows, ncols],[start_row, start_col],[end_row, end_col],speed,flattened matrix column-major

Wyjaśnienie

Link pomocnika

+2¦                                       | add the right argument to the second item in the left argument (current location)
   µ                                      | start a new monadic chain with the modified left argument
                    4¦                    | for the fourth item (speed)...
    _                                     |   subtract...
                 ịƲ$                      |     the item located at...
     2ịæ.ؽœị$Ʋ                           |       the dot product of the current position and (number of columns,
                                          |       right-padded with 1)
               +5                         |       plus five
                                        ? | Now, if...
                                       Ɗ  |   next three as a monad
                           ḣ2=/ẸƊ         |   either current row or current column are equal to nrows/ncolumns respectively
                                 o        | or
                                  F<0ẸƊ   |   any value is negative
                 0                        | return zero
                          ?               | else if...
                   ḣ3Ḋ⁼/Ɗ                 | the second and third items (current and end pos) are equal
                  1                       | return 1
                   Ñ                      | else pass the current list back to the main link

Główny link

ç             | call the helper link with the current list...
 Ɱ            |   and each of
  Ø.,U$;N$¤   |   [0,1],[1,0],[0,-1],[-1,0]
           Ẹ  | Check if any are true

0

Galaretka , 38 bajtów

ạƝṢ€Ḅ’¬Ạ
ŒṪ’ḟŒPŒ!€ẎW€j¥@€ÇƇḊ€‘œị⁸§Ṃ’<⁵

Niezwykle nieefektywny pełny program akceptujący teren (z niewidocznymi jak 101), a następnie początkową i końcową koordynuje następnie prędkość.

Wypróbuj online!(nie ma sensu próbować większości przypadków testowych!)

W jaki sposób?

Tworzy listę wszystkich permutacji dla każdego zestawu sił „wszystkich lokalizacji terenu z wyjątkiem początku i końca”, otacza każdą z nich początkiem i końcem, filtruje te, które wykonują tylko ortogonalne ruchy na odległość 1, opuszcza początek z każdego indeksuje z powrotem w teren, sumuje każdy, przyjmuje minimum, odejmuje jeden i sprawdza, czy jest to prędkość mniejsza niż prędkość.

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.