Subir escaleras con programación dinámica

¡Continúe creando, acelere el crecimiento! Este es el primer día de mi participación en el "Nuggets Daily New Plan · October Update Challenge", haz clic para ver los detalles del evento

La programación dinámica es una idea matemática de resolver problemas de toma de decisiones en etapas. Resuelve problemas complejos al descomponer el problema original en subproblemas simples.

subir escaleras

Supongamos que está subiendo escaleras. Necesitas  n pasos para llegar a la cima.

Puede subir  uno 1 o  2 más escalones a la vez. ¿De cuántas maneras diferentes puedes llegar a la cima de un edificio?

Ejemplo 1:

输入：n = 2
输出：2
解释：有两种方法可以爬到楼顶。
1. 1 阶 + 1 阶
2. 2 阶

复制代码

Ejemplo 2:

输入：n = 3
输出：3
解释：有三种方法可以爬到楼顶。
1. 1 阶 + 1 阶 + 1 阶
2. 1 阶 + 2 阶
3. 2 阶 + 1 阶
复制代码

ley de violencia

Podemos combinar todos los pasos posibles para escalar y resolver directamente recursivamente.

Como se muestra en la figura anterior, la solución de fuerza bruta tendrá muchas ramas repetidas y la complejidad del tiempo debe ser muy alta.

Programación dinámica:

Como puede subir 1 o 2 escalones a la vez, puede subir al enésimo escalón desde el n-2 o el n-1.

Hay varias formas de usar f[n] para representar n pasos, entonces f[n]=f[n-1]+f[n-2];

Considere dos casos especiales

• Cuando n=1, f(1)=1, es decir, solo hay un movimiento.
• Cuando n=2, f(2)=2, es decir, hay dos formas de moverse: 1er orden + 1er orden o 2do orden

realizar

class Solution {
    public int climbStairs(int n) {
        if (n==1){
           return 1;
        }else if (n==2){
            return 2;
        }else{  
            int[] dp=new int[n+1];
            dp[1]=1;
            dp[2]=2;
            for (int i=3;i<=n;++i) {
                dp[i]=dp[i-1]+dp[i-2];
            }
            return dp[n];
        }
    }
}
复制代码

Análisis de Complejidad:

• Complejidad del tiempo O(n): se necesita un ciclo para calcular f(n).
• Complejidad espacial O(n): la matriz dp se utiliza para registrar los movimientos en el orden n. Sin embargo, dado que f(n) en este tema solo está relacionado con los dos primeros elementos f(n-1) y f(n-2), podemos usar directamente dos registros variables y la complejidad del espacio se puede reducir a O( 1) )

class Solution {
public:
    int climbStairs(int n) {
        int p1 = 0, p2 = 0, current = 1;
        for (int i = 1; i <= n; ++i) {
            p1 = p2; 
            p2 = current; 
            current = p1 + p2;
        }
        return current;
    }
};
复制代码

• Complejidad temporal: O(n)
• Complejidad espacial: O(1)