💖作者：小树苗渴望变成参天大树🎈
🎉作者宣言：认真写好每一篇博客💤
🎊作者gitee:gitee✨
💞作者专栏：C语言,数据结构初阶,Linux,C++ 动态规划算法🎄

如果你喜欢作者的文章，就给作者点点关注吧！

文章目录

前言
第十一题:[面试题 17.16. 按摩师](https://leetcode.cn/problems/the-masseuse-lcci/)
第十二题:[213. 打家劫舍 II](https://leetcode.cn/problems/house-robber-ii/)
第十三题:[740. 删除并获得点数](https://leetcode.cn/problems/delete-and-earn/)
第十四题：[剑指 Offer II 091. 粉刷房子](https://leetcode.cn/problems/JEj789/)
第十五题：[309.最佳买卖股票时机含冷冻期](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-cooldown/)
第十六题：[714. 买卖股票的最佳时机含手续费](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-with-transaction-fee/)
第十七题：[123. 买卖股票的最佳时机 III](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iii/)
第十八题：[188. 买卖股票的最佳时机 IV](https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/)

前言

这篇博主花了好几天讲动态规划中的简单多状态类型的题目，难度也是从低到高，理解方面和之前也有不同，我会以三步给大家讲解，**题目解析，动态规划步骤，代码实现，**来解决问题，简单多状态表明我们我们讲题目进行多状态分析，然后进行简单化，之前都是一种状态，所以相对来说好理解一些，这篇说到的题型你都理解了，就会发现简单多状态就那么回事

第十一题:面试题 17.16. 按摩师

题目解析：

通过题解，我们选出数组中符合规则元素和的最大值就行了。

动态规划的步骤

状态表示：经验+题目要求
以i位置为结尾：
f[i]表示：从起点到达i位置，选择i位置时的最大值
g[i]表示：从起点到达i位置，不选择i位置，而是选择前面一位时的最大值

我们发现此位置不像是之前只有一种状态，这题有两种状态，这就是多状态

状态转移方程：以最近的状态来算此状态。

f[i]=g[i-1]+nums[i];

g[i]=max(f[i-1],g[i-1])

初始化：保证数组不越界，此题不需要创建虚拟节点，初始化非常简单第0个位置选还是不选的问题
选：f[0]=nums[0],不选：g[0]=0;
填表顺序：从左往右，两表同时填写
返回值
就是返回选的值大，还是不选的值大max(f[n-1],g[n-1])

代码实现：

class Solution {
public:
    int massage(vector<int>& nums) {
        //1.创建两个状态的dp表
        
        int n=nums.size();
        if(n==0)return 0;
        vector<int> f(n);//选
        auto g=f;//不选
        f[0]=nums[0];//初始化
        for(int i=1;i<n;i++)
        {
            f[i]=g[i-1]+nums[i];
            g[i]=max(g[i-1],f[i-1]);
        }
        return max(f[n-1],g[n-1]);
    }
};

运行效果：

这题因为有多种状态，所以我们要去分析不同状态对应的情况，经验还是适用的。，我们来看下一题

第十二题:213. 打家劫舍 II

这题目的动态规划的步骤和上面一题的分析几乎一模一样，但是有一点不同的就是首位相连，通道最后一个位置时，要看看第一个位置有没有偷，分类讨论，来看图解分析：

上面的思想就是把环形文图转换为线性问题，因为环形问题就在首位的时候有问题，我们单独分类挑出来，其余的部分就和线性问题一样了，那接下来的问题就是分析随便偷时的最大值

动态规划的步骤

状态表示
经验+题目要求
以i位置为结尾，偷到i位置时是的最大面额，偷到i位置右两种情况，选择偷f[i],选择不偷g[i];
状态转移方程，以最近的状态算此状态，就和上面的按摩师的分析一模一样

f[i]=g[i-1]+nums[i];
g[i]=max(f[i-1],g[i-1])

初始化：保证数组不越界，此题不需要创建虚拟节点，初始化非常简单第0个位置选还是不选的问题
选：f[0]=nums[0],不选：g[0]=0;
填表顺序：从左往右，两表同时填写
返回值
就是返回选的值大，还是不选的值大max(f[n-1],g[n-1])

这题要把随便偷的范围包装成一个函数，来看代码实现：

class Solution {
public:
    int rob(vector<int>& nums) {
        int n=nums.size();
       return max(nums[0]+rob1(nums,2,n-2),rob1(nums,1,n-1)); 
    }

    int rob1(vector<int>&nums,int left,int right)
    {
        if(left>right)
            return 0;

        int n=nums.size();
        //1.创建dp表
        vector<int>f(n);
        vector<int>g(n);
        f[left]=nums[left];//初始化
        for(int i=left;i<=right;i++)
        {
            f[i]=g[i-1]+nums[i];
            g[i]=max(f[i-1],g[i-1]);
        }
        return max(f[right],g[right]);
    }
};

运行结果：

第十三题:740. 删除并获得点数

这个题目按照正常思路是不好做下去的，因为我们任意位置开始选数，把对应的+1和-1位置的值删除，就说明你选择了这个位置，这个数的前一个数和下一个数你都选不了，来看图解：

大家要是看过我的计数排序那篇博客，应该理解我说的什么意思，这个问题就转换成上题中的子问题，相邻的两个位置不能选，选择删除arr[i]位置的值，点数就加上arr[i]，就相当于选择了nums[i]就等于arr[i]中的i,然后再arr中i-1位置和i+1位置的值就不能选，就相当于nums[i]-1和nums[i]+1的值被删除了。

动态规划的步骤

状态表示：经验+题目要求
我们只要对arr数组进行操作就可以了，以i位置为结尾，那么i+1位置我们就不需要考虑了，更方便，到达i位置我们有两种选择，选择删除或者不选择删除，f[i]表示：选择删除。g[i]表示：不选择删除
状态转移方程，和上题的子问题一样，博主就不画图演示了，我们直接用上面的状态转移方程：

f[i]=g[i-1]+nums[i];
g[i]=max(f[i-1],g[i-1])

初始化：保证数组不越界，此题不需要创建虚拟节点，初始化非常简单第0个位置选还是不选的问题
选：f[0]=nums[0],不选：g[0]=0;
填表顺序：从左往右，两表同时填写
返回值：就是返回选的值大，还是不选的值大max(f[n-1],g[n-1])

代码实现：

class Solution {
public:
    int deleteAndEarn(vector<int>& nums) {
        //为了求出nums中最大值max
        int Max=nums[0];
        for(int i=0;i<nums.size();i++)
            Max=max(Max,nums[i]);

        vector<int>arr(Max+1);//开辟最大值+1的空间，最后一个下标才等于最大值max
        for(int i=0;i<nums.size();i++)
            arr[nums[i]]+=nums[i];//统计nums[i]的总合

        //1.创建dp表
        vector<int>f(Max+1);
        vector<int>g(Max+1);
        //2.初始化
        f[0]=arr[0];
        for(int i=1;i<Max+1;i++)
        {
            //3.填表
            f[i]=g[i-1]+arr[i];
            g[i]=max(g[i-1],f[i-1]);
        }
        //4.返回值
        return max(f[Max],g[Max]);
    }
};

运行结果：

这题博主也没有想到这么做，通过讲解之后才理解了这种办法，可以说非常的巧妙。

第十四题：剑指 Offer II 091. 粉刷房子

这题是有三种状态的，题目理解难度不大，让我们一起看看吧

题目解析：

动态规划的步骤

状态表示：经验+题目要求
以i位置为结尾，从第0个房子到i个房子的最小花费，但是到达i房子我有三种选择，选择刷红色，蓝色或者绿色

我们为了和costs数组对应起来。
dp[i][0]表示：涂到第i个房子时涂红色的最小花费
dp[i][1]表示：涂到第i个房子时涂蓝色的最小花费
dp[i][2]表示：涂到第i个房子时涂绿色的最小花费
状态转移方程：以最近位置的状态算此状态

dp[i][0]=min(dp[i-1][1],dp[i-1][2])+costs[i-1][0];
dp[i][1]=min(dp[i-1][0],dp[i-1][2])+costs[i-1][1];
dp[i][2]=min(dp[i-1][0],dp[i-1][1])+costs[i-1][2];

初始化：保证该数组不越界，这题可以使用我们之前说过的创建虚拟节点的方法要注意两个点
（1）虚拟节点的值要保证后面的填表是正确的
（2）下标的映射关系

4. 填表顺序：从上往下，三种状态一起填写
5. 返回值：到最后一层，看看什么颜色的花费最小，所以返回值为：

min(dp[m][0],min(dp[m][1],dp[m][2]));

代码实现：

class Solution {
public:
    int minCost(vector<vector<int>>& costs) {
        int m=costs.size();
        //1.创建dp表
        //2.初始化
        //3.填表顺序
        //4.返回值
        vector<vector<int>> dp(m+1,vector<int>(3));
        for(int i=1;i<=m;i++)
        {
            dp[i][0]=min(dp[i-1][1],dp[i-1][2])+costs[i-1][0];
            dp[i][1]=min(dp[i-1][0],dp[i-1][2])+costs[i-1][1];
            dp[i][2]=min(dp[i-1][0],dp[i-1][1])+costs[i-1][2];
        }
        return min(dp[m][0],min(dp[m][1],dp[m][2]));
    }
};

运行结果：

此题还是非常简单的，大家下来自己尝试去做一下

第十五题：309.最佳买卖股票时机含冷冻期

这题我们需要使用一个方式来分析状态转移方程，这个方法特别适用状态多，不好分析的情况，来看一下这题：

题目解析：

大家对题目应该有所理解了吧
动态规划的步骤

状态表示：经验+题目要求
以i位置为结尾，到第i天的最大利润，我们有三种状态（买入，卖出，冷冻期），所以我们有三种状态表示，使用二维数组的形式存放着三个表
dp[i][0] 表⽰：第i天结束后，处于「买⼊」状态，此时的最⼤利润；
dp[i][1] 表⽰：第i天结束后，处于「卖出」状态，此时的最⼤利润；
dp[i][2] 表⽰：第i天结束后，处于「冷冻期」状态，此时的最⼤利润
状态转移方程
此题的状态非常多，我们用一种新的方法求状态转移方程：

dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] -prices[i])
dp[i][1] = max(dp[i - 1][1], dp[i - 1][2])
dp[i][2] = dp[i - 1][0] + prices[i]

初始化：保证数组不越界
三种状态都会⽤到前⼀个位置的值，因此需要初始化每⼀⾏的第⼀个位置：
dp[0][0] ：此时要想处于「买⼊」状态，必须把第⼀天的股票买了，因此dp[0][0] = -prices[0] ；
dp[0][1] ：啥也不⽤⼲即可，因此dp[0][1] = 0 ；
dp[0][2] ：⼿上没有股票，买⼀下卖⼀下就处于冷冻期，此时收益为0 ，因此 dp[0][2]= 0
填表顺序：根据「状态表⽰」，我们要三个表⼀起填，每⼀个表「从左往右」。
应该返回「卖出状态」下的最⼤值，因此应该返回max(dp[n - 1][1], dp[n - 1][2])

代码实现：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
    // 1. 创建 dp 表
    // 2. 初始化
    // 3. 填表
    // 4. 返回结果
    int n = prices.size();
    vector<vector<int>> dp(n, vector<int>(3));
    dp[0][0] = -prices[0];
    for(int i = 1; i < n; i++)
    {
        dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] - prices[i]);
        dp[i][1] = max(dp[i - 1][1], dp[i - 1][2]);
        dp[i][2] = dp[i - 1][0] + prices[i];
    }
    return max(dp[n - 1][1], dp[n - 1][2]);
    }
};

第十六题：714. 买卖股票的最佳时机含手续费

这题博主感觉比上题好理解，我们来看看这道题吧

题目解析：

动态规划的步骤

状态表示：经验+题目解析
以i位置为结尾，到达第i天的最大利润，第i天有两种状态：

所以我们有两个表：
f[i]表示：到达第i天是买入状态时的最大利润
g[i]表示：到达第i天是卖入状态时的最大利润
状态转移方程：以最近的状态算此状态

f[i]=max(f[i-1],g[i-1]-p[i]);
g[i]=max(g[i-1],f[i-1]+p[i]-fee);

初始化：保证数组不越界
此题涉及到i-1位置，我们把两个半iao的第一个位置填好就行了，根据状态转移方程来看，f[0]=-p[0],g[0]=0;
填表顺序：从左往右，两表同时填
返回值，因为最后一天是买入状态的利润肯定没有卖出状态利润高，手上有张股票卖不出去肯定利润低，返回g[n-1];

代码实现：

class Solution {
public:
    int maxProfit(vector<int>& prices, int fee) {
        int n=prices.size();
        //1.创建dp表
        vector<int>f(n);
        auto g=f;
        //2.初始化
        f[0]=-prices[0];
        //3.填表
        for(int i=1;i<n;i++)
        {
            f[i]=max(f[i-1],g[i-1]-prices[i]);
            g[i]=max(g[i-1],f[i-1]+prices[i]-fee);

        }
        //4.返回值
        return g[n-1];
    }
};

第十七题：123. 买卖股票的最佳时机 III

这道题比较难理解，而且状态特别多，还会介绍几个小技巧，我们就来一起看看这道题吧

题目解析：

动态规划的步骤

状态表示：经验+题目要求
以i位置为结尾，第i天的状态是什么是的最大利润

f[i][j]表示：第i天结束后，完成了j笔交易，此时是买入状态时的最大利润
g[i][j]表示：第i天结束后，完成了j笔交易，此时是卖出状态时的最大利润
状态转移方程：以最近的状态来分析此状态

我们看到上面的分析，我们发现当第i-1天是买入状态，想第i天到卖出状态，就需要卖出股票，完成一次交易，如果i-1前面都没有完成一次交易，那么交易次数就是0，此时j-1就会越界，所以我们需要加一个判断，当j-1<0时，第i-1天只能是卖出状态，第i天也是卖出状态，此时最大利润还是前一天的利润

f[i][j]=max(f[i-1][j],g[i-1][j]-prices[i]);
g[i][j]=g[i-1][j];
if(j-1>=0)
{ g[i][j]=max(g[i-1][j],f[i-1][j-1]+prices[i]);}
这是一个小细节，大家要注意

初始化，保证数组不越界

肯定是完成了0笔交易，按照状态转移方程去写就行了
f[0][0]=-p[0], g[0][0]=0;
填表顺序：从左往右，两表同时填
返回值，再上一题说过，最后一天肯定是卖出状态的时候利润最大，买入状态时手上还有一支股票卖不出去，肯定利润小一些，所以返回值是，卖出状态时完成几次交易的利润最大，也就是g[i][j]表最后一行的最大值。

代码实现：

class Solution {
public:
    const int INF=0x3f3f3f3f;//防止溢出
    int maxProfit(vector<int>& prices) {
         int n=prices.size();

        //1.创建dp表
        vector<vector<int>>f(n,vector<int>(3,-INF));//将所以的位置都初始化为-INF
        auto g=f;
        //2.初始化
        f[0][0]=-prices[0];//第一天交易0次时买入状态的最大值
        g[0][0]=0;//第一天交易0次时卖出状态的最大值

        //3.填表
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<=2;j++)
            {
                f[i][j]=max(f[i-1][j],g[i-1][j]-prices[i]);
                g[i][j]=g[i-1][j];
                if(j-1>=0)
                {
                    g[i][j]=max(g[i-1][j],f[i-1][j-1]+prices[i]);
                }
            }
        }
        //4.返回值：g表最后一行最大值
        int ret=0;
        for(int j=0;j<=2;j++)
        {
            ret=max(ret,g[n-1][j]);
        }
        return ret;
    }
};

运行结果：

最后一题和这题的分析一摸一样，带码几乎就一样，我们来看下一道题

第十八题：188. 买卖股票的最佳时机 IV

我们看到这里有了变化，从2变成了k，其余都和上面的代码一样，直接来看代码：

class Solution {
public:
    const int INF=0x3f3f3f3f;
    int maxProfit(int k, vector<int>& prices) {
        int n=prices.size();
        //1.创建dp表
        vector<vector<int>>f(n,vector<int>(k+1,-INF));
        auto g=f;
        f[0][0]=-prices[0];
        g[0][0]=0;
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<=k;j++)
            {
                f[i][j]=max(f[i-1][j],g[i-1][j]-prices[i]);
                g[i][j]=g[i-1][j];
                if(j-1>=0)
                {
                    g[i][j]=max(g[i-1][j],f[i-1][j-1]+prices[i]);
                }
            }
        }
        int ret=0;
        for(int j=0;j<=k;j++)
        {
            ret=max(ret,g[n-1][j]);
        }
        return ret;
    }
};