一、按摩师
题目描述：
题目分析：
1、状态表示
每个预约都只会有两种选择，即选或不选。因此我们可以用
- dp[i][0] 表示不选择第 i 个预约时，最长的预约时长
- dp[i][1] 表示选择第 i 个预约时，最长的预约时长
2、状态转移方程
对于 dp[i][0] ：
- 如果我们选择了第 i 个预约，那么第 i-1 次预约就一定不会选择，这时我们只需要知道不选第 i-1 次预约时的最长预约时长即可，即 dp[i-1][0] 的值，再加上 num[i] 即可。可得递推公式就为：
dp[i][1]=dp[i-1][0]+nums[i]
对于 dp[i][1] ：
- 如果我们不选择第 i 个预约，那么第 i-1 次预约就可以被选择，当然也可以不选，这时我们只需要知道选或不选第 i-1 次预约时分别的最长预约时长即可，即 dp[i-1][0] 与 dp[i-1][0] 的值，取这两个中的最大值即可。可得递推公式就为：
dp[i][0]=Math.max(dp[i-1][1],dp[i-1][0])
3、初始化
为了避免 i-1 时越界，我们初始化dp表的长度为 n+1，然后从 i=1 开始遍历
要注意下标的映射关系，此时 nums[i-1] 表示nums中第 i 个元素
4、返回值
直接返回 Math.max(dp[n][0],dp[n][1])，因为我们不确定最后一个选不选。
代码实现：
java
class Solution {
public int massage(int[] nums) {
int n=nums.length;
int[][] dp=new int[n+1][2];
for(int i=1;i<=n;i++){
dp[i][0]=Math.max(dp[i-1][1],dp[i-1][0]);
dp[i][1]=dp[i-1][0]+nums[i-1];
}
return Math.max(dp[n][0],dp[n][1]);
}
}
二、打家劫舍 II
题目描述：
题目分析：
其实这就是在上题的基础上做了一些限制。我们可以根据第一号房子是否选择来将问题抽象成两个模型：
- 偷第一号房子：此能就不能去偷第二号房子与第n号房子，就是还能偷 [3，n-1] 区间内的房子
- 不偷第一号房子：此时可以偷最后一个房子，也就是说可以偷 [2，n] 区间内的房子
我们可以将上题中的 "打家劫舍" 模型抽象出来，将求取 [1，n] 范围内的最优选改为设定的 [l，r] 范围内的最优选。只需要修改一下遍历时的边界即可
此时就将该问题抽象成了两个 "打家劫舍" 问题的最优解了。
代码实现：
java
class Solution {
public int rob(int[] nums) {
int n=nums.length;
return Math.max(nums[0]+fun(nums,3,n-1),fun(nums,2,n));
}
public static int fun(int[] nums,int l,int r){
int[][] dp=new int[nums.length+1][2];
for(int i=l;i<=r;i++){
dp[i][0]=Math.max(dp[i-1][0],dp[i-1][1]);
dp[i][1]=dp[i-1][0]+nums[i-1];
}
return Math.max(dp[r][0],dp[r][1]);
}
}
三、删除并获得点数
题目描述：
题目分析：
这题看上去似乎与 "打家劫舍" 毫不相关。但仔细观察我们会发现，当选择值为 num[i] 的数字时， num[i] -1与 num[i] +1就无法被选中了。这与不能连续选择元素的 "打家劫舍" 问题不谋而合
我们可以创建一个hash数组，将 num[i] 的值映射到 hash数组对应的下标。然后再对hash数组进行一次 "打家劫舍" 即可
代码实现：
java
class Solution {
public int deleteAndEarn(int[] nums) {
int[] arr=new int[10001];
for(int num:nums){
arr[num]+=num;
}
int[] f=new int[10001],g=new int[10001];
f[0]=arr[0];
for(int i=1;i<10001;i++){
f[i]=g[i-1]+arr[i];
g[i]=Math.max(f[i-1],g[i-1]);
}
return Math.max(f[10000],g[10000]);
}
}
四、粉刷房子
题目描述：
题目分析：
这个问题其实就是拓展版的 "打家劫舍" 问题。普通的 "打家劫舍" 问题每个状态只有 选与不选 两种，而该题有三种。但其实万变不离其中，仔细分析每种状态也能很好地做出来。
1、状态表示
- 用 r[i] 表示第 i 个位置选择红色时的最小花费
- 用 b[i] 表示第 i 个位置选择篮色时的最小花费
- 用 g[i] 表示第 i 个位置选择绿色时的最小花费
2、状态转移方程
由于每个位置都有三种选择，也就对应了三种状态：
对于 r[i] ：
- 如果第 i 个位置刷上红色，那么第 i-1 个位置上就只能刷 蓝色或绿色。因此我们只需要知道第 i-1 个位置刷上 蓝色或绿色 这两种情况中的最小花费，再加上 i 位置的花费即可。可得状态转移方程就为：
r[i]=Math.min(b[i-1],g[i-1])+costs[i][0]
同理可以得出另外两种状态转移方程为：
b[i]=Math.min(r[i-1],g[i-1])+costs[i][1]
g[i]=Math.min(r[i-1],b[i-1])+costs[i][2]
4、初始化
为了避免 i-1 发生越界访问，我们可以先初始化当 i=0 时每种情况的初始值。而由于是首次选择，因此每组的最小花费就应该为对应的costs本身：
r[0]=costs[0][0]
b[0]=costs[0][1]
g[0]=costs[0][2]
代码实现：
java
class Solution {
public int minCost(int[][] costs) {
int n=costs.length;
int[] r=new int[n],b=new int[n],g=new int[n];
r[0]=costs[0][0];
b[0]=costs[0][1];
g[0]=costs[0][2];
for(int i=1;i<n;i++){
r[i]=Math.min(b[i-1],g[i-1])+costs[i][0];
b[i]=Math.min(r[i-1],g[i-1])+costs[i][1];
g[i]=Math.min(r[i-1],b[i-1])+costs[i][2];
}
return Math.min(r[n-1],Math.min(b[n-1],g[n-1]));
}
}
那么本篇文章就到此为止了，如果觉得这篇文章对你有帮助的话，可以点一下关注和点赞来支持作者哦。如果有什么讲的不对的地方欢迎在评论区指出，希望能够和你们一起进步✊
