Diberi kisi-kisi arah dan posisi awal dan akhir, tentukan jumlah minimum penggantian dalam kisi arah yang perlu dibuat untuk menyelesaikan jalur antara dua titik. Kisi-kisi adalah dua silinder. Ini lebih jelas diberi contoh.

Contoh

Mari kita ambil kotak berikut sebagai contoh:

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

Mari kita mulai dari (1, 1)dan berakhir pada (1, 3)( di mana koordinat berada (x, y)atau (col, row), dengan baris atas dan kolom kiri berada 1). Kemudian, satu solusi yang mungkin adalah mengganti (1, 1)and (1, 2)dengan v, sehingga kisi terakhir terlihat seperti ini:

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

Mulai dari (1, 1), jalan menuju kita (1, 3). Namun, ada solusi yang lebih pendek, yang akan diganti (5, 2)dengan v, jadi kisi terakhir adalah ini:

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

Mulai dari (1, 1), jalan yang agak panjang menuju (1, 3).

Mengganti apa pun di baris atas dengan ^karya juga (terima kasih @Spitemaster).

Memasukkan

Input akan terdiri dari kisi-kisi empat kemungkinan nilai, serta dua koordinat. Anda dapat mengambil kotak dalam format apa pun yang masuk akal; misalnya, karakter atau matriks integer, daftar string, dll. Anda juga dapat meminta dimensi kisi. Anda dapat mengambil koordinat dalam format apa pun yang wajar; misalnya, pasangan bilangan bulat, bilangan kompleks, dll. Anda dapat memilih pengindeksan 0 atau 1.

Keluaran

Output harus berupa bilangan bulat tunggal, jumlah minimal penggantian grid yang diperlukan untuk menutup jalur dari awal hingga akhir.

Aturan dan Spesifikasi

• Celah Standar Berlaku
• kisi-kisi itu berlipat ganda, artinya bergerak ke atas dari atas ke bawah, kiri dari kiri ke kanan, dll.

Contoh Kasus

Kasus sampel diberikan sebagai matriks karakter dan koordinat 1-diindeks.

Kasus 1

Memasukkan

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

Keluaran

1

Penjelasan

Lihat contoh.

Kasus 2

Memasukkan

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

Keluaran

1

Penjelasan

Anda dapat mengganti (1, 1)dengan vatau (2, 1)dengan v. Dalam kasus pertama, mulai dari (1, 1), jalan lurus ke bawah dan kemudian ke kanan ke tujuan. Dalam kasus kedua, jalur loop dari kiri ke kanan, mencapai (2, 1), turun, kanan, bawah, dan kemudian kanan sampai menyentuh tujuan.

Kasus 3

Memasukkan

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

Keluaran

2

Penjelasan

Perubahan terbaik adalah membuat baris tengah membungkus kiri ke titik; yaitu, buat item pertama dan terakhir di baris tengah <. Atau, buat 2 2dan 3 2keduanya >.

Ini adalah tantangan kode-golf , jadi kode terpendek menang!

JavaScript (ES6),  140  135 byte

Mengambil input sebagai (a, width, height, x1, y1)(x0, y0)mana a[]adalah matriks bilangan bulat dan semua koordinat 0-diindeks.

Arah: untuk kiri , untuk atas , untuk kanan dan untuk bawah .$-2$- 1 0 1$-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

Cobalah online!

Bagaimana?

Kami menggunakan pencarian pertama untuk mencoba semua jalur yang mungkin dari ke tanpa mengunjungi dua kali sel yang sama.$(x,y)$$(X,Y)$

Kami melacak berapa kali mana arah yang dipilih tidak sesuai dengan arah yang disimpan dalam matriks input.$n$

Kami akhirnya mengembalikan , yang didefinisikan sebagai nilai minimum .$m$$n$

Jelly , 73 72 byte

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

Cobalah online!

Contoh menggunakan case 3 yang membutuhkan dua perubahan (juga memiliki footer untuk menerjemahkan ke ><v^dalam angka).

Program lengkap yang mengharapkan argumen berikut:

• Kiri: daftar dua daftar; pertama-tama grid arah yang rata dikodekan sebagai 1 = kanan, 2 = kiri, 3 = bawah, 4 = atas, diikuti oleh daftar posisi akhir dan mulai posisi sebagai indeks-nol [baris, kolom]. Sebagai contoh pertama [1,1,1,1,3,1,1,1,1,4,2,2,2,2,2],[[2,0],[0,0]],.

• Kanan: daftar jumlah baris yang diikuti oleh kolom. Sebagai contoh pertama[3,5]

Mengembalikan jumlah perubahan yang diperlukan untuk memulai dari awal hingga akhir. Lambat sekali ini lebih dari satu perubahan. Pada TIO, contoh kasus ketiga membutuhkan sekitar. 30 detik untuk selesai.

Penjelasan lengkap di bawah, tetapi gambaran umum adalah:

1. Inisialisasi penghitung ke nol.
2. $\mathit{row} × \mathit{column}$
3. Periksa apakah posisi akhir sudah termasuk:
   • $3 × \mathit{row} × \mathit{column}$
   • Jika benar, hentikan dan output penghitung

Penjelasan lengkap:

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)