Lituano <subir escaleras> tabla de combinación recursiva

Descripción del problema:
Suponga 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
Sugerencia: 1 <= n <= 45 Fuente: LeetCode Enlace:
https://leetcode-cn. /problemas/subir-escaleras
pertenece a Lingkou Network. Para reimpresiones comerciales, comuníquese con la autorización oficial, para reimpresiones no comerciales, indique la fuente.

Con respecto a esta pregunta, utilizo tres métodos para lograrlo, el primero es recursividad pura, que solo necesita tres líneas de código, pero el envío dirá que su tiempo es demasiado largo, porque la complejidad es demasiado alta y contiene demasiados cálculos repetidos. Así que todavía uso la recursividad para el segundo método, pero agrego una tabla para registrar los valores que ya he calculado. Cada vez que calculo, voy a la tabla para verificar si ya lo he calculado, de modo que puede ahorrar una gran cantidad de repeticiones Cálculo, el tercer método utilizo bucle iterativo para lograrlo. el código se muestra a continuación:

class Solution {
public:
    //递归写法，时间复杂度太高，因为这种递归涉及太多重复计算 
    int climbStairs(int n) {
    if(n==1) return 1;
    else if(n==2) return 2;
    else  return climbStairs(n-1)+climbStairs(n-2);
     }
}；

//同样采用递归，但用了个哈希表把每次算过的值都记录起来，在每次递归时先去表中查找有无该值，没再自己算，避免重复的计算
    map<int,int> M1;   //用map容器来存储已经计算过的值
    int climbStairs(int n) {
    int i=1;
     if(n==1) return 1;
     if(n==2) return 2;
     if(M1.end()!=M1.find(n))
     {
         map<int,int>::iterator pos = M1.find(n);
         return pos->second; 
     }else
         {
         int result = climbStairs(n-1)+climbStairs(n-2);
         M1.insert(pair<int,int>(n,result));
         return result;
         } 
     }
}; 
  

class Solution {
public:
    //最后再采用迭代循环的方法  画个图就很容易理解，每一次都是前两次的相加
    int climbStairs(int n) {
    if(n==1) return 1;    
    if(n==2) return 2;
    int result = 0;
    int pre = 2;
    int prepre = 1;
    for(int i = 3;i<=n;i++)
    {
        result=pre+prepre;
        prepre=pre;
        pre=result;
    }
    return result;
    }
 };