【背包问题】爬楼梯

今天看到对爬楼梯问题有意思的解法

力扣链接：力扣

这道题和斐波那契数一样，都很经典。

解法1

常规的解法，写个递归，不过这个在力扣会超时，放上代码

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2) {
            return n;
        }
        return climbStairs(n - 1) + climbStairs(n - 2);
    }
};

解法2

动态规划。动态规划解这道题很适合。具体代码如下：

class Solution {
public:
    int climbStairs(int n) {
        // 边界检查
        if (n <= 2) {
            return n;
        }
        vector<int> dp(n + 1, 0);
        // dp[i]表示爬到第i阶楼梯，共有dp[i]中方法
        // 递推公式：dp[i] = dp[i - 1] + dp[i - 2]
        // 从前向后遍历
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

当然也可以省掉数组用三个变量来滑动式的递推

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2) {
            return n;
        }
        int f1 = 1;
        int f2 = 2;
        for (int i = 3; i <= n; i++) {
            int temp = f1 + f2;
            f1 = f2;
            f2 = temp;
        }
        return f2;
    }
};

解法3

上述两种方法都很好理解，代码上也不都难。今天一个很有意思的解法。

利用完全背包去求解。

背包问题详见：(1条消息) 【算法】背包问题_StudyWinter的博客-CSDN博客

这里将1步、2步看作是物品，并且无限多，将楼梯阶数看作是背包容量。

也就是说有背包容量为n的背包，有物品容量为1和2的物品，可以无限拿，问装满背包有多少中

方法？

接下来就是递推公式了。

不考虑nums[i]的情况下，填满容量为j - nums[i]的背包，有dp[j - nums[i]]种方法。

那么只要搞到nums[i]的话，凑成dp[j]就有dp[j - nums[i]] 种方法。

例如：dp[j]，j 为5，

• 已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 dp[5]。
• 已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 dp[5]。
• 已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 dp[5]
• 已经有一个4（nums[i]） 的话，有 dp[1]中方法 凑成 dp[5]
• 已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 dp[5]

这里的递推公式也是

 dp[i] += dp[i - j];

最终代码

class Solution {
public:
    // 完全背包问题，有1和2可以无限取，楼梯的阶数是背包容量
    int climbStairs(int n) {
        vector<int> dp(n + 1, 0);        // dp[i]表示爬到第i个楼梯，共有dp[i]中方法
        dp[0] = 1;
        // 递推公式：dp[i] += dp[i - j];
        // 先遍历背包，后遍历物品
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= 2; j++) {
                if (i - j >= 0) {
                    dp[i] += dp[i - j];
                }
            }
        }
        return dp[n];
    }
};