Jogos de táticas baseadas em turnos, como Advance Wars, Wargroove e Fire Emblem, são constituídos por uma grade quadrada de terreno variável, com unidades de diferentes classes de movimento, exigindo custos diferentes para cada tipo de terreno. Investigaremos um subconjunto desse problema.

Desafio

Sua tarefa é determinar se um local é acessível a partir de outro, dada uma grade de custos do terreno e uma velocidade de movimento.

As unidades só podem se mover ortogonalmente onde o custo de se mover para um quadrado é o valor da célula correspondente na grade (a saída é gratuita). Por exemplo, mover de uma célula com valor 3 para uma célula com valor 1 custa 1 movimento, mas seguir o caminho requer 3. Alguns quadrados podem estar inacessíveis.

Exemplo

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

Mover de [1]para <1>requer um mínimo de 7 pontos de movimento, movendo para a direita um quadrado e depois para baixo três. Assim, se for dada 6 ou menos como velocidade de movimento, você deverá emitir uma resposta falsa.

Casos de teste de exemplo

Eles usarão coordenadas com índice zero (linha, coluna) de origem superior esquerda, em vez de células entre colchetes, no início e no final, para facilitar a análise. As células inacessíveis serão representadas comX

Caso 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

Caso 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

Caso 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

Caso 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

Caso 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

Caso 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

Caso 3a

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

Output: False

Caso 3b

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

Output: True

Regras, premissas e notas

• As brechas padrão são proibidas, a E / S pode estar em qualquer formato conveniente
• Você pode assumir que as coordenadas estão todas na grade
• A velocidade de movimento nunca será superior a 100
• As células inacessíveis podem ser representadas com números muito grandes (por exemplo, 420, 9001, 1 milhão) ou com 0 ou nulo, o que for mais conveniente para você.
• Todas as entradas consistirão em números inteiros positivos (a menos que seja nulo ou 0 para representar células inacessíveis)

Consulta TSQL, 205 191 bytes

Input é uma variável de tabela @t

@ x = iniciar xpos, @ y = iniciar ypos @ i = final xpos, @ j = final ypos @ = velocidade

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

Experimente a versão online não destruída

Python 2 , 220 bytes

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]

Experimente online!

Leva uma matriz mde números inteiros, com 'X'como um valor maior do que a 100 ;, uma velocidade a, mque tem largura we altura h; e retorna quando pudermos começar na célula de linha / coluna indexada a zero (r,c)e chegar à célula final (R,C).

O algoritmo é um preenchimento modificado. Código ligeiramente não destruído:

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.

JavaScript (ES7),  116  113 bytes

Toma entrada como (matrix)([endRow, endCol])(speed, startRow, startCol). Espera grandes valores para quadrados inacessíveis. Retorna ou .$0$$1$

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

Experimente online!

Comentado

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

Geléia , 59 bytes

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

Experimente online!

Não é terrivelmente rápido; tenta todos os caminhos até que as unidades de velocidade se esgotem, refazendo seus passos. No entanto, isso evita a necessidade de verificar se os espaços são visitados. A entrada é fornecida como[nrows, ncols],[start_row, start_col],[end_row, end_col],speed,flattened matrix column-major

Explicação

Link auxiliar

+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

Link principal

ç             | 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

Gelatina , 38 bytes

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

Um programa completo extremamente ineficiente que aceita o terreno (com os invisíveis como 101), em seguida, o início e o fim coordenam a velocidade.

Experimente online! (não faz muito sentido tentar a maioria dos casos de teste!)

Quão?

Cria uma lista de todas as permutações de cada um dos conjuntos de potência de "locais para todos os terrenos, exceto o início e o fim", envolve cada um deles com o início e o fim, filtros para aqueles que fazem apenas movimentos ortogonais da distância um, diminuem o início de cada um, indexa de volta ao terreno, soma cada um, pega o mínimo, subtrai um e testa que isso é menor que a velocidade.