【刷题】动态规划专题(一)矩阵DP

  • Matrix DP

动态规划实质就是先对问题进行解构,找到最小子问题。以leetcode120. 三角形最小路径和为例:

给定一个三角形,找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。
相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。
例如,给定三角形:
[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
自顶向下的最小路径和为 11(即,2 + 3 + 5 + 1 = 11)。

现在想求这个有四层的三角形的最小路径,我们必须知道三层三角形的最小路径,根据转移条件从从第三层的每个结点到第四层都有两种路径,直接跳到正下方的结点或者正下方右边结点,也就是从(3,j)->(4,j)或(3,j)->(4,j+1)。

直接找到最小路径和是有困难的,要遍历所有可能的路径,但是假如已经知道到第三层每个结点的最小路径和,计算从第三层每个结点到第四层每个结点的最小路径是简单的。
在这里插入图片描述

  • 到最左边结点的路径和:直接由到正上方结点的最小路径和加上自身得到。
  • 到最右边结点的路径和:直接由到上一层前一个结点的最小路径和加上自身得到。
  • 到中间结点的路径和:到上一层第i个结点和第i-1个结点的最小路径和加上自身得到。
    这里要注意由于转移条件的限制,并不是每一层直接取最小值就能得到具有最小路径和的路径,能直接算的只是到每个结点的最小路径和,然后在进行比较。

形式化描述为:
dp[i][j]:为到第i层第j个节点的最小路径和
在这里插入图片描述
总结一下这个套路:

  1. 先将问题分解找到最基本的子问题,一般我们可以从前i个结果已知如何得到第i+1的结果这个角度入手。
  2. 通过分析得到转移方程,想清楚dp数组的具体含义。
  3. 想清楚如何初始化以及边界问题。
    上代码:
class Solution {
public:
    int minimumTotal(vector<vector<int>>& triangle) {
        int n = triangle.size();
        int m = triangle[n-1].size();
        
        vector<vector<int>>dp(triangle);
        
        for(int i=1;i<n;i++){
            for(int j = 0;j<=i;j++){
                if(j==0){
                    dp[i][j] = dp[i-1][j]+dp[i][j];
                }else if(j==i){
                    dp[i][j] = dp[i-1][j-1]+dp[i][j];
                }else{
                    dp[i][j] = min(dp[i-1][j],dp[i-1][j-1])+dp[i][j];
                }
            }
        }
        int ans = INT_MAX;
        for(int i=0;i<m;i++){
            ans=min(dp[n-1][i],ans);
        }
        return ans;
    }
};

leetcode64. 最小路径和

给定一个包含非负整数的 m x n 网格,请找出一条从左上角到右下角的路径,使得路径上的数字总和为最小。
说明:每次只能向下或者向右移动一步。
示例:
输入:
[
[1,3,1],
[1,5,1],
[4,2,1]
]
输出: 7
解释: 因为路径 1→3→1→1→1 的总和最小。

分析:

  1. dp[i][j]:从左上角到(i,j)的最小路径和
  2. 确定转移方程:在这里插入图片描述
  3. 每个dp(i,j)的值是根据左边和右边结点的值计算得到的,所以dp的计算方向应该是从左到右,从上到下。
  4. 边界:dp[0][0],初始状态:grid[0][0]
class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m = grid.size(),n = grid[0].size();
        int dp[m][n];//从左上角到(m,n)的最小路径和
        dp[0][0] = grid[0][0];
        for(int i=1;i<m;i++)
            dp[i][0] = dp[i-1][0]+grid[i][0];
        for(int i=1;i<n;i++)
            dp[0][i] = dp[0][i-1]+grid[0][i];
        for(int i=1;i<m;i++){
            for(int j =1;j<n;j++){
                dp[i][j] = min(dp[i-1][j],dp[i][j-1])+grid[i][j];
            }
        }
        return dp[m-1][n-1];
    }
};

62. 不同路径

一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为“Start” )。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为“Finish”)。
问总共有多少条不同的路径?
例如,上图是一个7 x 3 的网格。有多少可能的路径?
示例 1:
输入: m = 3, n = 2
输出: 3
解释:
从左上角开始,总共有 3 条路径可以到达右下角。

  1. 向右 -> 向右 -> 向下
  2. 向右 -> 向下 -> 向右
  3. 向下 -> 向右 -> 向右 示例 2: 输入: m = 7, n = 3 输出: 28 提示: 1 <= m, n <= 100 题目数据保证答案小于等于 2 * 10 ^ 9
    分析:
  1. dp[i][j]:从左上角到(i,j)的不同路径条数
  2. 确定转移方程:在这里插入图片描述
  3. 每个dp(i,j)的值是根据左边和右边结点的值计算得到的,所以dp的计算方向应该是从左到右,从上到下。
  4. 边界:dp[0][0],初始状态:0
class Solution {
public:
    static const int maxn = 100;
    int dp[maxn][maxn];
    int uniquePaths(int m, int n) {
        dp[0][0];
        for(int i=0;i<n;i++)
            dp[i][0] = 1;
        for(int i=0;i<m;i++)
            dp[0][i]= 1;
        for(int i =1;i<n;i++){
            for(int j =1;j<m;j++){
                dp[i][j] = dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[n-1][m-1];
    }
};

63. 不同路径 II

一个机器人位于一个 m x n 网格的左上角 (起始点在下图中标记为“Start” )。
机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角(在下图中标记为“Finish”)。
现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径?
网格中的障碍物和空位置分别用 1 和 0 来表示。
说明:m 和 n 的值均不超过 100。
示例 1:
输入:
[
[0,0,0],
[0,1,0],
[0,0,0]
]
输出: 2
解释:
3x3 网格的正中间有一个障碍物。
从左上角到右下角一共有 2 条不同的路径:

  1. 向右 -> 向右 -> 向下 -> 向下
  2. 向下 -> 向下 -> 向右 -> 向右

分析:在上一题的基础上需要考虑当前单元的左边或上边单元有障碍物时,那这条路径就断了。

class Solution {
public:
    static const int maxn= 100;
    int dp[maxn][maxn];
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid[0].size(),n = obstacleGrid.size(); 
        if(obstacleGrid[0][0]==1)return 0;
        dp[0][0]=1;
        for(int i=1;i<m;i++){
            if(obstacleGrid[0][i]==0)
                dp[0][i] = dp[0][i-1];
            else dp[0][i] = 0;
        }
        for(int i=1;i<n;i++){
            if(obstacleGrid[i][0]==0)
                dp[i][0] = dp[i-1][0];
            else dp[i][0] = 0;
        }
        for(int i=1;i<n;i++){
            for(int j =1;j<m;j++){
                if(obstacleGrid[i][j]==0){
                    if(obstacleGrid[i-1][j]==0)
                        dp[i][j] = dp[i-1][j]+dp[i][j];
                    if(obstacleGrid[i][j-1]==0)
                        dp[i][j] = dp[i][j-1]+dp[i][j];
                }else dp[i][j] = 0;
            }
        }

        return dp[n-1][m-1];
    }
};
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值