746. Subir escaleras con costo mínimo* (Subir escaleras con costo mínimo)

https://leetcode.com/problems/min-cost-climbing-stairs/

Tema Descripción

Se le da una matriz de enteros costdonde cost[i]es el costo del ipeldaño en una escalera. Una vez que pague el costo, puede subir uno o dos escalones.

Puede comenzar desde el paso con índice 0o el paso con índice 1.

Devolver el coste mínimo para llegar a la parte superior del piso .

Ejemplo 1:

Input: cost = [10,15,20]
Output: 15
Explanation: Cheapest is: start on cost[1], pay that cost, and go to the top.

Ejemplo 2:

Input: cost = [1,100,1,1,1,100,1,1,100,1]
Output: 6
Explanation: Cheapest is: start on cost[0], and only step on 1s, skipping cost[3].

Restricciones:

2 <= cost.length <= 1000
0 <= cost[i] <= 999

Código

Lo que me parece interesante de esta pregunta es que cada vez que la escribo, siempre pienso que cometeré un error. Me acabo de dar cuenta hoy que la razón de esta idea es que no he incorporado el método de solución en el sistema de pensamiento existente. Aunque la ecuación de estado escrita en 746. Costo mínimo para subir escaleras* es concisa, no se ajusta a mi forma actual de pensar.

Este problema se resuelve mediante programación dinámica, utilizando para dp[i]representar iel costo mínimo que se debe pagar al llegar a . Suponiendo que el tamaño de costla matriz es N, el objetivo final es saltar a la posición Nx , y el precio que paga dp[N]es . el significado de la pregunta, cuando estás ien la posición Cuando , cost[i]puedes omitir uno o dos pasos pagando el costo de la posición actual. Luego, cuando quieras saltar a la posición ith , puedes estar en la i - 1posición th en el principio, y luego cost[i - 1]paga el costo de saltar un paso para llegar ia la posición th; está ubicado en i - 2la posición, y luego paga cost[i - 2]el precio de saltar dos pasos para llegar ia la posición;
en resumen, la ecuación de transición de estado está lista para salir :

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

Para determinar el estado inicial, el título dice que puedes comenzar a saltar desde 0la posición y la 1posición, luego:

dp[0] = 0;
dp[1] = 0;

Tenga en cuenta nuevamente dp[i]que el significado de es iel costo mínimo que debe pagarse al llegar a , y el costo en esta posición cost[i]se refiere ial precio que debe pagar cuando desea dejar la posición th, ya que podemos comenzar directamente saltando desde el 0th position y the 1th position, por lo que sus valores iniciales están todos establecidos en 0.Finalmente, solo necesitamos volver dp[N]para resolver el problema, el código es el siguiente:

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

Tenga en cuenta que el título dice que el tamaño de la matriz es al menos 2, N < 2por lo que no considere el caso de . En este punto, el código no está terminado y debemos considerar si se puede optimizar aún más. Los dp[i]resultados observados son solo relacionado con dp[i - 1]y dp[i - 2], parece que no hay necesidad de usar vectorpara registrar Para todos los resultados históricos, solo se necesita usar la variable dp0 = dp[i - 2], dp1 = dp[i - 1]para conservar el estado histórico, mientras que el estado dedp0 y se mantiene constantemente.dp1

class Solution {
    
    
public:
    int minCostClimbingStairs(vector<int>& cost) {
    
    
        int N = cost.size();
        int dp0 = 0, dp1 = 0, dp2 = 0;
        for (int i = 2; i <= N; ++ i) {
    
    
            dp2 = min(dp1 + cost[i - 1], dp0 + cost[i - 2]);
            dp0 = dp1;
            dp1 = dp2;
        }
        return dp2;
    }
};

Además, puede ver los siguientes "problemas similares", todos los cuales se pueden resolver utilizando la misma idea.