Táxi em São Francisco

14

Você é motorista de táxi em São Francisco. Como é típico dos motoristas de táxi, você está navegando em uma grade na qual as únicas direções válidas que você pode mover são a esquerda, direita, para cima e para baixo. No entanto, San Fransisco é muito montanhoso, portanto a distância entre dois cruzamentos adjacentes não é necessariamente a mesma. Mais especificamente, a distância entre um cruzamento na altitude ae um cruzamento adjacente na altitude bseria 1 + |a - b|. Seu objetivo é encontrar todos os caminhos mais curtos desde a sua origem no canto superior esquerdo do mapa até o seu destino no canto inferior direito.

Entrada

Uma grade bidimensional de altitudes inteiras, no formato que for mais conveniente (matriz bidimensional, matriz unidimensional com largura e / ou altura, etc.).

Resultado

Uma sequência de instruções para viajar para chegar ao canto inferior direito da entrada do canto superior esquerdo na menor distância possível, dada a distância entre duas interseções adjacentes de altitudes ae bé dada pela fórmula 1 + |a - b|. Se houver várias soluções, produza todas as soluções.

Embora eu use U, D, L, e Rpara cima, para baixo, para a esquerda e para a direita nos exemplos abaixo seu programa pode usar qualquer quatro cordas diferentes para representar as direções, desde que ele é consistente com eles dentro e através de todas as entradas.

Exemplos

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

Isso é então a resposta com a menor contagem de bytes vence.

0 '
fonte
1
As altitudes são sempre menores que 10? (eles estão em exemplos, mas eles vão sempre ser?)
Dada
@ Dadá as altitudes não são necessariamente menores que 10 (elas também podem ser negativas), atualizei os exemplos de acordo.
0
quando vi que este post estava ativo, eu estava suuuuuuper excitado - pensei que alguém tivesse postado uma resposta no táxi! talvez um dia
space junk

Respostas:

2

JavaScript (ES6), 228 212 200 194 bytes

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)

Entrada

Matriz unidimensional ae largura wna sintaxe de currying(a)(w)

Resultado

Uma lista separada por espaços de soluções, como "DRDRRDR DRDRDRR"

Formatado e comentado

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
)                                      //

Casos de teste

Arnauld
fonte