解释这个动态规划爬n-stair代码

Question

问题是

“你正在爬楼梯。每次可以走 1 级或 2 级。楼梯有 n 级。你可以用多少种不同的方式爬楼梯？”

以下是此问题的代码解决方案，但我无法理解它。谁能解释一下

int stairs(int n) {
  if (n == 0) return 0;
  int a = 1;
  int b = 1;
  for (int i = 1; i < n; i++) {
    int c = a;
    a = b;
    b += c;
  }
  return b;
 }

谢谢，

Answer 1

嗯，首先您需要了解递归公式，以及我们如何从中得出迭代公式。

递归公式为：

f(n) = f(n-1) + f(n-2)
f(0) = f(1) = 1

（f(n-1) 一步，f(n-2) 两步，总数是使用这些选项之一的方法数 - 因此是总和）。

如果你仔细看 - 这也是一个众所周知的系列 - fibonacci numbers，解决方案只是从头开始计算每个数字，而不是一遍又一遍地重新计算递归，从而产生更有效的解决方案.

Answer 2

使用 DP 爬楼梯

class Solution {
   public:
     int climbStairs(int n) {
    int dp[n+1];

    if (n <= 1)
        return 1;

    if (n ==2)
        return 2;

    dp[0] = 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];
   }};

Answer 3

在写下1步、2步到达确定楼层的可能选项的过程中；对我来说，有人看到组合的数量正好是斐波那契数列中的一个数字。那么，这就是答案。选项的数量（2 个选项：1 步和 2 步）与求和以获得斐波那契数列中的下一个数字的数字数量之间存在关系：两个数字。然后，如果您尝试使用例如 3 个选项（1 步、2 步、3 步）来解决爬楼梯，那么结果等效于适应斐波那契数列，但求和 3 个数字，该数列将是 0、1、1、2 , 4, 7, 13, 24. 我不知道这个系列有没有名字，但如果你检查，结果是正确的。

回到爬楼梯 1-2 步，对于下一个代码，我使用数组作为堆栈，而不是使用 3 个变量或数组（您可以在网上找到其他解决方案）。我弹出前两个数字，计算系列中的当前数字，然后推送最近的数字，然后推送当前数字。这两个数字将是 while 循环下一个循环中的前一个数字。

 /**
 * Using Fibonacci and a stack.
 * @param {number} n
 * @return {number}
 */
const climbingStairs = (n) => {
    if (n === 0) return 0;
    if (n === 1) return 1;
    if (n === 2) return 2;

    let stack = [];
    stack.push(1);
    stack.push(2);
    let current_steps = 3;
    let current_combinations = 0;
    while (current_steps <= n) {
        let previous = stack.pop();
        let previous2 = stack.pop();
        current_combinations = previous + previous2;
        stack.push(previous);
        stack.push(current_combinations);
        current_steps++
    }
    return current_combinations
}

console.log(climbingStairs(5));