动态规划解题步骤（重要）：

1. 确定dp数组（dp table）以及下标的含义
2. 确定递推公式
3. dp数组如何初始化
4. 确定遍历顺序
5. 举例推导dp数组

509. 斐波那契数

力扣题目链接

class Solution {
public:
    // 时间复杂度：O(n)
    // 空间复杂度：O(n)
    int fibDp1(int n) {
        if (n <= 1) {
            return n;
        }
        vector<int> dp(n + 1);
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
    // 时间复杂度：O(n)
    // 空间复杂度：O(1)

    int fibDp2(int n) {
        if (n <= 1) {
            return n;
        }
        int dp[2];
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            int sum = dp[0] + dp[1];
            dp[0] = dp[1];
            dp[1] = sum;
        }
        return dp[1];
    }

    // 递归
    // 时间复杂度：O(2^n)
    // 空间复杂度：O(n)，算上了编程语言中实现递归的系统栈所占空间
    int fibTraversal(int n) {
        if (n < 2) {
            return n;
        }
        return fibTraversal(n - 1) + fibTraversal(n - 2);
    }

    int fib(int n) {
        return 0;
    }
};

70. 爬楼梯

力扣题目链接

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 1) {
            return n;
        }
        vector<int> dp(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];
    }

    int climbStairs1(int n) {
        if (n <= 1) {
            return n;
        }
        int dp[3];
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            int sum = dp[1] + dp[2];
            dp[1] = dp[2];
            dp[2] = sum;
        }
        return dp[2];
    }

    // 通用版，一步m个台阶，爬n个台阶
    int _climbStairs(int n, int m) {
        vector<int> dp(n + 1, 0);
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (i - j >= 0) {
                    dp[i] += dp[i - j];
                }
            }
        }
        return dp[n];
    }
};

746. 使用最小花费爬楼梯

力扣题目链接

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size() + 1);
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= cost.size(); ++i) {
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]);
        }
        return dp[cost.size()];
    }

    int minCostClimbingStairs1(vector<int>& cost) {
        int dp[2];
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= cost.size(); ++i) {
            int dpi = min(dp[0] + cost[i - 2], dp[1] + cost[i - 1]);
            dp[0] = dp[1];
            dp[1] = dpi;
        }
        return dp[1];
    }
};