算法训练之动态规划（三）

♥♥♥~~~~~~欢迎光临知星小度博客空间~~~~~~♥♥♥

♥♥♥零星地变得优秀~也能拼凑出星河~♥♥♥

♥♥♥我们一起努力成为更好的自己~♥♥♥

♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥

♥♥♥如果有什么问题可以评论区留言或者私信我哦~♥♥♥
✨✨✨✨✨✨ 个人主页✨✨✨✨✨✨

接下来这篇博客我们将继续在题目中使用巧妙的动态规划思想~准备好了吗~我们发车去探索奥秘啦~🚗🚗🚗🚗🚗🚗

下降路径的最小和

这个题目看起来有点吓人，别怕，接下来我们一步步按照动态规划的思想来解决这道问题~

分析：

1、状态表示

结合这里的题目要求+经验：我们这里的状态表示——dp[i][j]为到达该位置的最小路径和

2、状态转移方程

       我们以离【i】【j】位置最近的状态分析状态转移方程（题目要求最多相隔一列）所以有下面的三种情况：

1、到达该位置，可能是从第【i-1】【j】位置向下一步到达的

2、到达该位置，可能是从第【i-1】【j-1】位置向下再向右一步到达的

3、到达该位置，可能是从第【i-1】【j+1】位置向下再向左一步到达的

       所以到达该位置最小路径和也就是三种情况的最小值再加上当前位置的数据（注意下标映射关系），所以状态转移方程也就是：

                dp[i][j]=min(min(dp[i-1][j],dp[i-1][j-1]),dp[i-1][j+1]) + nums[i-1][j-1]

3、初始化

        我们可以看到，状态转移方程里面有i-1,j-1，j+1当i=0或者j=0或者j=n的时候显然会出现越界的情况，所以我们需要进行初始化

        结合前面如果不想初始化太麻烦，我们可以多申请一些空间，这里与前面不一样的是这里是我们这里还有一个j+1，那么我们这里也就可以多申请一行两列~那么怎么初始化这一行两列呢？

        我们结合例子来看看：

        我们首先来看看结合我们的逻辑dp[i][j]里面的值在具体的例子中是多少？

      我们可以看到第一行就是它本身的值，而第一行是受到我们增加的那一行影响的，所以我们增加的那一行应该全部初始化为0，才不会出错~接下来看后面的两行，都是在取上一行三个位置的最小值加上当前位置值得到的，那么旁边的两列如果也初始化为0的话，那么边界找到的最小值就是0了，这并不是数组里面的有效数据~所以为了避免影响，我们也就可以把两列位置设置成INT_MAX,题目给出数据大小范围，显然dp[i][j]是不会超过INT_MAX的，那么我们就可以这样进行初始化~

                第一行初始化为0,剩下的位置初始化为INT_MAX



        这种初始化方式还需要注意的是下标的映射关系~

4、填表顺序

我们这里的逻辑是从上面依次推出下面的，所以填表顺序是从上向下

5、返回结果

这里返回结果也与我们前面的不一样，因为它不是一个具体的位置，最小路径和存在于最后一行，所以我们可以找到dp表最后一行最小值进行返回~

代码实现：

class Solution 
{
public:
    int minFallingPathSum(vector<vector<int>>& matrix) 
    {
        //1、创建dp表
        int m=matrix.size();
        int n=matrix[0].size();
        //多创建一行两列
        vector<vector<int>> dp(m+1,vector<int>(n+2,INT_MAX));
        //最开始就把所有位置初始化为INT_MAX
        //2、初始化
        //最开始就把所有位置初始化为INT_MAX了
        //初始化第一行为0
        for(int j=0;j<=n+1;j++)
        {
            dp[0][j]=0;
        }
        //3、填表
        for(int i=1;i<=m;i++)
        {
            for(int j=1;j<=n;j++)
            {
                dp[i][j]=min(min(dp[i-1][j-1],dp[i-1][j]),dp[i-1][j+1])+matrix[i-1][j-1];//注意下标映射关系
            }
        }
        //4、返回结果
        //找到最后一行最小值进行返回
        int ret=dp[m][1];
        for(int i=2;i<=n;i++)
        {
            ret=min(ret,dp[m][i]);
        }
        return ret;
    }
};

顺利通过~分析之后也就十分清楚了，我们来看看下一道题目~

最小路径和

我们同样可以一步步来分析：

1、状态表示

结合这里的题目要求+经验：我们这里的状态表示——dp[i][j]为到达该位置的最小总和

2、状态转移方程

       我们以离【i】【j】位置最近的状态分析状态转移方程（题目要求只能向下或者向右移动）所以有下面的两种情况：

1、到达该位置，可能是从第【i-1】【j】位置向下一步到达的

2、到达该位置，可能是从第【i】【j-1】位置向右一步到达的

       所以到达该位置最小总和也就是两种情况的最小值再加上当前位置的数据（注意下标映射关系），所以状态转移方程也就是：

                dp[i][j]=min(dp[i-1][j],dp[i][j-1]) + nums[i-1][j-1]

3、初始化

        我们可以看到，状态转移方程里面有i-1,j-1当i=0或者j=0的时候显然会出现越界的情况，所以我们需要进行初始化

        结合前面如果不想初始化太麻烦，我们可以多申请一些空间，那么我们这里结合经验也就可以多申请一行一列~那么怎么初始化这一行一列呢？

        我们结合例子来看看：

        我们首先来看看结合我们的逻辑dp[i][j]里面的值在具体的例子中是多少？

      我们可以看到除了左上角的数就是它本身的值，其他的值都发生了变化，而左上角的数是受到它上面的位置和左边的位置影响的，结合状态转移方程 dp[i][j]=min(dp[i-1][j],dp[i][j-1]) + nums[i-1][j-1]，所以它上面的位置和左边的位置应该初始化为0，才不会出错~接下来看剩下的位置，每一个位置都是在取当前位置上面的位置和左边的位置的最小值加上当前位置值得到的，那么如果也初始化为0的话，那么边界找到的最小值就是0了，这并不是数组里面的有效数据~所以为了避免影响，我们也就可以把剩下的设置成INT_MAX,题目给出数据大小范围，显然dp[i][j]是不会超过INT_MAX的，那么我们就可以这样进行初始化~

       dp[1][0]=dp[0][1]=0,剩下的位置初始化为INT_MAX

        这种初始化方式还需要注意的是下标的映射关系~

4、填表顺序

我们这里的逻辑是从上面依次推出下面的，所以填表顺序是从上向下

5、返回结果

右下角的位置就是我们想要的结果，直接返回dp[m][n]就可以了

有了前面题目的铺垫，相信这道题目就手到擒来了~

代码实现：

class Solution 
{
public:
    int minPathSum(vector<vector<int>>& grid) 
    {
        //1、创建dp表
        int m=grid.size();
        int n=grid[0].size();
        //dp表最开始全部初始化为INT_MAX
        vector<vector<int>> dp(m+1,vector<int>(n+1,INT_MAX));

        //2、初始化
        dp[0][1]=dp[1][0]=0;

        //3、填表
        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];
                //注意下标映射关系
            }
        }
        //4、返回结果
        return dp[m][n];
    }
};

顺利通过~

地下城游戏

一看这题目就有点吓人，我们同样按照我们之前的步骤来进行分析：

1、状态表示

        结合这里的题目要求+经验：状态表示一般有两种方式：

1、以某一个位置为结尾分析：

        我们这里来看看如果我们以【i】【j】位置为结尾来分析的话，认为dp【i】【j】表示的是到该位置的最低健康点数，那么我们可以发现dp【i】【j】不仅仅受到前面位置的影响，还会受到后面位置的影响，这样就会十分麻烦，所以我们换一种方式~

2、以某一个位置为起点分析：

        我们这里来看看如果我们以【i】【j】位置为起点来分析的话，认为dp【i】【j】表示的是从该位置开始到达指定位置的最低健康点数，那么dp【i】【j】只受到后面位置的影响，这样就更加方便~

2、状态转移方程

       我们以离【i】【j】位置最近的状态分析状态转移方程（题目要求只能向下或者向右移动）所以有下面的两种情况：

1、以该位置为起点，可能是向下一步到达第【i+1】【j】位置

2、以该位置为起点，可能是向右一步到达第【i】【j+1】位置

       所以dp【i】【j】也就是以该位置为起点，两种情况的最小值再减去当前位置的数据（这里增加不需要注意下标映射关系），所以状态转移方程也就是：

                dp[i][j]=min(dp[i+1][j],dp[i][j+1]) - nums[i][j]

        这样处理之后，还有一种情况就是dp[i][j]是负数了，也就是nums[i][j]很大，那么该位置的最小健康点数只需要是1经过加上nums[i][j]就可以了，所以还需要处理为负数的情况~

        dp[i][j]=max(1,dp[i][j])

3、初始化

        我们可以看到，状态转移方程里面有i+1,j+1当i=m-1或者j=n-1的时候显然会出现越界的情况，所以我们需要进行初始化

        结合前面如果不想初始化太麻烦，我们可以多申请一些空间，那么我们这里结合经验也就可以多申请一行一列~与前面不同的是这里是以【i】【j】位置为起点来分析，所以加的那一行一列在后面，那么怎么初始化这一行一列呢？

        我们结合例子来看看：

        我们首先来看看结合我们的逻辑dp[i][j]里面的值在具体的例子中是多少？

      我们可以看到除了右下角的数到达右边或者下边那一个位置至少还应该剩下1的健康点数，不能刚好到了就死亡了，所以dp【m-1】【n】=dp【m】【n-1】=1，接下来看剩下的位置，每一个位置都是在取当前位置下面的位置和右边的位置的最小值加上当前位置值得到的，那么如果也初始化为1的话，那么边界找到的最小值就是错误的~所以为了避免影响，我们也就可以把剩下的设置成INT_MAX,题目给出数据大小范围，显然dp[i][j]是不会超过INT_MAX的，那么我们就可以这样进行初始化~

       dp[m-1][n]=dp[m][n-1]=1,剩下的位置初始化为INT_MAX

        这种初始化方式还不需要注意下标的映射关系了~因为位置与数组一一对应的~

4、填表顺序

我们这里的逻辑是从下面/右边依次推出上面/左边的，所以填表顺序是从下向上，从右向左

5、返回结果

左上角的位置就是我们想要的结果，直接返回dp[0][0]就可以了

代码实现：

class Solution 
{
public:
    int calculateMinimumHP(vector<vector<int>>& d) 
    {
        //1、创建dp表
        int m=d.size();
        int n=d[0].size();
        //最开始全部初始化为INT_MAX
        vector<vector<int>> dp(m+1,vector<int>(n+1,INT_MAX));

        //2、初始化
        dp[m-1][n]=dp[m][n-1]=1;

        //3、填表
        //注意填表顺序
        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])-d[i][j];
                //处理为负的情况
                dp[i][j]=max(1,dp[i][j]);
            }
        }
        //4、返回结果
        return dp[0][0];
    }
};