【动态规划算法】-简单多状态题型（11-18题）
作者：小树苗渴望变成参天大树
作者宣言：认真写好每一篇博客
作者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;
}
};
运行结果：
至此我们的简单多状态题型就讲解完毕了，希望大家有所收获，题目之间都有联系，大家要找出共同的部分，为以后做题打好基础，这才是最关键的，下一篇，我将讲解子数组系列题型，希望大家到时候来支持支持博主
