Đưa ra một lưới các hướng và một vị trí bắt đầu và kết thúc, xác định số lượng thay thế tối thiểu trong lưới hướng cần được thực hiện để hoàn thành đường dẫn giữa hai điểm. Lưới là hình trụ đôi. Điều này rõ ràng hơn được đưa ra một ví dụ.

Thí dụ

Hãy lấy lưới sau đây làm ví dụ:

>>>>v
>>>><
<<<<<

Chúng ta hãy bắt đầu tại (1, 1)và kết thúc tại (1, 3)(nơi tọa độ là (x, y)hoặc (col, row), với hàng trên cùng và cột bên trái 1). Sau đó, một giải pháp khả thi là thay thế (1, 1)và (1, 2)bằng v, để lưới cuối cùng trông như thế này:

v>>>v
v>>><
<<<<<

Bắt đầu từ (1, 1), con đường sẽ dẫn chúng ta đến (1, 3). Tuy nhiên, một giải pháp ngắn hơn tồn tại, đó là thay thế (5, 2)bằng v, vì vậy lưới cuối cùng là đây:

>>>>v
>>>>v
<<<<<

Bắt đầu từ (1, 1), một con đường khá dài dẫn đến (1, 3).

Thay thế bất cứ điều gì ở hàng trên cùng với ^công việc quá (cảm ơn @Spitemaster).

Đầu vào

Đầu vào sẽ bao gồm một lưới hình chữ nhật gồm 4 giá trị có thể, cũng như hai tọa độ. Bạn có thể lấy lưới ở bất kỳ định dạng hợp lý nào; ví dụ: ma trận ký tự hoặc số nguyên, danh sách chuỗi, v.v. Bạn cũng có thể yêu cầu kích thước của lưới. Bạn có thể lấy tọa độ ở bất kỳ định dạng hợp lý nào; ví dụ: cặp số nguyên, số phức, v.v. Bạn có thể chọn lập chỉ mục 0 hoặc 1.

Đầu ra

Đầu ra phải là một số nguyên duy nhất, số lần thay thế lưới tối thiểu cần thiết để đóng đường dẫn từ đầu đến cuối.

Quy tắc và thông số kỹ thuật

• Áp dụng sơ hở tiêu chuẩn
• lưới có dạng hình trụ đôi, có nghĩa là di chuyển từ trên xuống dưới, bên trái từ bên trái đi bên phải, v.v.

Trường hợp mẫu

Các trường hợp mẫu được đưa ra dưới dạng ma trận ký tự và tọa độ 1 chỉ mục.

Trường hợp 1

Đầu vào

>>>>v
>>>><
<<<<<
1 1
1 3

Đầu ra

1

Giải trình

Xem ví dụ.

Trường hợp 2

Đầu vào

<<<<<
v>v>v
>>>>>
1 1
5 3

Đầu ra

1

Giải trình

Bạn có thể thay thế (1, 1)bằng vhoặc (2, 1)bằng v. Trong trường hợp đầu tiên, bắt đầu từ (1, 1), đường dẫn đi thẳng xuống và sau đó đến bên phải đến đích. Trong trường hợp thứ hai, đường dẫn vòng từ trái sang phải, đến (2, 1), đi xuống, phải, xuống, và sau đó phải cho đến khi đến đích.

Trường hợp 3

Đầu vào

^^^^^^
><<>>>
vvvvvv
2 2
5 2

Đầu ra

2

Giải trình

Thay đổi tốt nhất là làm cho hàng trung tâm bao quanh bên trái đến điểm; nghĩa là tạo các mục đầu tiên và cuối cùng trong hàng trung tâm <. Hoặc, làm 2 2và 3 2cả hai >.

Đây là một thử thách chơi gôn , vì vậy mã ngắn nhất sẽ thắng!

JavaScript (ES6),  140  135 byte

Đưa đầu vào như (a, width, height, x1, y1)(x0, y0)nơi a[]là một ma trận các số nguyên và tất cả các tọa độ là 0-lập chỉ mục.

$-2$$-1$$0$$1$

(a,w,h,X,Y)=>m=g=(x,y,n=0,r=a[y%=h],v=r[x%=w])=>x-X|y-Y?[-1,0,1,2].map(d=>r[v<2&&g(x+w+d%(r[x]=2),y+h+--d%2,n+(v!=d)),x]=v)|m:m=m<n?m:n

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

Làm sao?

$(x,y)$$(X,Y)$

$n$

$m$$n$

Thạch , 73 72 byte

W,0+Ɱ⁴PṬ€×Ɱ3¤Ẏ¤,€ɗ/€Ẏ$‘ƭ€ịØ.,N;U$¤;ɗ/0ị+æ.Ɱ⁴‘Ṫịʋ¥Ɗ%⁴ṭƲ⁴P¤¡ŒHṪe¥/Ʋ€Ẹ¬Ɗ/¿Ṫ

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

Ví dụ sử dụng trường hợp 3 yêu cầu hai thay đổi (cũng có chân trang để dịch ><v^thành số).

Một chương trình đầy đủ mong đợi các đối số sau đây:

• Bên trái: danh sách hai danh sách; đầu tiên, lưới hướng phẳng được mã hóa là 1 = phải, 2 = trái, 3 = xuống, 4 = lên, theo sau là danh sách vị trí kết thúc và vị trí bắt đầu dưới dạng chỉ mục 0 [hàng, cột]. Ví dụ đầu tiên , [1,1,1,1,3,1,1,1,1,4,2,2,2,2,2],[[2,0],[0,0]].

• Phải: danh sách số lượng hàng theo sau là cột. Ví dụ đầu tiên[3,5]

Trả về số lượng thay đổi cần thiết để có được từ đầu đến cuối. Chậm một lần điều này là nhiều hơn một thay đổi. Trên TIO, trường hợp ví dụ thứ ba mất khoảng. 30 giây để hoàn thành.

Giải thích đầy đủ bên dưới, nhưng tổng quan là:

1. Khởi tạo một bộ đếm về không.
2. $\mathit{row} × \mathit{column}$
3. Kiểm tra nếu vị trí kết thúc được bao gồm:
   • $3 × \mathit{row} × \mathit{column}$ phiên bản mới của lưới, mỗi phiên bản có một vị trí lưới duy nhất thay đổi thành một trong ba di chuyển thay thế có thể. Sau đó quay lại bước 2.
   • Nếu đúng, chấm dứt và xuất bộ đếm

Giải thích đầy đủ:

W,0 | Wrap input in a list, and then pair with 0 (thus initialising the counter)


                                           Ɗ/¿ | While the following is true for the first item of the input pair (i.e. the list of all grids to be tested, paired with the end and start grid positions):
                                       Ʋ€      | - For each member of the list:
          ɗ/                                   |   - Reduce using the following as a dyad (so left argument is flattened grid and right is end/start positions)
ị       ¤                                      |     - Index into the following as a nilad
 Ø.                                            |       - [0, 1]
   ,N                                          |       - Pair with negative [[0, 1], [0, -1]]
     ;U$                                       |       - Concatenate to upended version of this [[0, 1], [0, -1], [1, 0], [-1, 0]]
         ;                                     |     - Concatenate (to end/start positions)
                            Ʋ⁴P¤¡              |   - Repeat the following links the number of times indicated by the product of the grid dimensions:
                        Ɗ                      |     - Following as a monad:
            0ị                                 |       - Last item (current grid position)
              +        ¥                       |       - Add to the following as a dyad:
               æ.Ɱ⁴                            |         - Dot product of current position with each of grid dimensions
                   ‘                           |         - Increase by 1
                    Ṫ                          |         - Tail (which is current position in flattened grid)
                     ị                         |         - index into flattened grid
                         %⁴                    |        - Mod grid dimensions
                           ṭ                   |        - Tack onto end of current grid/position list
                                 ŒH            |   - Split into halves (first half will be flattened grid and desired end position, second half will be all positions reached after moving through grid)
                                     ¥/        |   - Following as a dyad, with the first half from above step as left argument and the second half as right
                                   Ṫ           |     - Tail (i.e. the desired end position)
                                    e          |     - Exists within (the list of all positions reached)
                                         Ẹ¬    | - Not true for any of the input grids


                    ƭ€ | For each of the pair (list of grids, counter), do one of the following:
                  $    | - For the list of grids, do the following as a monad:
              ɗ/€      |   - Do the following as a dyad, with the flattened grid as the left argument and end/start positions as the right:
+Ɱ                     |     - Add to the flattened grid list each of:
           ¤           |       - The following as a nilad
         ¤             |         - The following as a nilad:
  ⁴P                   |           - The product of the grid dimensions
    Ṭ€                 |           - Convert each (using an implicit range from 1 to the grid dimension product) to a boolean list with a 1 at the relevant position (i.e. [[1], [0, 1], [0, 0, 1]...])
      ×Ɱ3              |           - Multiply by each of 1..3
          Ẏ            |        - Flatten to a single list of lists
            ,€         |    - Pair each with the end/start positions
                 Ẏ     |   - Tighten to a single list of grids paired with end/start positions
                   ‘   | - For the counter increment it


Ṫ | Finally, take the tail (which is the final value of the counter)