【学习】动态规划算法 + LC代码

---

学习资料为B站视频：【动态规划专题班】动态规划入门 Introduction to Dynamic Programming

动态规划应对问题

动态规划四大步骤

1. 确定状态
   1.1 最后一步
   1.2 子问题
2. 转移方程
3. 初始条件和边界条件
4. 计算顺序

一、求最大值最小值

以类似LC322. 零钱兑换/硬币兑换为基础讲解
题目：

你有三种硬币：2、5、7元，每种足够多枚
买一本书27元
如何用最少的硬币数，正好付清

1. 确定状态

1.1 最后一步

1.2 子问题

如果用递归方法解？会有什么问题？

• 如何避免：
  动态规划，将结果保存下来，并改变计算顺序

2. 转移方程

3. 初始条件和边界条件

• 初始条件
  注意f[0] = 0，转移方程算不出来，需要手动定义，x>0就不需要了
• 边界条件
  注意数组不要越界

4. 计算顺序

• 时间复杂度
  金额：n
  硬币种类：m
  时间复杂度：O(n*m)
  

代码 LC322. 零钱兑换

int coinChange(vector<int>& coins, int amount) {
    if(amount == 0)         return 0;
    if(coins.size() == 0)   return -1;

    //声明一个amount+1长度的数组dp, 0...n
    //dp代表各个金额，第0个钱包可以容纳的总价值为0，其它全部初始化为无穷大
    //dp[j]代表金额为j时，所需要的最少硬币的个数
    vector<int>dp(amount + 1 , INT_MAX); 
    dp[0] = 0;
	
	// dp[1]....dp[amount]
	for(int i=0; i<=amount; i++){
		// 计算最后的coins[j]
		// dp[i] = min{dp[i-coins[0]]+1, ..., dp[i-coins[n-1]+1}
		for(int j = 0; j < coins.size(); j++){
            if(i >= coins[j] && dp[i-coins[j]] != INT_MAX){
                dp[i] = min(dp[i], dp[i-coins[j]]+1);
            }
	}
	return dp[amount] == INT_MAX ? -1 : dp[amount];
}

二、计数问题

1. 确定状态

2. 转移方程

3. 初始和边界条件

4. 计算顺序

代码 LC62. 不同路径

    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n,1));
        for(int i=1; i<m; i++){
            for(int j=1; j<n; j++){
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1]; 
    }

优化：空间复杂度O(n)

    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n,1));
        for(int i=1; i<m; i++){
            for(int j=1; j<n; j++){
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1]; 
    }

代码 LC63. 不同路径II（有障碍）

    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        if(obstacleGrid[0][0] == 1) return 0;

        int n = obstacleGrid.size(), m = obstacleGrid[0].size();
        vector<vector<int>> dp(n, vector<int>(m,0));

        for(int i=0; i<n; i++){
            for(int j=0; j<m; j++){
                if(obstacleGrid[i][j] == 1){
                    dp[i][j] = 0;
                }
                else{
                    if(i == 0 && j == 0)    dp[i][j] = 1;
                    else if(i==0) dp[i][j]=dp[i][j-1];
                    else if(j==0) dp[i][j]=dp[i-1][j];
                    else    dp[i][j] = dp[i-1][j] + dp[i][j-1];
                }
            }
        }
        return dp[n-1][m-1];
    }

参考题解：简单DP，🤷‍♀️必须秒懂！

三、可行性

1. 确定状态

2. 转移方程

3. 初始条件和边界条件

4. 计算顺序

代码 LC55. 跳跃游戏

• 贪心算法

    bool canJump(vector<int>& nums) {
        int maxLength = 0;	// 记录每次能达到的最大位置
        for(int i = 0; i<nums.size(); i++){
            if(maxLength >= nums.size()-1)   return true;
            if(maxLength < i)   return false;
            maxLength = max(maxLength, i+nums[i]);
        }
        return true;
    }

• dp方法超时
  

总结