动态规划一 - 技术栈

1.斐波那契数列模型

[题目一------1137. 第 N 个泰波那契数 - 力扣（LeetCode）](#题目一——1137. 第 N 个泰波那契数 - 力扣（LeetCode）)

[题目二------面试题 08.01. 三步问题 - 力扣（LeetCode）](#题目二——面试题 08.01. 三步问题 - 力扣（LeetCode）)

[题目三------746. 使用最小花费爬楼梯 - 力扣（LeetCode）](#题目三——746. 使用最小花费爬楼梯 - 力扣（LeetCode）)

1.3.1.解法一

[1.3.2. 解法二](#1.3.2. 解法二)

[题目四------91. 解码方法 - 力扣（LeetCode）](#题目四——91. 解码方法 - 力扣（LeetCode）)

2.路径问题

[题目一------62. 不同路径 - 力扣（LeetCode）](#题目一——62. 不同路径 - 力扣（LeetCode）)

[题目二------63. 不同路径 II - 力扣（LeetCode）](#题目二——63. 不同路径 II - 力扣（LeetCode）)

[题目三------LCR 166. 珠宝的最高价值 - 力扣（LeetCode）](#题目三——LCR 166. 珠宝的最高价值 - 力扣（LeetCode）)

[题目四------931. 下降路径最小和 - 力扣（LeetCode）](#题目四——931. 下降路径最小和 - 力扣（LeetCode）)

[题目五------64. 最小路径和 - 力扣（LeetCode）](#题目五——64. 最小路径和 - 力扣（LeetCode）)

[题目六------174. 地下城游戏 - 力扣（LeetCode）](#题目六——174. 地下城游戏 - 力扣（LeetCode）)

1.斐波那契数列模型

题目一------1137. 第 N 个泰波那契数 - 力扣（LeetCode）

我们很容易就得到下面这个公式

这样子有没有发现我们可以一直通过这个公式递推后面的数啊

使用动态规划来处理的话，一般是5步来进行的

确定一个状态表示
根据状态表示来推导状态表示方程
初始化
填表顺序
返回值

确定一个状态表示

一般而言，动态规划会创建一个一维数组或者二维数组，并且取名为dp，通常这个数组也被叫做dp表

接下来我们就是想办法把里面填满，然后里面的某一个值可能就是我们的最终结果。

好，接下来来解释一下上面的5步。

确定一个状态表示的意思就是确定dp表里面每个位置存放的值的含义（这个含义就是状态表示）

**那这个状态表示怎么来的？**这里只讲下面3个

题目要求
经验+题目要求（非常常用）
分析问题的过程中，发现重复子问题

这个状态表示怎么来的是非常重要的！！！我们需要不断的练习才会明白

在我们这个题目里面，我们可以让dp[n]存储的值即可。

状态转移方程

说白了，状态转移方程就是dp[i]=？，我们得想办法通过前面（或者后面）的状态来推导dp[i]等于什么。

就像现在这道题目里的，这就是一个现成的方程，的计算依赖于前面3个状态。

我们就能得到dp[i]=dp[i-1]+dp[i-2]+dp[i-3]，这就是状态转移方程，dp[i]的计算依赖于前面3个状态。

状态转移方程的推导是动态规划的难点！！！我们得好好学习

初始化

其实就是保证填dp表的时候不越界。

我们是根据状态转移方程来填表的，但是状态转移方程不一定适用于所有元素。

就像这题的dp[i]=dp[i-1]+dp[i-2]+dp[i-3]，有没有考虑一下下标为0，1，2这3个位置的元素呢？这3个位置的元素是不能使用动态转移方程来计算的，因为那会越界访问。所有我们得先处理这3个位置的元素。

这道题很贴心啊，直接告诉我们了

这样子我们的dp[0]，dp[1]，dp[2]就填好了，后面我们填dp[3]，dp[4]的时候就不会越界了。

填表顺序

其实就是为了填写当前状态的时候，所需要的状态已经计算过了。

就像是 dp[i]=dp[i-1]+dp[i-2]+dp[i-3]，我们首先得知道dp[i-1]，dp[i-2]，dp[i-3]吧！！！

所以我们需要从左往右填

返回值

我们可以根据题目要求和状态表示来确定

题目要求是给你整数 n，请返回第 n 个泰波那契数 Tn 的值。
状态表示是Tn的值

那我直接返回dp[n]不就好了吗！！

我们很快就能写出代码

cpp 复制代码

class Solution {
public:
    int tribonacci(int n) {
        if (n == 0 )
            return 0;
        if(n==1||n==2)
            return 1;
        
        //创建dp表，注意需要n+1大小
        vector<int> dp(n + 1); // dp[i] 表⽰：第 i 个泰波那契数的值。

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

        // 从左往右填表
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];//状态转移方程
        }

        //返回结果
        return dp[n];
    }
};

内存优化版本

接下来我将讲解这个内存优化版本

动态规划的内存优化，我只会在这题和后面的背包问题里面讲解。

我们这题可以使用滚动数组来看看

有没有想过dp[i]=dp[i-1]+dp[i-2]+dp[i-3]，求dp[i]只需要dp[i-1]，dp[i-2]，dp[i-3]这3个，那我可不可以搞3个变量，不搞数组了！！！后面一个进来，前面一个出去就好。

cpp 复制代码

class Solution {
public:
    int tribonacci(int n) {
        if (n == 0)
            return 0;
        if (n == 1 || n == 2)
            return 1;
        int a = 0, b = 1, c = 1, d = 0;
        for (int i = 3; i <= n; i++) {
            d = a + b + c;
            a = b;
            b = c;
            c = d;
        }
        return d;
    }
};

题目二------面试题 08.01. 三步问题 - 力扣（LeetCode）

这个题目数据量特别大啊。

我们先模拟一下这个题目怎么做？

嗯？一顿分析下来，怎么感觉和上题差不多

1.确定状态表⽰

这道题可以根据「经验+题⽬要求」

直接定义出状态表⽰：

dp[i] 表⽰：到达 i 位置时，⼀共有多少种⽅法。

2.根据状态表示推导状态转移⽅程

我们一般是使用之前或者之后的状态来推导这个dp[i]的！！！

以i位置状态的最近的⼀步，来分情况讨论：

如果 d p[i] 表⽰⼩孩上第 i 阶楼梯的所有⽅式，那么它应该等于所有上⼀步的⽅式之和：

i. 上⼀步上⼀级台阶， dp[i] += dp[i - 1] ；
ii. 上⼀步上两级台阶， dp[i] += dp[i - 2] ；
iii. 上⼀步上三级台阶， dp[i] += dp[i - 3] ；

综上所述， dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3] 。

需要注意的是，这道题⽬说，由于结果可能很⼤，需要对结果取模。

在计算的时候，三个值全部加起来再取模，即(dp[i - 1] + dp[i - 2] + dp[i - 3]) % MOD 是不可取的，同学们可以试验⼀下， integer overflow 。

n 取题⽬范围内最⼤值时，⽹站会报错 signed 对于这类需要取模的问题，我们每计算⼀次（两个数相加/乘等），都需要取⼀次模。否则，万⼀发⽣了溢出，我们的答案就错了。

3. 初始化

从我们的递推公式可以看出，推导的，因为 dp[-3] dp[i] 在 i = 0, i = 1 以及 dp[-2] 或 i = 2 的时候是没有办法进⾏ dp[-1] 不是⼀个有效的数据。

因此我们需要在填表之前，根据题意将 1， 2 ， 3 位置的值初始化。

dp[1] = 1, dp[2] = 2, dp[3] = 4 。

4. 填表顺序

毫⽆疑问是「从左往右」。

5. 返回值

直接返回dp[n] 的值。

cpp 复制代码

class Solution {
public:
    const int MOD = 1e9 + 7;
    int waysToStep(int n) {     
        // 处理边界情况
        if (n == 1 || n == 2)
            return n;
        if (n == 3)
            return 4;
        // 1. 创建 dp 表
        vector<int> dp(n + 1);
        // 2. 初始化
        dp[1] = 1, dp[2] = 2, dp[3] = 4;
        // 3. 填表
        for (int i = 4; i <= n; i++)
            dp[i] = ((dp[i - 1] + dp[i - 2]) % MOD + dp[i - 3]) % MOD;
        // 4. 返回
        return dp[n];
    }
};

题目三------746. 使用最小花费爬楼梯 - 力扣（LeetCode）

这个题意是特别简单的吧！这题我们将使用2种dp思想来解决这个问题。

1.3.1.解法一

这是以i位置为结尾的思路来思考问题。

我们还是按照五步走走

1.确定状态表⽰

这道题可以根据「经验+题⽬要求」

直接定义出状态表⽰：

**dp[i] 表⽰：**到达i位置时候的最小花费

2.根据状态表示推导状态转移⽅程

我们一般是使用之前或者之后的状态来推导这个dp[i]的！！！

一般而言，根据经验而言，是通过最近的那个状态来推导的。也就是下面这个

从i-1位置来推导：先到达i-1位置，然后支付cost[i-1]，走一步
从i-2位置来推导：先到达i-2位置，然后支付cost[i-2]，走两步

为了使总花费最小，dp[i] 应取上述两项的最小值，因此状态转移方程如下：

dp[i]=min(dp[i−1]+cost[i−1],dp[i−2]+cost[i−2])

依次计算 dp 中的每一项的值，最终得到的 dp[n] 即为达到楼层顶部的最小花费。

3. 初始化

上面那个状态转移方程其实是有使用范围的，即 2≤i≤n 时。

从我们的递推公式可以看出，我们需要先初始化 i = 0 ，以及 i = 1 位置的值。容易得到 dp[0] = dp[1] = 0 ，因为不需要任何花费，就可以直接站在第 0 层和第 1 层上

4. 填表顺序

很简单，直接从左往右

5. 返回值

根据「状态表⽰以及题⽬要求」，需要返回 dp[n] 位置的值。

现在我们很容易就写出下面这个代码

cpp 复制代码

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int>dp(cost.size()+1);
        dp[0]=dp[1]=0;
        for(int i=2;i<cost.size()+1;i++)
        {
            dp[i]=min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
        }
        return dp[cost.size()];
    }
};

1.3.2. 解法二

我们可以以i位置为起点来思考这个问题

我们还是按照五步走走

1.确定状态表⽰

这道题可以根据「经验+题⽬要求」

直接定义出状态表⽰：

**dp[i] 表⽰：**从 i 位置出发，到达楼顶，此时的最⼩花费。

2.根据状态表示推导状态转移⽅程

我们一般是使用之前或者之后的状态来推导这个dp[i]的！！！

一般而言，根据经验而言，是通过最近的那个状态来推导的。

也就是下面这个

⽀付 cost[i] ，往后⾛⼀步，接下来从 i + 1 的位置出发到终点，这个时候dp[i]=dp[i+1] + cost[i]
⽀付cost[i] ，往后⾛两步，接下来从 i + 2 的位置出发到终点，这个时候dp[i]]=dp[i+2] + cost[i] ；

为了使总花费最小，因此状态转移方程如下：

dp[i] = min( dp[i + 1], dp[i + 2] ) + cost[i] 。

依次计算 dp 中的每一项的值，最终得到的 dp[n] 即为达到楼层顶部的最小花费。

3. 初始化

为了保证填表的时候不越界，我们需要初始化最后两个位置的值，结合状态表⽰易得：

dp[n - 1] = cost[n - 1]
dp[n - 2] = cost[n - 2]

4. 填表顺序

根据「状态转移⽅程」可得，遍历的顺序是「从右往左」。

5. 返回值

根据「状态表⽰以及题⽬要求」，需要返回 min(dp[0], dp[1]);的值

我们很快就得出

cpp 复制代码

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        int n=cost.size();
        vector<int>dp(n);
       dp[n-1]=cost[n-1];
       dp[n-2]=cost[n-2];
        for(int i=n-3;i>=0;i--)
        {
            dp[i]=min(dp[i+1],dp[i+2])+cost[i];
        }
        return  min(dp[0], dp[1]);;
    }
};

其实这种题目的状态表示怎么来的完全是根据经验得出的

以i位置为起点

以i位置为终点

这两种思想是特别重要的，特别是在线性dp的

题目四------91. 解码方法 - 力扣（LeetCode）

类似于斐波那契数列~

1. 状态表⽰：

根据以往的经验，对于⼤多数线性 dp ，我们经验上都是「以某个位置结束或者开始」做⽂章，这⾥我们继续尝试「⽤i位置为结尾」结合「题⽬要求」来定义状态表⽰。

dp[i] 表⽰：字符串中 [0 ， i] 区间上，⼀共有多少种编码⽅法。

2.根据状态表示推导状态转移方程

定义好状态表⽰，我们就可以分析 i 位置的 dp 值，如何由「前⾯」或者「后⾯」的信息推导出来。

关于 i 位置的编码状况，我们可以分为下⾯两种情况：

让 i 位置上的数单独解码成⼀个字⺟；
让 i 位置上的数与 i - 1 位置上的数结合，解码成⼀个字⺟。

下⾯我们就上⾯的两种解码情况，继续分析：

让i位置上的数单独解码成⼀个字⺟，就存在「解码成功」和「解码失败」两种情况：

i. 解码成功 ：当 i 位置上的数在[1, 9] 之间的时候，说明 i 位置上的数是可以单独解码的，那么此时 [0, i] 区间上的解码⽅法应该等于[0, i - 1] 区间上的所有解码结果。因为此时只需要在[0, i - 1] 区间上的解码⽅法后⾯填上⼀个 i 位置解码后的字⺟就可以了，但是这个不影响这个解码方式的总数。此时dp[i] = dp[i - 1]；。

ii. 解码失败 ：**当 i 位置上的数是 0 的时候，说明 i 位置上的数是不能单独解码的，那么此时 [ 0, i] 区间上不存在解码⽅法。**因为 i 位置如果单独参与解码，但是解码失败了，那么前⾯做的努⼒就全部⽩费了。此时dp[i] = 0 。

让 i 位置上的数与 i - 1 位置上的数结合在⼀起，解码成⼀个字⺟，也存在「解码成功」和「解码失败」两种情况：

i.解码成功 ：当结合的数（i-1位置上的数x10+i位置上的数）在 [10, 26] 之间的时候，说明 [i - 1, i] 两个位置是可以解码成功的，那么此时 [0, i] 区间上的解码⽅法应该等于 [0, i - 2 ]区间上的解码⽅法，原因同上。此时dp[i] = dp[i - 2]；

ii.解码失败 ：当结合的数（i-1位置上的数x10+i位置上的数）在 [0, 9] 和 [27 , 99] 之间的时候，说明两个位置结合后解码失败（这⾥⼀定要注意 00 01 02 03 04 ......这⼏种情况），那么此时 [0, i] 区间上的解码⽅法就不存在了，原因依旧同上。此时 dp[i] = 0 。

综上所述： dp[i] 最终的结果应该是上⾯四种情况下，解码成功的两种的累加和（因为我们关⼼的是解码⽅法，既然解码失败，就不⽤加⼊到最终结果中去），因此可以得到状态转移⽅程（ dp[i] 默认初始化为 0 ）：

当 s[i] 上的数在 [1, 9] 区间上时： dp[i] += dp[i - 1] ；
当 s[i - 1] 与 s[i] 上的数结合后，在 [10, 26] 之间的时候： dp[i] += dp[i - 2] ；
如果上述两个判断都不成⽴，说明没有解码⽅法， dp[i] 就是默认值 0 。

3.初始化：

⽅法⼀（直接初始化）： 由于可能要⽤到 i - 1 以及 i - 2 位置上的 dp 值，因此要先初始化「前两个位置」。

初始化 dp[0] ：

当 s[0] == '0' 时，没有编码⽅法，结果 dp[0] = 0 ；
当 s[0] != '0' 时，能编码成功， dp[0] = 1

初始化 dp[1] ：

当 s[1] 在 [1 ， 9] 之间时，能单独编码，此时 dp[1] += dp[0] （原因同上，dp[1] 默认为 0 ）
当 s[0] 与 s[1] 结合后的数在 [10, 26] 之间时，说明在前两个字符中，⼜有⼀种编码⽅式，此时 dp[1] += 1

4.填表顺序：

毫⽆疑问是「从左往右」

5.返回值：

应该返回 dp[n - 1] 的值，表⽰在 [0, n - 1] 区间上的编码⽅法。

使⽤直接初始化

cpp 复制代码

class Solution {
public:
    int numDecodings(string s) {
        int n = s.size();
        vector<int> dp(n); //创建⼀个dp 表

            //初始化前两个位置

        dp[0] = s[0]=='0'?0:1;
        if (n == 1)
            return dp[0]; //处理边界情况

        if (s[1] <= '9' && s[1] >= '1')
            dp[1] += dp[0];
        int t = (s[0] - '0') * 10 + s[1] - '0';
        if (t >= 10 && t <= 26)
            dp[1] += 1;
        
        //填表
        for (int i = 2; i < n; i++) {
            //如果单独编码
            if (s[i] <= '9' && s[i] >= '1')
                dp[i] += dp[i - 1];
            
            //如果和前⾯的⼀个数联合起来编码
            int t = (s[i - 1] - '0') * 10 + s[i] - '0';
            if (t >= 10 && t <= 26)
                dp[i] += dp[i - 2];
        }
        //返回结果
        return dp[n - 1];
    }
};

使⽤添加辅助结点

有没有发现dp[1]的计算过程跟那个for循环里面的过程完全一样啊，

我们完全可以通过设置一个虚拟结点dp[0]，并设置为1，然后在dp[1]开始存储有效的数据即可，就把这个过程放到那个for循环里面

cpp 复制代码

class Solution {
public:
    int numDecodings(string s) {
        //优化
        int n = s.size();
        vector<int> dp(n + 1);
        dp[0] = 1; //保证后续填表是正确的
        dp[1] = s[0] != '0';
        //填表
        for (int i = 2; i <= n; i++) {
            //处理单独编码
            if (s[i - 1] != '0')
                dp[i] += dp[i - 1];
            //如果和前⾯的⼀个数联合起来编码
            int t = (s[i - 2] - '0') * 10 + s[i - 1] - '0';
            if (t >= 10 && t <= 26)
                dp[i] += dp[i - 2];
        }
        return dp[n];
    }
};

2.路径问题

题目一------62. 不同路径 - 力扣（LeetCode）

大家特别注意这个只能往下走和只能往右走

1. 状态表⽰：

对于这种「路径类」的问题，我们的状态表⽰⼀般有两种形式：

从 [i, j] 位置出发，巴拉巴拉；
从起始位置出发，到达 [i, j] 位置，巴拉巴拉。

这⾥选择第⼆种定义状态表⽰的⽅式：

dp[i][j] 表⽰：从起始位置出发， ⾛到 [i, j] 位置处，⼀共有多少种⽅式。

2. 状态转移⽅程：

大家特别注意这个只能往下走和只能往右走

简单分析⼀下。如果 dp[i][j] 表⽰到达 [i, j] 位置的⽅法数，那么到达 [i, j] 位置的前的⼀⼩步，有两种情况：

从 [i, j] 位置的上⽅（ [i - 1, j] 的位置）向下⾛⼀步，转移到 [i, j] 位置；
从 [i, j] 位置的左⽅（ [i, j - 1] 的位置）向右⾛⼀步，转移到 [i, j] 位置

由于我们要求的是有多少种⽅法，因此状态转移⽅程就呼之欲出了： dp[i][j] =dp[i-1][j] + dp[i][j - 1] 。

初始化： [i, j] 位置。

dp[i][j] =dp[i-1][j] + dp[i][j - 1] 这个方程是有越界风险的，第一行和第一列都会越界。所以我们需要处理这个越界情况。

那我们可以直接多开一列，多开一行，这样子就不会有越界的情况发生了。同时我们还要将dp[0][1] 设置为1.

现在灰色格子里面的都可以使用状态转移方程来解决啦！！

当然，下面这种情况也是可以的

填表顺序：

根据「状态转移⽅程」的推导来看，填表的顺序就是「从上往下」填每⼀⾏，在填写每⼀⾏的时候「从左往右」。

返回值：

根据「状态表⽰」，我们要返回 dp[m][n] 的值。

我们很快就能写出下面的代码

cpp 复制代码

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

题目二------63. 不同路径 II - 力扣（LeetCode）

机器人每次只能向下或者向右移动一步。

1.状态表示

本题为不同路径的变型，只不过有些地⽅有「障碍物」，只要在「状态转移」上稍加修改就可解决。

对于这种「路径类」的问题，我们的状态表⽰⼀般有两种形式：

从 [i, j] 位置出发，巴拉巴拉；
从起始位置出发，到达 [i, j] 位置，巴拉巴拉。

这⾥选择第⼆种定义状态表⽰的⽅式：

dp[i][j] 表⽰：从起始位置出发，⾛到 [i, j] 位置处，⼀共有多少种⽅式。

2. 状态转移：

简单分析⼀下。

如果 dp[i][j] 表⽰到达 [i, j] 位置的⽅法数，那么到达 [i, j] 位置的前的⼀⼩步，有两种情况：

i. 从[i, j] 位置的上⽅（ [i - 1, j] 的位置）向下⾛⼀步，转移到 [i, j] 位置；
ii. 从 [i, j] 位置的左⽅（ [i, j - 1] 的位置）向右⾛⼀步，转移到 [i, j] 位置。

但是， [i - 1, j] 与 [i, j - 1] 位置都是可能有障碍的，此时从上⾯或者左边是不可能到达[ i, j] 位置的，也就是说，此时的⽅法数应该是0。

由此我们可以得出⼀个结论，只要这个位置上「有障碍物」，那么我们就不需要计算这个位置上的值，直接让它等于 0 即可。

我们的状态转移方程就是

grid[i][j]!=1： dp[i][j] =dp[i-1][j] + dp[i][j - 1]
grid[i][j]==1：dp[i][j]=0;

3. 初始化：

dp[i][j] =dp[i-1][j] + dp[i][j - 1] 这个方程是有越界风险的，第一行和第一列都会越界。所以我们需要处理这个越界情况。

那我们可以直接多开一列，多开一行，这样子就不会有越界的情况发生了。同时我们还要将dp[0][1] 设置为1.

现在灰色格子里面的都可以使用状态转移方程来解决啦！！

当然，下面这种情况也是可以的

4. 填表顺序：

根据「状态转移」的推导，填表的顺序就是「从上往下」填每⼀⾏，每⼀⾏「从左往右」。

5. 返回值：

根据「状态表⽰」，我们要返回的结果是 dp[m][n] 。

我们很快就能写出代码

cpp 复制代码

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,0));
        dp[0][1]=1;
        for(int i=1;i<=m;i++)
        {
            for(int j=1;j<=n;j++)
            {
                if(obstacleGrid[i-1][j-1]!=1)
                {
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
                }
                else
                {
                    dp[i][j]=0;
                }
            }
        }
        return dp[m][n];
    }
};

题目三------LCR 166. 珠宝的最高价值 - 力扣（LeetCode）

这题和上面两题都很类似啊

每次可以移动到右侧或下侧的相邻位置

1. 状态表⽰：

对于这种「路径类」的问题，我们的状态表⽰⼀般有两种形式：

i. 从 [i, j] 位置出发，巴拉巴拉；
ii. 从起始位置出发，到达 [i, j] 位置，巴拉巴拉。

这⾥选择第⼆种定义状态表⽰的⽅式：

dp[i][j] 表⽰：从起始位置出发，⾛到 [i, j] 位置处，此时的最⼤价值。

2. 状态转移⽅程：

对于 dp[i][j] ，我们发现想要到达 [i, j] 位置，有两种⽅式：

从[i, j] 位置的上⽅ [i - 1, j] 位置，向下⾛⼀步，此时到达[i, j]位置能拿到的礼物价值为 dp[i - 1][j] + grid[i][j] ；
从 [i, j] 位置的左边 [i, j] 位置，向右⾛⼀步，此时到达[i, j]位置能拿到的礼物价值为 dp[i][j - 1] + grid[i][j]

我们要的是最⼤值，因此状态转移⽅程为： dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]。

3. 初始化：

dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) + grid[i][j] 有越界的风险啊啊

第一行和第一列都会越界。所以我们需要处理这个越界情况。

那我们可以直接多开一列，多开一行，这样子就不会有越界的情况发生了。同时我们还要将所有元素设置为0.

现在灰色格子里面的都可以使用状态转移方程来解决啦！！

不过注意一下：现在状态转移方程变成了dp[i][j]=max(dp[i-1][j],dp[i][j-1])+frame[i-1][j-1]

4. 填表顺序：

根据「状态转移⽅程」，填表的顺序是「从上往下填写每⼀⾏」，「每⼀⾏从左往右」。

5. 返回值：

根据「状态表⽰」，我们应该返回 dp[m][n] 的值。

cpp 复制代码

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,0));
        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];
    }
};

题目四------931. 下降路径最小和 - 力扣（LeetCode）

关于这⼀类题，由于我们做过类似的，因此「状态表⽰」以及「状态转移」是⽐较容易分析出来的。⽐较难的地⽅可能就是对于「边界条件」的处理。

1. 状态表⽰：

对于这种「路径类」的问题，我们的状态表⽰⼀般有两种形式：

从 [i, j] 位置出发，到达⽬标位置有多少种⽅式；
从起始位置出发，到达 [i, j] 位置，⼀共有多少种⽅式

这⾥选择第⼆种定义状态表⽰的⽅式：

dp[i][j] 表⽰：从起始位置出发，到达 [i, j] 位置时，所有下降路径中的最⼩和。

2. 状态转移⽅程：

对于普遍位置 [i, j] ，根据题意得，到达 i. 从正上⽅ [i, j] 位置可能有三种情况：

从正上方[i - 1, j] 位置转移到 [i, j] 位置；
从左上⽅ [i - 1, j - 1] 位置转移到[i, j] 位置；
从右上⽅ [i - 1, j + 1] 位置转移到 [i, j] 位置；

我们要的是三种情况下的「最⼩值」，然后再加上矩阵在 [i, j] 位置的值。

于是 dp[i][j] = min(dp[i - 1][j], min(dp[i - 1][j - 1], dp[i - 1][j + 1])) + matrix[i][j] 。

3.初始化

dp[i][j] = min(dp[i - 1][j], min(dp[i - 1][j - 1], dp[i - 1][j + 1])) + matrix[i][j] 这个有越界情况啊。

上面，左边和右边都会越界。所以我们需要处理这个越界情况。

那我们可以直接多开两列，多开一行，这样子就不会有越界的情况发生了。同时我们还要将所有元素设置为0.

现在灰色格子里面的都可以使用状态转移方程来解决啦！！

4. 填表顺序：

根据「状态表⽰」，填表的顺序是**「从上往下」**。

5. 返回值：

注意这⾥不是返回 dp[m][n] 的值！题⽬要求「只要到达最后⼀⾏」就⾏了，因此这⾥应该返回「dp表中最后⼀⾏的最⼩值」。

我们很快就能写出答案

cpp 复制代码

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

        //寻找最后一行的最小值
        int ret=INT_MAX;
        for(int i=1;i<=n;i++)
        {
            ret=min(ret,dp[m][i]);
        }
        return ret;
    }
};

题目五------64. 最小路径和 - 力扣（LeetCode）

像这种表格形式的动态规划，是⾮常容易得到「状态表⽰」以及「状态转移⽅程」的，可以归结到「不同路径」⼀类的题⾥⾯。

1. 状态表⽰：

对于这种路径类的问题，我们的状态表⽰⼀般有两种形式：

i. 从 [i, j] 位置出发，巴拉巴拉；
ii. 从起始位置出发，到达 [i, j] 位置，巴拉巴拉。

这⾥选择第⼆种定义状态表⽰的⽅式：

dp[i][j] 表⽰：从起始位置出发，到达 [i, j] 位置处，最⼩路径和是多少。

2. 状态转移：

简单分析⼀下。如果 dp[i][j] 表⽰到达 [i, j] 位置处的最⼩路径和，那么到达 [i, j] 位置之前的⼀⼩步，有两种情况：

i. 从 [i - 1, j] 向下⾛⼀步，转移到 [i, j] 位置；
ii. 从 [i, j - 1] 向右⾛⼀步，转移到 [i, j] 位置。

由于到 [i, j] 位置两种情况，并且我们要找的是最⼩路径，因此只需要这两种情况下的最⼩值，再加上 [i, j] 位置上本⾝的值即可。

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

3.初始化

**dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j]**有越界的风险，所以我们需要做一些处理工作

那我们可以直接多开一列，多开一行，这样子就不会有越界的情况发生了。同时我们还要将所有元素设置为0.

在本题中，「添加⼀⾏」，并且「添加⼀列」后，所有位置的值可以初始化为⽆穷⼤，然后让 dp[0][1] = dp[1][0] = 0 即可。

4.填表顺序：

根据「状态转移⽅程」的推导来看，填表的顺序就是「从上往下」填每⼀⾏，每⼀⾏「从左往后」。

5.返回值：

根据「状态表⽰」，我们要返回的结果是dp[m][n] 。

很快就能写出代码

cpp 复制代码

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
        // 1.创建 dp 表
        // 2.初始化
        // 3.填表
        // 4.返回结果

        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];
    }
};

题目六------174. 地下城游戏 - 力扣（LeetCode）

我们可以是自己来演示一下示例一

我们分别使用初始血量为3，6，7来模拟，发现7刚刚好。

1.状态表⽰：

对于这种路径类的问题，我们的状态表⽰⼀般有两种形式：

i. 从 [i, j] 位置出发，巴拉巴拉；
ii. 从起始位置出发，到达 [i, j] 位置，巴拉巴拉。

但是我们发现第二种方法不行了！！

这道题如果我们定义成：从起点开始，到达 [i, j] 位置的时候，所需的最低初始健康点数。

那么我们分析状态转移的时候会有⼀个问题：那就是我们当前的健康点数不仅受到前面路径的影响，还会受到后⾯的路径的影响。也就是从上往下的状态转移不能很好地解决问题。

这个时候我们要换第一种状态表⽰：

从 [i, j] 位置出发，到达终点时所需要的最低初始健康点数。

这样我们在分析状态转移的时候，后续的最佳状态就已经知晓。综上所述，定义状态表⽰为：

dp[i][j] 表⽰：从 [i, j] 位置出发，到达终点时所需的最低初始健康点数。

这题可是我们第一次使用第一种方式来处理这种问题的

2.状态转移方程

对于 dp[i][j] ，从 [i, j] 位置出发，下⼀步会有两种选择：

⾛到右边，然后⾛向终点:
- 很容易知道我们从 [i, j] 位置出发，到达终点时所需的最低初始健康点数（即dp[i][j]） 加上这⼀个位置的消耗（即dungeon[i][j]），应该大于等于从 [i, j+1] 位置出发，到达终点时所需的最低初始健康点数（即dp[i][j+1]）
- 即：dp[i][j] + dungeon[i][j] >= dp[i][j + 1]
- 通过移项可得：dp[i][j] >= dp[i][j + 1] - dungeon[i][j]
- 因为我们需要最小值，所以 dp[i][j] = dp[i][j + 1] - dungeon[i][j]
走到下边 ：
- 很容易知道我们从 [i, j] 位置出发，到达终点时所需的最低初始健康点数（即dp[i][j]） 加上这⼀个位置的消耗（即dungeon[i][j]），应该大于等于从 [i+, j] 位置出发，到达终点时所需的最低初始健康点数（即dp[i+1][j]）
- 即：dp[i][j] + dungeon[i][j] >= dp[i + 1][j]
- 通过移项可得：dp[i][j] >= dp[i + 1][j] - dungeon[i][j]
- 因为我们需要最小值，所以 dp[i][j] = dp[i + 1][j] - dungeon[i][j]

综上所述，我们需要的是两种情况下的最⼩值，因此可得状态转移⽅程为：

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

但是，如果当前位置的 dungeon[i][j] 是⼀个⽐较⼤的正数的话， dp[i][j] 的值可能变成 0 或者负数。也就是最低点数会⼩于 1 ，那么骑⼠就会死亡。

因此我们求出来的dp[i][j] 如果⼩于等于 0 的话，说明此时的最低初始值应该为 1 。

处理这种情况仅需让 1 取⼀个最⼤值即可：dp[i][j] = max(1, dp[i][j])

3.初始化

在 dp 表最后添加一行和一列，并初始化为无穷大。
让 dp[m][n-1] = dp[m-1][n] = 1，因为从右下角出发到终点只需要1点健康值。

4.填表顺序

从下往上填每一行，每一行从右往左。

5.返回值

返回 dp[0][0] 的值，即到达起点所需的最低初始健康点数。

我们很快就能写出下面这个代码

cpp 复制代码

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];
    }
};