เกมที่ใช้กลยุทธ์หันเช่น Advance Wars, Wargroove และ Fire Emblem ประกอบด้วยตารางสี่เหลี่ยมของภูมิประเทศที่แตกต่างพร้อมหน่วยการเรียนการเคลื่อนไหวที่แตกต่างกันซึ่งต้องใช้ต้นทุนที่แตกต่างกันสำหรับแต่ละภูมิประเทศ เราจะตรวจสอบชุดย่อยของปัญหานั้น

ท้าทาย

งานของคุณคือการพิจารณาว่าสถานที่แห่งหนึ่งสามารถเข้าถึงได้จากอีกแห่งหนึ่งโดยกำหนดตารางค่าภูมิประเทศและความเร็วในการเคลื่อนที่

หน่วยสามารถเคลื่อนที่แบบตั้งฉากได้โดยที่ค่าใช้จ่ายในการเคลื่อนย้ายไปยังจตุรัสเป็นค่าของเซลล์ที่สอดคล้องกันบนกริด (การย้ายออกฟรี) ตัวอย่างเช่นการย้ายจากเซลล์ที่มีค่า 3 ไปยังเซลล์ที่มีค่า 1 การเคลื่อนไหว 1 แต่ไปในทางอื่นต้องใช้ 3 สี่เหลี่ยมบางอย่างอาจไม่สามารถเข้าถึงได้

ตัวอย่าง

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

การย้ายจาก[1]ไปยัง<1>ต้องการจุดเคลื่อนที่อย่างน้อย 7 จุดโดยเลื่อนไปทางขวาหนึ่งช่องจากนั้นเลื่อนลงสามจุด ดังนั้นถ้าให้ความเร็วการเคลื่อนที่ 6 หรือน้อยกว่าคุณควรเอาท์พุทคำตอบที่ผิดพลาด

ตัวอย่างกรณีทดสอบ

สิ่งเหล่านี้จะใช้พิกัด zero-left-origin-indexed (แถว, คอลัมน์) แทนที่จะเป็นเซลล์ที่มีวงเล็บสำหรับการเริ่มต้นและสิ้นสุดเพื่อให้การแยกวิเคราะห์ง่ายขึ้น เซลล์ที่เข้าไม่ถึงจะถูกแสดงด้วยX

กรณีที่ 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

กรณีที่ 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

กรณีที่ 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

กรณีที่ 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

กรณีที่ 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

กรณีที่ 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

กรณีที่ 3a

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

Output: False

กรณีที่ 3b

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

Output: True

กฎข้อสมมติฐานและหมายเหตุ

• ช่องโหว่มาตรฐานถูกแบน I / O สามารถอยู่ในรูปแบบใดก็ได้
• คุณอาจถือว่าพิกัดอยู่ในตารางทั้งหมด
• ความเร็วในการเคลื่อนที่จะไม่เกิน 100
• เซลล์ที่เข้าไม่ถึงนั้นอาจมีจำนวนมาก (เช่น 420, 9001, 1 ล้าน) หรือมี 0 หรือ null แล้วแต่ว่าวิธีไหนจะสะดวกที่สุดสำหรับคุณ
• อินพุตทั้งหมดจะประกอบด้วยจำนวนเต็มบวก (เว้นแต่ใช้ null หรือ 0 เพื่อแทนเซลล์ที่ไม่สามารถเข้าถึงได้)

ข้อความค้นหา TSQL, 205 191 ไบต์

อินพุตเป็นตัวแปรตาราง @t

@ x = เริ่ม xpos, @ y = เริ่ม ypos @ i = จุดสิ้นสุด xpos, @ j = จุดสิ้นสุด ypos @ = ความเร็ว

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

ลองใช้เวอร์ชันที่ไม่ได้ออนไลน์

Python 2 , 220 ไบต์

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]

ลองออนไลน์!

ใช้เวลาอาร์เรย์mของจำนวนเต็มมี'X'เป็นขนาดใหญ่กว่า 100 คุ้มค่า ;, ความเร็วa, mมีความกว้างwและความสูงh; และผลตอบแทน whteher เราสามารถเริ่มต้นที่แถวถือเป็นศูนย์การจัดทำดัชนี / คอลัมน์และได้รับไปยังเซลล์สุดท้าย(r,c)(R,C)

อัลกอริทึมคือการเติมน้ำท่วมที่แก้ไข รหัสที่ไม่ได้รับเกียรติเล็กน้อย:

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 ไบต์

(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

ลองออนไลน์!

แสดงความคิดเห็น

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

เยลลี่ , 59 ไบต์

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

ลองออนไลน์!

ไม่เร็วอย่างน่ากลัว ลองเส้นทางทั้งหมดจนกว่าหน่วยความเร็วจะหมดแม้จะย้อนกลับขั้นตอน อย่างไรก็ตามนี่เป็นการหลีกเลี่ยงความจำเป็นในการตรวจสอบว่ามีการเยี่ยมชมช่องว่าง ป้อนข้อมูลให้เป็น[nrows, ncols],[start_row, start_col],[end_row, end_col],speed,flattened matrix column-major

คำอธิบาย

ลิงค์ผู้ช่วยเหลือ

+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

ลิงค์หลัก

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

เยลลี่ , 38 ไบต์

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

โปรแกรมเต็มรูปแบบที่ไม่มีประสิทธิภาพอย่างมากยอมรับภูมิประเทศ (ที่ไม่สามารถมองเห็นได้คือ 101) จากนั้นจุดเริ่มต้นและจุดสิ้นสุดจะประสานกับความเร็ว

ลองออนไลน์! (ไม่มากนักที่พยายามทดสอบกรณีส่วนใหญ่!)

อย่างไร?

สร้างรายการการเรียงสับเปลี่ยนทั้งหมดของแต่ละชุดกำลังของ "ตำแหน่งภูมิประเทศทั้งหมดยกเว้นจุดเริ่มต้นและจุดจบ" ล้อมรอบแต่ละจุดด้วยจุดเริ่มต้นและจุดสิ้นสุดตัวกรองไปยังตำแหน่งที่ทำให้การเคลื่อนที่แบบออโธกอนอลของระยะทางหนึ่งลดลง จากแต่ละดัชนีกลับเข้าไปในภูมิประเทศผลรวมแต่ละอย่างใช้เวลาน้อยที่สุดลบหนึ่งและทดสอบว่านี่คือน้อยกว่าความเร็ว