Advance Wars, Wargroove ve Fire Emblem gibi sıra tabanlı taktik oyunları, her arazi türü için farklı maliyetler gerektiren farklı hareket sınıfları birimleriyle değişen bir arazi karesinden oluşur. Bu sorunun bir alt kümesini araştıracağız.

Meydan okuma

Göreviniz, arazi maliyetleri ve hareket hızı ızgarası göz önüne alındığında, bir konuma başka bir yerden erişilip erişilemeyeceğini belirlemektir.

Birimler yalnızca bir kareye hareket etmenin maliyeti ızgaradaki karşılık gelen hücrenin değeri olduğu yerde (hareket etmek ücretsizdir) dikey olarak hareket edebilir. Örneğin, 3 değerine sahip bir hücreden, 1 değerine sahip bir hücreye geçmek 1 hareket gerektirir, ancak diğer yöne gitmek için 3 gerekir. Bazı karelere erişilemeyebilir.

Misal

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

Hareketle [1]üzere <1>üç aşağı sonra sağa bir kare ve hareket ettirerek 7 hareket noktalarının en az gerektirir. Bu nedenle, hareket hızı olarak 6 veya daha az verilirse, yanlış bir cevap vermelisiniz.

Örnek Test Durumları

Bunlar ayrışmayı kolaylaştırmak için başlangıç ​​ve bitiş için köşeli ayraçlı hücreler yerine sol üst köşeli sıfır dizinli (satır, sütun) koordinatları kullanır. Ulaşılamayan hücrelerX

Durum 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

Durum 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

Durum 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

Durum 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

Durum 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

Durum 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

Vaka 3a

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

Output: False

Vaka 3b

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

Output: True

Kurallar, Varsayımlar ve Notlar

• Standart boşluklar yasaklanmıştır, G / Ç herhangi bir uygun formatta olabilir
• Tüm koordinatların ızgarada olduğunu varsayabilirsiniz.
• Hareket hızı asla 100'ün üzerinde olmayacak
• Erişilemeyen hücreler, sizin için en uygun olan çok sayıda (örn. 420, 9001, 1 milyon) veya 0 veya null ile temsil edilebilir.
• Tüm girdiler pozitif tamsayılardan oluşur (erişilemeyen hücreleri temsil etmek için null veya 0 kullanılmazsa)

TSQL sorgusu, 205 191 bayt

Girdi @t bir tablo değişkeni

@ x = başlangıç ​​xpos, @ y = başlangıç ​​ypos @ i = bitiş xpos, @ j = bitiş ypos @ = hız

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

Çevrimiçi deneyin ungolfed sürümü

Python 2 , 220 bayt

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]

Çevrimiçi deneyin!

Bir dizi alır molan tamsayılar 'X'bir büyük-daha-100 değeri ;, bir hız olarak a, msahip olan genişlik wve yükseklik h; ve sıfır indeksli satır / sütun hücresinden başlayıp (r,c)son hücreye ulaşabileceğimiz yere döner (R,C).

Algoritma değiştirilmiş bir taşkın dolgusudur. Hafifçe çözülmemiş 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.

JavaScript (ES7),  116  113 bayt

(matrix)([endRow, endCol])(speed, startRow, startCol)$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

Çevrimiçi deneyin!

Yorumlananlar

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

Jöle , 59 bayt

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

Çevrimiçi deneyin!

Çok hızlı değil; hız birimleri bitene kadar tüm yolları dener, hatta adımlarını geri çeker. Ancak bu, alanların ziyaret edilip edilmediğini kontrol etme ihtiyacını ortadan kaldırır. Giriş şu şekilde sağlanır:[nrows, ncols],[start_row, start_col],[end_row, end_col],speed,flattened matrix column-major

açıklama

Yardımcı bağlantı

+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

Ana bağlantı

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

Jöle , 38 bayt

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

Araziyi kabul eden son derece verimsiz bir tam program (101 gibi istenmeyen), başlangıç ​​ve bitiş daha sonra hızı koordine eder.

Çevrimiçi deneyin! (test vakalarının çoğunu denemek çok fazla nokta değil!)

Nasıl?

"Başlangıç ​​ve bitiş hariç tüm arazi konumlarının" güç setinin her birinin tüm permütasyonlarının bir listesini oluşturur, bunların her birini başlangıç ​​ve bitiş ile çevreler, yalnızca bir mesafenin dik hareketlerini yapanlara filtreler, başlangıcı düşürür her birinden, araziye indeksler, her birini toplar, minimum tutar, birini çıkarır ve bunun hızdan daha düşük olduğunu test eder.