LeetCode //C - 909. Serpientes y escaleras

909. Serpientes y escaleras

Se le proporciona un tablero de matriz de enteros nxn donde las celdas están etiquetadas de 1 a n2 en un estilo Boustrophedon comenzando desde la parte inferior izquierda del tablero (es decir, tablero [n - 1] [0]) y alternando la dirección en cada fila.

Comienzas en la casilla 1 del tablero. En cada movimiento, comenzando desde el cuadrado curr, haga lo siguiente:

• Elija un cuadrado de destino al lado con una etiqueta en el rango [curr + 1, min(curr + 6, n2)].
  • Esta elección simula el resultado de una tirada de dado estándar de 6 caras: es decir, siempre hay como máximo 6 destinos, independientemente del tamaño del tablero.
• Si el siguiente tiene una serpiente o escalera, debes moverte al destino de esa serpiente o escalera. De lo contrario, pasa al siguiente.
• El juego termina cuando llegas a la casilla n2.

Un cuadrado de tablero en la fila r y la columna c tiene una serpiente o una escalera si tablero[r][c] != -1. El destino de esa serpiente o escalera es el tablero[r][c]. Los cuadrados 1 y n2 no tienen serpiente ni escalera.

Ten en cuenta que solo tomas una serpiente o una escalera como máximo una vez por movimiento. Si el destino de una serpiente o escalera es el inicio de otra serpiente o escalera, no sigas la serpiente o escalera siguiente.

• Por ejemplo, supongamos que el tablero es [[-1,4],[-1,3]] y en el primer movimiento, su casilla de destino es la 2. Sigue la escalera hasta la casilla 3, pero no sigue la escalera siguiente. para 4.

Devuelve el menor número de movimientos necesarios para llegar al cuadrado n2. Si no es posible llegar al cuadrado, devuelve -1.
 

Ejemplo 1:

Entrada: tablero = [[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,- 1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,- 1],[-1,15,-1,-1,-1,-1]]
Salida: 4
Explicación:
Al principio, comienza en el cuadrado 1 (en la fila 5, columna 0).
Decides moverte al cuadrado 2 y debes tomar la escalera hasta el cuadrado 15.
Luego decides moverte al cuadrado 17 y debes llevar la serpiente al cuadrado 13.
Luego decides moverte al cuadrado 14 y debes tomar la escalera al cuadrado 35.
Luego decides pasar al cuadro 36, finalizando el juego.
Este es el menor número posible de movimientos para llegar al último cuadrado, así que devuelve 4.

Ejemplo 2:

Entrada: placa = [[-1,-1],[-1,3]]
Salida: 1

Restricciones:

• n == tablero.longitud == tablero[i].longitud
• 2 <= norte <= 20
• tablero[i][j] es -1 o está en el rango [ $1,{norte}^2$ ].
• Los cuadrados etiquetados 1 y ${norte}^2$ no tienen escaleras ni serpientes.

De: LeetCode
Enlace: 909. Serpientes y escaleras

---

Solución:

Ideas:

1. Convierta el tablero 2D en una matriz 1D, donde cada celda de la matriz representa una celda del tablero.
2. Inicie BFS desde la primera celda de la matriz.
3. Para cada celda, intente pasar de 1 a 6 celdas siguientes. Si la celda tiene una serpiente o una escalera, salta al destino de la serpiente o la escalera.
4. Lleve un registro del número de movimientos necesarios para llegar a cada celda.
5. Cuando llegues a la última celda, devuelve el número de movimientos necesarios.

Código:

int snakesAndLadders(int** board, int boardSize, int* boardColSize) {
    
    
    int n = boardSize;
    int totalCells = n * n;
    int* moves = (int*)malloc((totalCells + 1) * sizeof(int));
    for (int i = 0; i <= totalCells; ++i) moves[i] = -1;
    moves[1] = 0;
    
    int* queue = (int*)malloc((totalCells + 1) * sizeof(int));
    int front = 0, rear = 0;
    queue[rear++] = 1;
    
    while (front < rear) {
    
    
        int curr = queue[front++];
        for (int i = 1; i <= 6 && curr + i <= totalCells; ++i) {
    
    
            int next = curr + i;
            int row = n - 1 - (next - 1) / n;
            int col = ((n - 1 - row) % 2 == 0) ? (next - 1) % n : n - 1 - (next - 1) % n;
            if (board[row][col] != -1) next = board[row][col];
            if (moves[next] == -1) {
    
    
                moves[next] = moves[curr] + 1;
                if (next == totalCells) return moves[next];
                queue[rear++] = next;
            }
        }
    }
    
    free(moves);
    free(queue);
    
    return -1;
}