San Francisco içerisinde bulunan Taxicab firması

San Francisco'da bir taksi sürücüsüdür. Taksik sürücülerinin tipik hali gibi, taşıyabileceğiniz tek geçerli yönün sol, sağ, yukarı ve aşağı olduğu bir ızgarada ilerliyorsunuz. Ancak, San Fransisco çok tepeliktir, bu nedenle iki bitişik kavşak arasındaki mesafe mutlaka aynı değildir. Daha spesifik olarak, rakımda bir kavşak ile rakımda abitişik bir kavşak arasındaki mesafe bolacaktır 1 + |a - b|. Amacınız haritanın sol üst köşesindeki başlangıç ​​noktanızdan sağ alt köşedeki hedefinize giden en kısa yolları bulmaktır.

Giriş

Hangi formatta en uygun iki tamsayı rakım ızgarası (iki boyutlu dizi, genişlik ve / veya yüksekliğe sahip tek boyutlu dizi, vb.).

Çıktı

Seyahat için yön dizisi, iki bitişik yüksekliklerde kesişimleri arasındaki mesafe verilen en kısa mesafe mümkün sol üst girişi sağ alt köşesinde gelmesi ave başağıdaki formül ile verilmektedir 1 + |a - b|. Birden fazla çözüm varsa, tüm çözümlerin çıktısını alın.

Kullandığım rağmen U, D, L, ve Rup, aşağı, sola ve sağa kadar uzun ve tüm girişler, onlarla tutarlı olarak yön temsil etmek herhangi dört ayrı dizeleri kullanabilir Programınızda Aşağıdaki örneklerde.

Örnekler

Input:
0 3 0 0 0
0 2 0 2 0
0 0 0 3 0
Output:
D D R R U U R R D D

Input:
3
Output:
<empty>

Input:
11 11 11
11 11 11
11 11 11
Output:
R R D D
R D R D
R D D R
D R R D
D R D R
D D R R

Input:
7 8 1 -1 0
4 4 6 -1 7
3 4 4  2 8
2 5 2 -1 2
Output:
D R D R R D R
D R D R D R R

Bu kod golf yani kısa bayt sayısı ile cevap kazanır.

JavaScript (ES6), 228 212 200 194 bayt

a=>w=>(B=1/0,(F=(r,p,s,b=a[p])=>p-a.length+1?1/b&&([...a[p]='RDUL'].map((c,d)=>d|p%w<w-1&&d-3|p%w&&F(r+c,P=p+[1,w,-w,-1][d],s+1+Math.abs(b-a[P]))),a[p]=b):R=s>B?R:s<B?(B=s,r):R+' '+r)('',0,0),R)

Giriş

Kıvrımlı sözdiziminde tek boyutlu dizi ave genişlikw(a)(w)

Çıktı

Boşluklarla ayrılmış çözüm listesi "DRDRRDR DRDRDRR"

Biçimlendirilmiş ve yorumlanmış

a => w => (                            // given an array 'a' and a width 'w'
  B = 1 / 0,                           // B = best score so far, initialized as +Infinity
  (                                    //
    F = (                              // F = recursive function with:
      r,                               //   - r = current path (string)
      p,                               //   - p = current position in grid
      s,                               //   - s = current score
      b = a[p]                         //   - b = backup of current cell
    ) =>                               //
    p - a.length + 1 ?                 // if we haven't reached our destination:
      1 / b && (                       //   if the current cell is valid:
        [...a[p] = 'RDUL']             //     invalidate the current cell
        .map((c, d) =>                 //     for each possible direction:
          d | p % w < w - 1 &&         //       check right boundary
          d - 3 | p % w &&             //       check left boundary
          F(                           //       do a recursive call with:
            r + c,                     //         - new direction appended to the path
            P = p + [1, w, -w, -1][d], //         - updated position
            s + 1 + Math.abs(b - a[P]) //         - updated score
          )                            //
        ),                             //
        a[p] = b                       //     restore current cell value
      )                                //
    :                                  // else:
      R = s > B ?                      //   if the current score is worse than B:
        R                              //     keep the previous solution
      : s < B ?                        //   if the current score is better than B:
        (B = s, r)                     //     update best score / store path as new solution
      : R + ' ' + r                    //   if it's just as good: append path to solution
  )('', 0, 0),                         // initial call to F with r = '', p = 0, s = 0
  R                                    // return solution
)                                      //

Test senaryoları

let f =

a=>w=>(B=1/0,(F=(r,p,s,b=a[p])=>p-a.length+1?1/b&&([...a[p]='RDUL'].map((c,d)=>d|p%w<w-1&&d-3|p%w&&F(r+c,P=p+[1,w,-w,-1][d],s+1+Math.abs(b-a[P]))),a[p]=b):R=s>B?R:s<B?(B=s,r):R+' '+r)('',0,0),R)

console.log(f([
  0, 3, 0, 0, 0,
  0, 2, 0, 2, 0,
  0, 0, 0, 3, 0
])(5));

console.log(f([
  3
])(1));

console.log(f([
  11, 11, 11,
  11, 11, 11,
  11, 11, 11
])(3));

console.log(f([
  7, 8, 1, -1, 0,
  4, 4, 6, -1, 7,
  3, 4, 4,  2, 8,
  2, 5, 2, -1, 2
])(5));