Subir escaleras (programación recursiva, dinámica)

Rebote: Rebote

Supongamos que está subiendo escaleras. Se necesitan n pasos antes de poder llegar a la parte superior del edificio.

Puedes subir 1 o 2 escalones a la vez. ¿De cuántas maneras diferentes puedes llegar a la parte superior del edificio?

Ejemplo 1:

Entrada: n = 2
Salida: 2
Explicación: Hay dos formas de subir a la parte superior del edificio.
1. 1er pedido + 1er pedido
2. 2do pedido

Ejemplo 2:

Entrada: n = 3
Salida: 3
Explicación: Hay tres formas de subir a la parte superior del edificio.
1. Nivel 1 + Nivel 1 + Nivel 1
2. Nivel 1 + Nivel 2
3. Nivel 2 + Nivel 1

pista:

1 <= norte <= 45

Ejemplo de código 1:  [recursión]

class Solution:
    @functools.lru_cache(100)  # 缓存装饰器
    def climbStairs(self, n: int) -> int:
        if n == 1 or n == 2:
            return n
        return self.climbStairs(n-1) + self.climbStairs(n-2)
        

La solución recursiva directa es fácil de agotar.Python puede agregar un decorador de caché, que puede considerarse como convertir la recursividad en una forma iterativa.

Ejemplo de código 2: [Programación dinámica] [Caché de estado]

class Solution:
    def climbStairs(self, n: int) -> int:
        dp = {}
        dp[1] = 1
        dp[2] = 2
        for i in range(3, n+1):
            dp[i] = dp[i-1] + dp[i-2]
        return dp[n]

Cree un nuevo diccionario o matriz para almacenar variables anteriores, complejidad espacial O (n)

Ejemplo de código 3: [Programación dinámica] [Compresión espacial]

class Solution:
    def climbStairs(self, n: int) -> int:
        if n == 1 or n == 2:
            return n
        a, b, tmp = 1, 2, 0
        for i in range(3, n+1):
            tmp = a + b
            a = b
            b = tmp
        return tmp

Solo se almacenan los dos primeros elementos, lo que reduce el espacio y la complejidad del espacio es O(1)

Análisis de ideas: