目录
//打家劫舍问题的变形~⼩偷变成了按摩师
⼀个有名的按摩师会收到源源不断的预约请求,每个预约都可以选择接或不接。在每次预约服务之间 要有休息时间,因此她不能接受相邻的预约。给定⼀个预约请求序列,替按摩师找到最优的预约集合 (总预约时间最⻓),返回总的分钟数。
算法思路:
对于简单的线性dp ,我们可以⽤「经验+题⽬要求」来定义状态表⽰:
- i. 以某个位置为结尾,巴拉巴拉;
- ii. 以某个位置为起点,巴拉巴拉。
这⾥我们选择⽐较常⽤的⽅式,以某个位置为结尾,结合题⽬要求,定义⼀个状态表⽰:
dp[i] 表⽰:选择到 i 位置时,此时的最⻓预约时⻓。
但是我们这个题在 i 位置的时候,会⾯临「选择」或者「不选择」两种抉择,所依赖的状态需要 细分:
▪ f[i] 表⽰:选择到 i 位置时, nums[i] 必选,此时的最⻓预约时⻓;
▪ g[i] 表⽰:选择到 i 位置时, nums[i] 不选,此时的最⻓预约时⻓。
因为状态表⽰定义了两个,因此我们的状态转移⽅程也要分析两个:
相当于是有 选和不选两种状态
对于f[i] :
▪ 如果nums[i] 必选,那么我们仅需知道i - 1 位置在不选的情况下的最⻓预约时⻓, 然后加上nums[i] 即可,因此f[i] = g[i - 1] + nums[i] 。
对于g[i] :
▪ 如果nums[i] 不选,那么i - 1 位置上选或者不选都可以。因此,我们需要知道i - 1 位置上选或者不选两种情况下的最⻓时⻓,因此g[i] = max(f[i - 1], g[i - 1]) 。
这道题的初始化⽐较简单,因此⽆需加辅助节点,仅需初始化 f[0] = nums[0], g[0] = 0 即可。
根据「状态转移⽅程」得「从左往右,两个表⼀起填」。
应该返回max(f[n - 1], g[n - 1]) 。
- class Solution {
- public:
- int massage(vector<int>& nums) {
- 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(f[i - 1], g[i - 1]);
- }
- return max(g[n - 1], f[n - 1]);
- }
- };
:
你是⼀个专业的⼩偷,计划偷窃沿街的房屋,每间房内都藏有⼀定的现⾦。这个地⽅所有的房屋都围成⼀圈,这意味着第⼀个房屋和最后⼀个房屋是紧挨着的。同时,相邻的房屋装有相互连通的防 盗系统,如果两间相邻的房屋在同⼀晚上被⼩偷闯⼊,系统会⾃动报警。给定⼀个代表每个房屋存放⾦额的⾮负整数数组,计算你在不触动警报装置的情况下,今晚能够偷 窃到的最⾼⾦额。
//理解:就是不能两个房间连着偷,就还是f or g 的问题啦
算法思路: 这⼀个问题是「打家劫舍I」问题的变形。
上⼀个问题是⼀个「单排」的模式,这⼀个问题是⼀个「环形」的模式,也就是⾸尾是相连的。但 是我们可以将「环形」问题转化为「两个单排」问题:
a. 偷第⼀个房屋时的最⼤⾦额x ,此时不能偷最后⼀个房⼦,因此就是偷[0, n - 2] 区间 的房⼦; b. 不偷第⼀个房屋时的最⼤⾦额y ,此时可以偷最后⼀个房⼦,因此就是偷[1, 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;
- // 1. 创建 dp 表
- // 2. 初始化
- // 3. 填表
- // 4. 返回结果
- int n = nums.size();
- vector<int> f(n);
- auto g = f;
- f[left] = nums[left]; // 初始化
- for (int i = left + 1; 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]);
- }
- };
给你⼀个整数数组nums,你可以对它进⾏⼀些操作。每次操作中,选择任意⼀个nums[i],删除它并获得nums[i]的点数。之后,你必须删除所有等 于nums[i]-1 和nums[i]+1的元素。 开始你拥有0个点数。返回你能通过这些操作获得的最⼤点数。
算法思路: 其实这道题依旧是「打家劫舍I」问题的变型。
我们注意到题⽬描述,选择x 数字的时候, x - 1 与x + 1 是不能被选择的。像不像「打家 劫舍」问题中,选择i 位置的⾦额之后,就不能选择i - 1 位置以及i + 1 位置的⾦额呢~
因此,我们可以创建⼀个⼤⼩为10001 (根据题⽬的数据范围)的 hash 数组,将nums 数组中每⼀个元素x ,累加到hash 数组下标为x 的位置处,然后在hash 数组上来⼀次「打 家劫舍」即可。
- class Solution {
- public:
- int deleteAndEarn(vector<int>& nums) {
- const int N = 10001;
- // 1. 预处理
- //把没见过的往见过的上面靠
- int arr[N] = {0};
- for (auto x : nums)
- arr[x] += x;//记录重复数字的和
- // 2. 在 arr 数组上,做⼀次 “打家劫舍” 问题
- // 创建 dp 表
- vector<int> f(N);
- auto g = f;
- // 填表
- for (int i = 1; i < N; i++) {
- f[i] = g[i - 1] + arr[i];
- g[i] = max(f[i - 1], g[i - 1]);
- }
- // 返回结果
- return max(f[N - 1], g[N - 1]);
- }
- };
预处理:把没见过的往见过的上面靠~
假如有一排房子,共 n
个,每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种,你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。
当然,因为市场上不同颜色油漆的价格不同,所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x 3
的正整数矩阵 costs
来表示的。
例如,costs[0][0]
表示第 0 号房子粉刷成红色的成本花费;costs[1][2]
表示第 1 号房子粉刷成绿色的花费,以此类推。
请计算出粉刷完所有房子最少的花费成本。
示例 1:
输入: costs = [[17,2,17],[16,16,5],[14,3,19]] 输出: 10 解释: 将 0 号房子粉刷成蓝色,1 号房子粉刷成绿色,2 号房子粉刷成蓝色。 最少花费: 2 + 5 + 3 = 10。
示例 2:
输入: costs = [[7,6,2]] 输出: 2
- class Solution {
- public:
- int minCost(vector
int >>& costs){ - int minCost(vector
int >> & costs){ - // dp[i][j] 第i个房⼦刷成第j种颜⾊最⼩花费
- int n = costs.size();
- vector
int>> dp(n + 1, vector<int>(3)); - for (int i = 1; i <= n; 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][1], dp[i - 1][0]) + costs[i - 1][2];
- }
- return min(dp[n][0], min(dp[n][1], dp[n][2]));//只能两个一min
- }
- }
- ;
1.情况选择的表示:
两种:f or g
三种:二维数组
2.然后分别写出情况下的dp方程