动态规划：基础篇

目录

1. 斐波那契数(LeetCode509)

解法1：动态规划(基础版)

解法2：动态规划(优化版) 

2. 爬楼梯(方案个数)(斐波那契数列扩展)(LeetCode70)

 解法1：动态规划(基础版)

解法2：动态规划(优化版)

3. 爬楼梯(最小花费)(LeetCode746)

解法1：动态规划(基础版) 

 解法2：动态规划(优化版)

4. 不同路径(无障碍)(LeetCode62)

解法1：动态规划(基础版)

 解法2：动态规划(优化版)

5. 不同路径(有障碍)(LeetCode63)

解法1：动态规划(基础版)

解法2：动态规划(优化版)

6. 整数拆分(LeetCode343) 

7. 不同的二叉搜索树(LeetCode96)

---

1. 斐波那契数(LeetCode509)

题目描述：https://leetcode.cn/problems/fibonacci-number/description/

解法1：动态规划(基础版)

解题思路：动态规划五部曲

• Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
  • dp[i]：第i个数的斐波那契数值是dp[i]
• Step2：确定递推公式
  • dp[i] = dp[i - 1] + dp[i - 2]  题目已给
• Step3：初始化dp数组
  • 由递推公式可知，需要初始化前两个元素（题目已给）
    • dp[0] = 0
    • dp[1] = 1
• Step4：确定遍历顺序
  • 由递推公式可知，后面的斐波那契数值依赖于前面两个
  • 因此，需要从前向后遍历
• Step5：打印dp数组（调试）

#include <iostream>
using namespace std;
#include <vector>

class Solution 
{
public:
    int fib(int n) 
    {
        if (n <= 1) return n;

        // Step3：初始化dp数组
        vector<int> dp(n + 1);
        dp[0] = 0;
        dp[1] = 1;
        // Step4：确定遍历顺序
        for (int i = 2; i <= n; i++)
        {
            // Step2：确定递推公式
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

int main()
{
    int n = 4;

    Solution s;
    int ans = s.fib(n);   // 3

    cout << ans << endl;

    system("pause");
    return 0;
}

复杂度分析：

• 时间复杂度：O(n)  需要计算每个元素的斐波那契数值
• 空间复杂度：O(n)  需要存储每个元素的斐波那契数值

注意事项：

• if (n <= 1) return n;  当n为0或1时，无法由递推公式推导得到，需要根据dp数组的含义直接返回结果，此处在实际编程过程中容易忽略。（所有动态规划题目都需要格外注意）

解法2：动态规划(优化版) 

解题思路：利用"状态压缩"进行优化 → 由于当前数值仅依赖于前面两个数值，因此只需要维护两个数值 （后面将讲解的很多动规的题目其实都是当前状态依赖前两个，或者前三个状态，都可以做空间上的优化）

#include <iostream>
using namespace std;
#include <vector>
  
class Solution
{
public:
    int fib(int n)
    {
        if (n <= 1) return n;

        vector<int> dp(2, 0);  // 优化：只需要维护两个数值即可，不需要记录整个序列
        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];
    }
};

int main()
{
    int n = 4;

    Solution s;
    int ans = s.fib(n);   // 3

    cout << ans << endl;

    system("pause");
    return 0;
}

复杂度分析：

• 时间复杂度：O(n)  需要计算每个元素的斐波那契数值
• 空间复杂度：O(1)  无需存储每个元素的斐波那契数值（只需要维护两个数值即可，不需要记录整个序列）

2. 爬楼梯(方案个数)(斐波那契数列扩展)(LeetCode70)

题目描述：https://leetcode.cn/problems/climbing-stairs/description/

 解法1：动态规划(基础版)

解题思路：动态规划五部曲
         爬到第1层楼梯：有1种方法
         爬到第2层楼梯：有2种方法  1+1(每次爬一个台阶)、2(一次爬两个台阶)
         爬到第3层楼梯：有3种方法  
             1 +2(先爬一个台阶、再爬两个台阶)   由第1层楼梯过来
             1+1 +1(每次爬一个台阶)                    由第2层楼梯过来
             2 +1(先爬两个台阶、再爬一个台阶)   由第2层楼梯过来
             可见，到第三层楼梯的状态 可以由 第二层楼梯 和 第一层楼梯状态 推导出来

    

• Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
  • dp[i]：爬到第i层楼梯的方法个数有dp[i]种
• Step2：确定递推公式
  • 从dp[i]的定义可以看出，dp[i]可以有两个方向推出来
    • dp[i-1]：上到第i-1层楼梯，有dp[i-1]种方法，再一步 跳一个台阶 即可到达第i层楼梯
    • dp[i-2]：上到第i-2层楼梯，有dp[i-2]种方法，再一步 跳两个台阶 即可到达第i层楼梯
  • dp[i] = dp[i-1] + dp[i-2]
• Step3：初始化dp数组
  • 由递推公式可知，需要初始化前两个元素
    • dp[1] = 1
    • dp[2] = 2
  • 注意：此处并不初始化dp[0]，因为没有实际意义
  • 很多题解强行将dp[0]初始化为1，基本都是直接奔着答案去解释的（因为在递推的过程中i从2开始遍历本题就能过）
• Step4：确定遍历顺序
  • 由递推公式可知，需要从前向后遍历
• Step5：打印dp数组（调试）

#include <iostream>
using namespace std;
#include <vector>

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

        vector<int> dp(n+1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++)  // 注意：此处i是从3开始遍历
        {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

int main()
{
    Solution s;
    int ans = s.climbStairs(3);

    cout << ans << endl;

    system("pause");
    return 0;
}

复杂度分析：

• 时间复杂度：O(n)  需要计算到达每层楼梯的方法个数
• 空间复杂度：O(n)  需要存储到达每层楼梯的方法个数

解法2：动态规划(优化版)

解题思路：利用"状态压缩"进行优化 → 由于当前数值仅依赖于前面两个数值，因此只需要维护两个数值 （动态规划的常见优化思路）

#include <iostream>
using namespace std;
#include <vector>

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

        vector<int> dp(3);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++)  // 注意：此处i是从3开始遍历
        {
            int sum = dp[1] + dp[2];
            dp[1] = dp[2];
            dp[2] = sum;
        }
        return dp[2];
    }
};

int main()
{
    Solution s;
    int ans = s.climbStairs(3);

    cout << ans << endl;

    system("pause");
    return 0;
}

复杂度分析：

• 时间复杂度：O(n)  需要计算到达每层楼梯的方法个数
• 空间复杂度：O(1)  无需存储每个元素的斐波那契数值（只需要维护两个数值即可，不需要记录整个序列）

3. 爬楼梯(最小花费)(LeetCode746)

题目描述：https://leetcode.cn/problems/min-cost-climbing-stairs/

解法1：动态规划(基础版) 

解题思路：动态规划五部曲

• Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
  • dp[i]：到达第i台阶所花费的最少体力为dp[i]
• Step2：确定递推公式
  • 由于每次只能向上爬一个或者两个台阶，因此到达第i台阶有两个途径
    • 从第i-1台阶跳1步：需要花费 dp[i-1]+cost[i-1]
    • 从第i-2台阶跳2步：需要花费 dp[i-2]+cost[i-2]
  • dp[i] = min(dp[i-1]+cost[i-1], dp[i-2]+cost[i-2])
• Step3：初始化dp数组
  • 题目描述：可以选择从下标为0或下标为1的台阶开始爬楼梯
  • 到达第0个台阶是不花费体力，但从第0个台阶往上跳的话，需要花费cost[0]
  • 到达第1个台阶是不花费体力，但从第1个台阶往上跳的话，需要花费cost[1]
  • dp[0] = 0
  • dp[1] = 0
• Step4：确定遍历顺序
  • 由递推公式可知，需要从前向后遍历
• Step5：打印dp数组（调试）

#include <iostream>
using namespace std;
#include <vector>

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 main()
{
    vector<int> cost{ 10,15,20 };   // 15
    //vector<int> cost{ 1,100,1,1,1,100,1,1,100,1 };   // 6

    Solution s;
    int ans = s.minCostClimbingStairs(cost);

    cout << ans << endl;
}

复杂度分析：

• 时间复杂度：O(n)  需要计算到达每层楼梯的最小体力
• 空间复杂度：O(n)  需要存储到达每层楼梯的最小体力

 解法2：动态规划(优化版)

#include <iostream>
using namespace std;
#include <vector>

class Solution
{
public:
    int minCostClimbingStairs(vector<int>& cost)
    {
        vector<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];
    }
};


int main()
{
    vector<int> cost{ 10,15,20 };   // 15
    //vector<int> cost{ 1,100,1,1,1,100,1,1,100,1 };   // 6

    Solution s;
    int ans = s.minCostClimbingStairs(cost);

    cout << ans << endl;
}

复杂度分析：

• 时间复杂度：O(n)  需要计算到达每层楼梯的最小体力
• 空间复杂度：O(1)  

4. 不同路径(无障碍)(LeetCode62)

题目描述：https://leetcode.cn/problems/unique-paths/description/

解法1：动态规划(基础版)

解题思路：动态规划五部曲

• Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
  • dp[i][j]：从(0,0)出发到达(i,j)的不同路径有dp[i][j]条
• Step2：确定递推公式
  • 机器人每次只能向下或者向右移动一步，因此到达(i,j)有两个途径
    • 从(i-1,j)向下移动：dp[i-1][j]  从(0,0)出发，到(i-1,j)的不同路径个数
    • 从(i,j-1)向右移动：dp[i][j-1]  从(0,0)出发，到(i,j-1)的不同路径个数
  • dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
• Step3：初始化dp数组
  • 从(0,0)出发，到达第一行的任意位置，只有1种路径  →  dp[0][j] = 1
  • 从(0,0)出发，到达第一列的任意位置，只有1种路径  →  dp[i][0] = 1
  • 注意：只能向下或向右移动
• Step4：确定遍历顺序
  • 由递推公式可知，需要从前向后、从上向下遍历
• Step5：打印dp数组（调试）

#include <iostream>
using namespace std;
#include <vector>

class Solution
{
public:
    int uniquePaths(int m, int n) 
    {
        // 示例：m=3 n=7
        // 1  1  1  1  1  1  1
        // 1  2  3  4  5  6  7
        // 1  3  6  10 15 21 28

        // Step3：初始化dp数组
        vector<vector<int>> dp(m, vector<int>(n, 0));   // 二维数组的初始化（重要）
        for (int i = 0; i < m; i++)  dp[i][0] = 1;
        for (int j = 0; j < n; j++) dp[0][j] = 1;
        // Step4：确定遍历顺序
        for (int i = 1; i < m; i++)
        {
            for (int j = 1; j < n; j++)
            {
                // Step2：确定递推公式
                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
            }
        }
        return dp[m - 1][n - 1];
    }
};

int main()
{
    Solution s;
    int ans = s.uniquePaths(3, 7);  // 28

    cout << ans << endl;

    system("pause");
    return 0;
}

复杂度分析：

• 时间复杂度：O(m×n)  需要计算到达每一个位置的不同路径个数，两层for循环（第一层for循环遍历m-1行，第二层for循环遍历n-1列）
• 空间复杂度：O(m×n)  需要存储到达每一个位置的不同路径个数

 解法2：动态规划(优化版)

解题思路：使用一维数组(可以理解为滚动数组)进行空间优化  →  不利于理解，但可以优化空间

#include <iostream>
using namespace std;
#include <vector>

class Solution
{
public:
    int uniquePaths(int m, int n)
    {
        // 示例：m=3 n=7
        // 初始化一维数组    1  1  1  1  1  1  1
        // i=1              1  2  3  4  5  6  7
        // i=2              1  3  6  10 15 21 28

        // Step3：初始化dp数组
        vector<int> dp(n, 1);
        // Step4：确定遍历顺序(只能先遍历行，后遍历列)
        for (int i = 1; i < m; i++)       // 遍历行时，只能从上向下遍历
        {
            for (int j = 1; j < n; j++)   // 遍历列时，只能从前向后遍历
            // for (int j = n-1; j > 0; j--)  // 错误
            {
                // Step2：确定递推公式
                // dp[j-1]：在计算dp[j]时，dp[j-1]已经计算完毕，因此dp[j-1]为第i行("新值") → 从(i,j-1)出发，向右移动
                // dp[j](公式右侧)：dp[j]还没有计算，因此dp[j]为第i-1行("旧值") → 从(i-1,j)出发，向下移动
                dp[j] = dp[j - 1] + dp[j];
            }
        }
        return dp[n - 1];
    }
};

int main()
{
    Solution s;
    int ans = s.uniquePaths(3, 7);  // 28

    cout << ans << endl;

    system("pause");
    return 0;
}

复杂度分析：

• 时间复杂度：O(m×n)  需要计算到达每一个位置的不同路径个数
• 空间复杂度：O(n)    每一阶段仅存储一行中所有位置的信息（先计算完一行，再计算下一行）

5. 不同路径(有障碍)(LeetCode63)

题目描述：https://leetcode.cn/problems/unique-paths-ii/description/

解法1：动态规划(基础版)

解题思路：本题与不同路径（无障碍）的区别

• 区别1：dp数组的初始化
  • 不同路径1：直接将第一行和第一列初始化为1
  • 不同路径2：若某个位置存在障碍物，则该位置及其之后的所有位置均不可达
• 区别2：递推公式
  • 不同路径1：所有位置都可以计算递推公式
  • 不同路径2：若某个位置存在障碍物，则该位置的不同路径个数为0，无需计算递推公式，而是直接使用默认值（遇到障碍dp[i][j]保持0）

#include <iostream>
using namespace std;
#include <vector>

class Solution 
{
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) 
    {
        int m = obstacleGrid.size();     // 网格的行数
        int n = obstacleGrid[0].size();  // 网格的列数

        // 若起点或终点存在障碍物，则表明终点不可达，直接返回路径个数0
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) return 0;

        // Step3：初始化dp数组
            // 若第一行存在障碍物，则该障碍物及其之后的所有位置均不可达；若第一行不存在障碍物，则所有位置均初始化为1
            // 若第一列存在障碍物，则该障碍物及其之后的所有位置均不可达；若第一列不存在障碍物，则所有位置均初始化为1
        // 注意代码里for循环的终止条件，一旦遇到obstacleGrid[i][0] == 1的情况，就停止dp[i][0]的赋值1的操作，dp[0][j]同理
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;      // 初始化第一列
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1;      // 初始化第一行

        // Step4：确定遍历顺序
        for (int i = 1; i < m; i++)
        {
            for (int j = 1; j < n; j++)
            {
                // Step2：确定递推公式
                // 当前位置不存在障碍物，执行if语句，计算达到该位置的不同路径个数
                // 当前位置存在障碍物，不执行if语句，使用默认的初始化值0，表明该位置不可达 或 达到该位置的不同路径个数为0
                if (obstacleGrid[i][j] == 0)
                {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
                }
            }
        }
        return dp[m - 1][n - 1];
    }
};

int main()
{
    vector<vector<int>> obstacleGrid{ {0,0,0},{0,1,0},{0,0,0} };  // 2
    //vector<vector<int>> obstacleGrid{ {0,1},{0,0} };  // 1

    Solution s;
    int ans = s.uniquePathsWithObstacles(obstacleGrid);

    cout << ans << endl;

    system("pause");
    return 0;
}

复杂度分析：

• 时间复杂度：O(mxn)
• 空间复杂度：O(mxn) 

注意事项：

• if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) return 0;  若起点或终点存在障碍物，则表明终点不可达，直接返回路径个数0（易漏点）

解法2：动态规划(优化版)

#include <iostream>
using namespace std;
#include <vector>

class Solution
{
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid)
    {
        int m = obstacleGrid.size();     // 网格的行数
        int n = obstacleGrid[0].size();  // 网格的列数

        // 若起点或终点存在障碍物，则表明终点不可达，直接返回路径个数0
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m - 1][n - 1] == 1) return 0;

        // Step3：初始化dp数组
        vector<int> dp(n, 0);
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[j] = 1;

        // Step4：确定遍历顺序
        for (int i = 1; i < m; i++)
        {
            for (int j = 0; j < n; j++)
            {
                // Step2：确定递推公式
                // 对于第1列：若存在障碍物，则赋值为0；若不存在障碍物，保持不变
                // 对于其余列：若存在障碍物，则赋值为0；若不存在障碍物，则利用递推公式推导              
                if (obstacleGrid[i][j] == 1)   // 若存在障碍物(无论哪一列)，则赋值为0
                {
                    dp[j] = 0;
                }
                else if(j != 0)                // 若不存在障碍物且非第1列，则利用递推公式
                {
                    dp[j] = dp[j - 1] + dp[j];
                }
                // 注：以上代码不能修改如下
                // if (obstacleGrid[i][j] == 1) dp[j] = 0;   // 若存在障碍物，则赋值为0
                // if (j != 0) dp[j] = dp[j - 1] + dp[j];    // 若不存在障碍物，则利用递推公式（第一列不存在障碍物，则延续上一行的结果，不需要任何操作）
            }
        }
        return dp[n - 1];
    }
};

int main()
{
    vector<vector<int>> obstacleGrid{ {0,0,0},{0,1,0},{0,0,0} };  // 2
    //vector<vector<int>> obstacleGrid{ {0,1},{0,0} };  // 1

    Solution s;
    int ans = s.uniquePathsWithObstacles(obstacleGrid);

    cout << ans << endl;

    system("pause");
    return 0;
}

复杂度分析：

• 时间复杂度：O(mxn)
• 空间复杂度：O(n)

6. 整数拆分(LeetCode343) 

待补充！！！

7. 不同的二叉搜索树(LeetCode96)

题目描述： https://leetcode.cn/problems/unique-binary-search-trees/description/

以"n=3"举例分析

• 当1为头结点时：右子树有两个节点，两个节点的布局 和 n=2时两棵树的布局 是一样的
• 当2为头结点时：左右子树都只有一个节点，一个节点的布局 和 n=1时只有一棵树的布局 是一样的
• 当3为头结点时：左子树有两个节点，两个节点的布局 和 n=2时两棵树的布局 是一样的
  • dp[3]：元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量
  • 元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量dp[2] * 左子树有0个元素的搜索树数量dp[0]
  • 元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量dp[1] * 左子树有1个元素的搜索树数量dp[1]
  • 元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量dp[0] * 左子树有2个元素的搜索树数量dp[2]
  • dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]

解题思路：动态规划五部曲

• Step1：确定dp数组(一维)/dp表格(二维)、下标的含义
  • dp[i]：由i个节点组成的二叉搜索树的个数为dp[i]
• Step2：确定递推公式
  • 假设头节点的数值为j（需要遍历头节点的所有可能）
  • dp[j-1]：由j-1个节点组成的二叉搜索树的个数（左子树的节点个数为j-1）
  • dp[i-j]：由i-j个节点组成的二叉搜索树的个数（右子树的节点个数为i-j） 
• Step3：初始化dp数组
  • dp[0] = 1
  • dp[1] = 1 
  • dp[2] = 2
• Step4：确定遍历顺序
  • 从递推公式可以看出，i是由j-1和i-j推导而来，因此需要从前向后遍历
  • j从1遍历到i：j-1小于i；i-j小于i，因此i由小于i的项推导得到
• Step5：打印dp数组（调试）

#include <iostream>
using namespace std;
#include <vector>

class Solution
{
public: 
    int numTrees(int n) 
    {
        if (n == 1) return 1;
        if (n == 2) return 2;

        vector<int> dp(n + 1, 0);
        dp[0] = 1;  // 易错点：dp[0]不能为0，否则会导致左右子树的布局个数相乘为0
        dp[1] = 1;
        dp[2] = 2;

        for (int i = 3; i <= n; i++)      // 第一层for循环：遍历二叉搜索树中的节点个数
        {
            for (int j = 1; j <= i; j++)  // 第二层for循环：遍历头节点的数值（状态）
            {
                dp[i] += (dp[j - 1] * dp[i - j]);
            }
        }
        return dp[n];
    } 
};

int main()
{
    //int n = 3;  // 5
    int n = 1;  // 1

    Solution s;
    int ans = s.numTrees(n);

    cout << ans << endl;

    system("pause");
    return 0;
}

注意事项：当结点个数为0时，是否需要初始化，应该初始化为什么？这是一个难点(易错点、易漏点)。

• dp[0] = 1;  dp[0]不能为0，否则会导致左右子树的布局个数相乘为0
• 本题的解法不能进行状态压缩，因为每次计算dp[i]时，需要依赖前面的所有状态。