Khả năng tiếp cận địa hình


12

Các trò chơi chiến thuật theo lượt như Advance Wars, Wargroove và Fire Badge được tạo thành từ một lưới vuông có địa hình khác nhau với các đơn vị thuộc các lớp chuyển động khác nhau đòi hỏi chi phí khác nhau cho từng loại địa hình. Chúng tôi sẽ điều tra một tập hợp con của vấn đề đó.

Thử thách

Nhiệm vụ của bạn là xác định xem một địa điểm có thể tiếp cận được từ một địa điểm khác với một chi phí địa hình và tốc độ di chuyển hay không.

Các đơn vị chỉ có thể di chuyển trực giao trong đó chi phí di chuyển lên một hình vuông là giá trị của ô tương ứng trên lưới (di chuyển ra là miễn phí). Chẳng hạn, việc di chuyển từ một ô có giá trị 3 lên một ô có giá trị 1 chuyển động 1, nhưng đi theo cách khác đòi hỏi 3. Một số ô vuông có thể không truy cập được.

Thí dụ

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

Di chuyển từ [1]đến <1>yêu cầu tối thiểu 7 điểm di chuyển bằng cách di chuyển sang phải một hình vuông và sau đó xuống ba điểm. Do đó, nếu được đưa ra 6 hoặc ít hơn tốc độ di chuyển, bạn nên đưa ra câu trả lời sai lệch.

Ví dụ trường hợp kiểm tra

Chúng sẽ sử dụng các tọa độ không có chỉ mục (hàng, cột) có nguồn gốc từ trên bên trái thay vì các ô được đặt dấu ngoặc để bắt đầu và kết thúc để phân tích cú pháp dễ dàng hơn. Các ô không thể truy cập sẽ được đại diện vớiX

Trường hợp 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

Trường hợp 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

Trường hợp 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

Trường hợp 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

Trường hợp 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

Trường hợp 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

Trường hợp 3a

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

Output: False

Trường hợp 3b

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

Output: True

Quy tắc, giả định và ghi chú

  • Các lỗ hổng tiêu chuẩn bị cấm, I / O có thể ở bất kỳ định dạng thuận tiện nào
  • Bạn có thể giả sử tọa độ là tất cả trên lưới
  • Tốc độ di chuyển sẽ không bao giờ vượt quá 100
  • Các ô không thể truy cập có thể được biểu diễn với số lượng rất lớn (ví dụ 420, 9001, 1 triệu) hoặc bằng 0 hoặc null, tùy theo điều kiện nào thuận tiện nhất cho bạn.
  • Tất cả các đầu vào sẽ bao gồm các số nguyên dương (trừ khi sử dụng null hoặc 0 để thể hiện các ô không thể truy cập)

1
@LuisfelipeDejesusMunoz "Những thứ này sẽ sử dụng tọa độ không có chỉ số (hàng, cột) gốc trái"
Beefster

Bạn nói I / O có thể ở bất kỳ định dạng thuận tiện. Có bao gồm, ví dụ, một danh sách / mảng có kích thước không? Tôi tin rằng điều đó thường được cho phép, nhưng nó chắc chắn tiết kiệm rất nhiều byte qua việc phân tích chuỗi.
dfeuer

@dfeuer, vâng tất nhiên
Beefster

Tôi đã tải xuống các cuộc chiến nâng cao trên trình giả lập điện thoại của mình ... Tôi rất buồn vì nó buộc bạn phải thực hiện 13 cấp độ hướng dẫn ... Tôi muốn phát lại nó rất tệ nhưng sự kiên nhẫn của tôi là giấy mỏng để làm rối hướng dẫn trên các hệ thống cũ.
Bạch tuộc ma thuật Urn

Câu trả lời:


2

Truy vấn TSQL, 205 191 byte

Đầu vào là một biến bảng @t

@ x = start xpose, @ y = start ypose @ i = end xpose, @ j = end ypose @ = speed

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

Dùng thử phiên bản không có bản quyền


0

Python 2 , 220 byte

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]

Hãy thử trực tuyến!

Có một mảng mcác số nguyên, với 'X'giá trị lớn hơn 100, tốc độ a, mcó chiều rộng wvà chiều cao h; và trả về khi chúng ta có thể bắt đầu tại ô hàng / cột được lập chỉ mục bằng không (r,c)và đến ô cuối cùng (R,C).

Thuật toán là một vùng lũ được sửa đổi. Mã hơi vô căn 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.

0

JavaScript (ES7),  116  113 byte

(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

Hãy thử trực tuyến!

Đã bình luận

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

Thạch , 59 byte

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

Hãy thử trực tuyến!

Không nhanh khủng khiếp; thử tất cả các đường dẫn cho đến khi các đơn vị tốc độ cạn kiệt, thậm chí lùi lại các bước của nó. Tuy nhiên, điều này tránh sự cần thiết phải kiểm tra xem có phải là không gian được truy cập hay không. Đầu vào được cung cấp như[nrows, ncols],[start_row, start_col],[end_row, end_col],speed,flattened matrix column-major

Giải trình

Liên kết trợ giúp

+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

Liên kết chính

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

Thạch , 38 byte

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

Một chương trình đầy đủ cực kỳ kém hiệu quả chấp nhận địa hình (với unvisitables là 101) sau đó bắt đầu và kết thúc tọa độ sau đó là tốc độ.

Hãy thử trực tuyến! (không có nhiều điểm thử hầu hết các trường hợp thử nghiệm!)

Làm sao?

Tạo một danh sách tất cả các hoán vị của từng tập hợp sức mạnh của "tất cả các vị trí địa hình ngoại trừ điểm bắt đầu và kết thúc", bao quanh mỗi vị trí này với điểm bắt đầu và kết thúc, các bộ lọc chỉ thực hiện các chuyển động trực giao của khoảng cách một, giảm điểm bắt đầu từ mỗi, lập chỉ mục trở lại địa hình, tính tổng từng điểm, lấy mức tối thiểu, trừ đi một và kiểm tra xem giá trị này nhỏ hơn tốc độ.

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.