【算法】DP系列之路径问题

NeeEk0

于 2024-10-11 10:47:20 发布

阅读量717

点赞数 21

分类专栏： NeeEk0 陪你一起算法登峰文章标签：算法 c++ leetcode 数据结构动态规划 dp

本文链接：https://blog.csdn.net/waluolandao/article/details/142787502

版权

NeeEk0 陪你一起算法登峰专栏收录该内容

27 篇文章 0 订阅

订阅专栏

【ps】本篇有 6 道 leetcode OJ。

一、算法简介

动态规划（Dynamic Programming）算法的核心思想是：将大问题划分为小问题进行解决，从而一步步获取最优解的处理算法

动态规划算法与分治算法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。

与分治法不同的是，适合于用动态规划求解的问题，经分解得到的子问题往往不是互相独立的（即下一个子阶段的求解是建立在上一个子阶段的解的基础上）。

【Tips】动态规划算法解决问题的分类

计数：有多少种方式走到右下角 / 有多少种方法选出k个数使得和是 sum。
求最大值/最小值：从左上角走到右下角路径的最大数字和最长上升子序列长度。
求存在性：取石子游戏，先手是否必胜 / 能不能取出 k 个数字使得和是 sum。

【Tips】动态规划dp算法一般步骤

确定状态表示（dp[ i ] 的含义是什么，来源：1、题目要求；2、经验+题目要求；3、分析问题时发现重复子问题）
状态转移方程（可求得 dp[ i ] 的数学公式，来源：题目要求+状态表示）
初始化（dp 表中特别的初始值，保证填 dp 表时不会越界，来源：题目要求+状态表示）
填表顺序（根据状态转移方程修改 dp[ i ] 的方式，来源：题目要求+状态表示）
返回值（题目求解的结果，来源：题目要求+状态表示）

二、相关例题

1）不同路径

62. 不同路径

.1- 题目解析

dp[i][j] 表示：到 [i, j] 位置处，⼀共有多少种方式。
状态转移方程：dp[i][j] = dp[i-1][j] + dp[i][j-1]。
初始化：dp[0][1] = 1（ps：我们创建了虚拟节点来映射下标）。
填表顺序：从左往右、从上到下。
返回值：dp[m][n]。

.2- 代码编写

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m+1,vector<int>(n+1));
        dp[0][1]=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][n];
    }
};

2）不同路径 II

63. 不同路径 II

.1- 题目解析

dp[i][j] 表示：到 [i, j] 位置处，一共有多少种方式。
状态转移方程：如果不是障碍物，dp[i][j] = dp[i-1][j] + dp[i][j-1]；如果是障碍物，为 dp[i][j] = 0。
初始化：dp[1][0] = 1（ps：我们创建了虚拟节点来映射下标）。
填表顺序：从左往右、从上到下。
返回值：dp[m][n]。

.2- 代码编写

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

3）珠宝的最高价值

LCR 166. 珠宝的最高价值

.1- 题目解析

dp[i][j] 表示：到 [i, j] 位置处，此时的最大价值。
状态转移方程：dp[i][j] = frame[i-1][j-1] + max(dp[i-1][j], dp[i][j-1])。
初始化：dp[0][0] = 0（ps：我们创建了虚拟节点来映射下标）。
填表顺序：从左往右、从上到下。
返回值：dp[m][n]。

.2- 代码编写

class Solution {
public:
    int jewelleryValue(vector<vector<int>>& frame) {
        int m=frame.size(),n=frame[0].size();
        vector<vector<int>> dp(m+1,vector<int>(n+1));
        for(int i=1;i<=m;i++)
            for(int j=1;j<=n;j++)
                dp[i][j]=max(dp[i-1][j],dp[i][j-1])+frame[i-1][j-1];//注意引入虚拟节点后，下标的映射
        return dp[m][n];
    }
};

4）下降路径最小和

931. 下降路径最小和

.1- 题目解析

dp[i][j] 表示：到 [i, j] 位置处，此时下降路径最小和。
状态转移方程：dp[i][j] = matrix[i-1][j-1] + min(min(dp[i-1][j], dp[i-1][j-1]), dp[i-1][j+1])。
初始化：为了保证填表正确，将 dp 表的第一行全部初始化为 0，其余元素初始化为整型最大值 INT_MAX（ps：我们创建了虚拟节点来映射下标）。
填表顺序：从上到下。
返回值：dp 表最后一行中的最小值。

.2- 代码编写

class Solution {
public:
    int minFallingPathSum(vector<vector<int>>& matrix) {
        int n=matrix.size();
        vector<vector<int>> dp(n+1,vector<int>(n+2,INT_MAX));
        for(int j=0;j<n+2;j++) dp[0][j]=0;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                dp[i][j]=min(dp[i-1][j-1],min(dp[i-1][j],dp[i-1][j+1]))
                            + matrix[i-1][j-1];
        int ret=INT_MAX;
        for(int j=1;j<=n;j++)
            ret=min(ret,dp[n][j]);
        return ret;
    }
};

5）最小路径和

64. 最小路径和

.1- 题目解析

dp[i][j] 表示：到 [i, j] 位置处，此时的最小路径和。
状态转移方程：dp[i][j] = grid[i-1][j-1] + min(dp[i-1][j], dp[i][j-1])。
初始化：为了保证填表正确，dp[0][1]=dp[1][0]=0，其余元素初始化为整型最大值 INT_MAX（ps：我们创建了虚拟节点来映射下标）。
填表顺序：从上到下、从左往右。
返回值：dp[m][n]。

.2- 代码编写

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        int m=grid.size(),n=grid[0].size();
        vector<vector<int>> dp(m+1,vector<int>(n+1,INT_MAX));
        dp[0][1]=dp[1][0]=0;
        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-1][j-1];
        return dp[m][n];
    }
};

6）地下城游戏

174. 地下城游戏

.1- 题目解析

这道题的状态表示如果定义成：“从起点开始，到达 [i, j] 位置的时候，所需的最低初始健康点数”，那么分析状态转移方程的时候会有一个问题，当前的健康点数还会受到后面的路径的影响。也就是说，从上往下的状态转移不能很好地解决问题。

此时我们可以换⼀种状态表示：从 [i, j] 位置出发，到达终点时所需要的最低初始健康点数。这样在分析状态转移的时候，后续的最佳状态就已经知晓。

dp[i][j] 表示：从 [i, j] 位置出发，到达终点时所需的最低初始健康点数。
状态转移方程：dp[i][j] = min(dp[i + 1][j], dp[i][j + 1]) - dungeon[i][j] 和 dp[i][j]=max(1,dp[i][j])；如果当前位置的 dungeon[i][j] 是⼀个比较大的正数的话（大血包），由状态转移方程，dp[i][j] 的值可能变成 0 或负数，也就是说，骑士会死亡，但这显然是不合理的，因此，求出来的 dp[i] [j] 如果小于等于 0 的话，此时的最低初始值其实应该为 1 。
初始化：在 dp 表最后面添加一行，并且添加一列后，所有的值都先初始化为INT_MAX，然后让 dp[m][n - 1] = dp[m - 1][n] = 1 即可。
填表顺序：从下往上、从右往左。
返回值：dp[0][0]。

.2- 代码编写

class Solution {
public:
    int calculateMinimumHP(vector<vector<int>>& dungeon) {
        int m=dungeon.size(),n=dungeon[0].size();
        vector<vector<int>> dp(m+1,vector<int>(n+1,INT_MAX));
        dp[m][n-1]=dp[m-1][n]=1;
        for(int i=m-1;i>=0;i--)
            for(int j=n-1;j>=0;j--)
            {
                dp[i][j]=min(dp[i+1][j],dp[i][j+1])-dungeon[i][j];
                dp[i][j]=max(1,dp[i][j]);
            }    
        return dp[0][0];
                
    }
};