LeetCode748 Subir escaleras con coste mínimo

748. Usa el costo mínimo para subir escaleras

Se le da una matriz de números enteros cost , donde cost[i]está iel costo de subir el peldaño -th de las escaleras. Una vez que pague esta tarifa, puede optar por subir un tramo de escaleras o dos.

Puede optar por empezar a subir las escaleras desde los escalones marcados con 0o con .1

Calcule y devuelva el costo mínimo para llegar a la parte superior de las escaleras.

ejemplo

Entrada: costo = [1,100,1,1,1,100,1,1,100,1]

Salida: 6

Explicación: Comenzará desde el paso con el índice 0.

• Paga 1 y sube dos escalones para llegar al escalón con subíndice 2.
• Paga 1 y sube dos escalones hasta el escalón marcado como 4.
• Paga 1 y sube dos escalones para llegar al escalón con subíndice 6.
• Paga 1 y sube un escalón para llegar al escalón con subíndice 7.
• Paga 1 y sube dos escalones para llegar al escalón con subíndice 9.
• Paga 1, sube un escalón para llegar a la parte superior de las escaleras.

El costo total es de 6.

---

Método 1: Programación Dinámica

La solución presentada en este artículo es la misma que la solución del problema oficial de Likou, pero la definición de arreglo dp en este artículo es diferente, y la inicialización del arreglo dp, la fórmula recursiva y el orden transversal también son diferentes.

Siga el método de 5 pasos de programación dinámica presentado en el tema de programación dinámica para resolver:

1. Determine el significado de la matriz dp y el subíndice

   El uso de programación dinámica necesita registrar información de estado.De acuerdo con el significado de la pregunta, puede establecer una matriz unidimensional dp[i] para registrar el costo mínimo de subir desde el i-ésimo piso hasta la parte superior de la escalera.

2. Determinar la fórmula recursiva

   De acuerdo con el significado de la pregunta, después de pagar el costo[i] del i-ésimo piso, puede optar por subir uno o dos escalones, por lo que el costo de subir del i-ésimo piso hasta la parte superior de la escalera es igual a costo[i] + dp[i+1 ], o igual a costo[i] + dp[i+2].

   entonces dp[i] = cost[i] + min( dp[i+1], dp[i+2])_

3. Cómo inicializar la matriz dp

   De acuerdo con el significado de la pregunta, el costo mínimo para subir desde la capa cost.size-1 hasta la parte superior de la escalera es cost[size-1];

   El costo mínimo para subir desde el piso cost.size-2th hasta la parte superior de la escalera es cost[size-2];

   vector<int> dp(cost.size());
   dp[size-1] = cost[size-1];
   dp[size-2] = cost[size-2];
   

4. Determinar el orden de recorrido

   De la fórmula de recurrencia se puede ver que es necesario atravesar de atrás hacia adelante .

5. Ejemplo de matriz dp de derivación

   Tome el ejemplo: costo = [1, 100, 1, 1, 1, 100, 1, 1, 100, 1] para simular el cambio de estado de la matriz dp, de la siguiente manera:

   Subíndice i	0	1	2	3	4	5	6	7	8	9
   dp[yo]	6	105	5	5	4	102	3	2	100	1

   A juzgar por el valor mínimo de dp[0] y dp[1], comience a subir las escaleras desde el escalón con subíndice 0 o subíndice 1.

Código

int minCostClimbingStairs(vector<int>& cost) {
    
    
  int size = cost.size();
  vector<int> dp(size);
  dp[size - 1] = cost[size - 1];
  dp[size - 2] = cost[size - 2];
  for (int i = size - 3; i >= 0; i--) {
    
    
    dp[i] = cost[i] + min(dp[i + 1], dp[i + 2]);
  }
  return min(dp[0], dp[1]);
}

Complejidad del tiempo: $O\left(n\right)$
complejidad del espacio:$O\left(n\right)$

La complejidad del espacio también se puede optimizar, porque dp[i] se deriva de los dos últimos bits y, al final, solo se deben comparar dp[0] y dp[1], por lo que solo se deben mantener dos elementos.

int minCostClimbingStairs2(vector<int>& cost) {
    
    
  int size = cost.size();
  vector<int> dp(2);
  dp[1] = cost[size - 1];
  dp[0] = cost[size - 2];
  for (int i = size - 3; i >= 0; i--) {
    
    
    int sum = cost[i] + min(dp[0], dp[1]);
    dp[1] = dp[0];
    dp[0] = sum;
  }
  return min(dp[0], dp[1]);
}

Complejidad del tiempo: $O\left(n\right)$
complejidad espacial:$O\left(1\right)$

---