Bootstrap

动态规划之简单多状态

1. 按摩师(easy)

1.题目链接:按摩师
2.题目描述:一个有名的按摩师会收到源源不断的预约请求,每个预约都可以选择接或不接。在每次预约服务之间要有休息时间,因此她不能接受相邻的预约。给定一个预约请求序列,替按摩师找到最优的预约集合(总预约时间最长),返回总的分钟数。
示例 1:

输入: [1,2,3,1]
输出: 4 解释: 选择 1 号预约和 3 号预约,总时长 = 1 + 3 = 4。

示例 2:

输入: [2,7,9,3,1]
输出: 12 解释: 选择 1 号预约、 3 号预约和 5 号预约,总时长 = 2 + 9 + 1 = 12。

示例 3:

输入: [2,1,4,5,3,1,1,3]
输出: 12 解释: 选择 1 号预约、 3 号预约、 5 号预约和 8 号预约,总时长 = 2 + 4 + 3 + 3 = 12。

3.问题分析:
对于动态规划多状态这类问题,看完题目后,对于某个事物,有明显几个状态;比如这道题的事物就是这个按摩师,这个按摩师可能有工作,休息两种状态,而我们要做的就是将这两种状态表示出来,然后计算不同状态下他所能达到的值。 最后依据题目来求解最大值还是最小值。

  1. 状态表示:先用一个dp[n]进行表示,然后就会发现,对于某一个位置来说,这个位置的客人可能选,可能不选(不选可能就是在休息),那么很明显用一个dp表是不能表示出这两种状态的。所以状态表示可以如下:f[i] 表⽰:选择到 i 位置时, nums[i] 必选,此时的最⻓预约时⻓; g[i] 表⽰:选择到 i 位置时, nums[i] 不选,此时的最⻓预约时⻓。
  2. 状态转移方程:对于f[i]数组来说,选择到 i 位置时, nums[i] 必选,此时的最⻓预约时⻓,所以如果i位置必选,那么i-1就不能再选,刚好g[i] 表示的就是 nums[i] 不选,此时的最⻓预约时,此时f[i]=nums[i] + g[i-1]; g[i]表示i位置不选,那么i-1可以选也可以不选,取这两者最大值,g[i]=max(f[i-1], g[i-1])。 所以状态表示分别为 f[i] = nums[i] + g[i - 1];g[i] = max(f[i - 1], g[i - 1]);
  3. 初始化:对于f[i]来说,i位置表示必选,所以f[0]=nums[0];对于g[i]来说,i位置表示不选,所以g[0]=0
  4. 填表顺序:根据状态转移⽅程得从左往右,两个表⼀起填。
  5. 返回值:根据状态表⽰,应该返回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), g(n);
        //初始化
        f[0] = nums[0];
        for (int i = 1; i < n; ++i)
        {
            f[i] = nums[i] + g[i - 1];
            g[i] = max(f[i - 1], g[i - 1]);
        }
        return max(f[n - 1], g[n - 1]);
    }
};

2. 打家劫舍II (medium)

1.题目链接:打家劫舍II
2.题目描述:你是一个专业的小偷,计划偷窃沿街的房屋,每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ,这意味着第一个房屋和最后一个房屋是紧挨着的。同时,相邻的房屋装有相互连通的防盗系统,如果两间相邻的房屋在同一晚上被小偷闯入,系统会自动报警 。
给定一个代表每个房屋存放金额的非负整数数组,计算你 在不触动警报装置的情况下 ,今晚能够偷窃到的最高金额。

示例 1:

输入:nums = [2,3,2]
输出:3 解释:你不能先偷窃 1 号房屋(金额 = 2),然后偷窃 3 号房屋(金额 = 2),因为他们是相邻的。

示例 2:

输入:nums = [1,2,3,1]
输出:4 解释:你可以先偷窃 1 号房屋(金额 = 1),然后偷窃 3 号房屋(金额 = 3)。偷窃到的最高金额 = 1 + 3 = 4 。

示例 3:

输入:nums = [1,2,3]
输出:3

3.问题分析:
这道题上道题的区别就是将这个nums数组看作是一个环形数组,这样的话就需要考虑临界区,也就是对首尾的状况进行分析;具体有如下几种:如果第一个位置选,那么最后一个位置就不能选,也就是在区间[0,n - 2];如果最后一个位置选,那么第一个位置就不能选,也就是区间[1,n - 1]。 还有没有别的情况?没有了。然后对两个区间[0,n - 2]和[1,n - 1]分别进行一次按摩师的问题,就可以求出最大值。

  1. 状态表示:f[i] 表⽰:选择到 i 位置时, nums[i] 必选,此时偷取利润的最大值; g[i] 表⽰:选择到 i 位置时, nums[i] 不选,此时偷取利润的最大值。
  2. 状态转移方程:如按摩师的分析方式,状态转移方程如下: f[i] = nums[i] + g[i - 1];g[i] = max(f[i - 1], g[i - 1]);
  3. 初始化:对于f[i]来说,i位置表示必选,所以f[0]=nums[0];对于g[i]来说,i位置表示不选,所以g[0]=0
  4. 填表顺序:根据状态转移⽅程得从左往右,两个表⼀起填。
  5. 返回值:根据状态表⽰,应该返回max(f[n - 1], g[n - 1])

代码如下:

class Solution 
{
public:
    int _rob(vector<int>& nums, int left, int right)
    {
        if (left > right)
            return 0;
        int n = nums.size();
        vector<int> f(n), g(n);
        //初始化第一个值
        f[left] = nums[left];
        for (int i = left + 1; i <= right; ++i)
        {
            f[i] = nums[i] + g[i - 1];
            g[i] = max(f[i - 1], g[i - 1]);
        }
        return max(f[right], g[right]);
    }
    int rob(vector<int>& nums) 
    {
        int n = nums.size();
        //判断临界条件
        if (n == 1)
            return nums[0];
        //分别求出两个区间[0,n - 2]和[1,n - 1]的最大值
        return max(_rob(nums, 0, n - 2), _rob(nums, 1, n - 1));
    }
};

3. 删除并获得点数(medium)

1.题目链接:删除并获得点数
2.题目描述:
给你一个整数数组 nums ,你可以对它进行一些操作。
每次操作中,选择任意一个 nums[i] ,删除它并获得 nums[i] 的点数。之后,你必须删除 所有 等于 nums[i] - 1 和 nums[i] + 1 的元素。
开始你拥有 0 个点数。返回你能通过这些操作获得的最大点数。

示例 1:

输入:nums = [3,4,2]
输出:6 解释: 删除 4 获得 4 个点数,因此 3 也被删除。 之后,删除 2 获得 2个点数。总共获得 6 个点数。

示例 2:

输入:nums = [2,2,3,3,3,4]
输出:9 解释: 删除 3 获得 3 个点数,接着要删除两个 2 和 4 。 之后,再次删除3 获得 3 个点数,再次删除 3 获得 3 个点数。 总共获得 9 个点数。

提示:

1 <= nums.length <= 2 * 10^4
1 <= nums[i] <= 10^4

3.问题分析:
这道题就需要很好的理解能力了,大概意思是给你一个数组,然后你可以删除一个元素并获得它的大小(这里就叫做点数),但是你如果删除了某个数,比如5,那么你就不能再删除数组中的3和4(上述加红区域)。看到这会想到什么??是不是就和上述第一题差不多了,i位置必选的话,i-1与i+1位置就不能再选。然后就需要一些操作,将本题变为与上述题一样的解法即可,思路如下:由提示可知道1 <= nums[i] <= 10^4,所以用一个10001大小的数组将数据管理起来,下标对应的就是每个数据,所存的元素表示该下标总共的和(例如4出现3次,那么4的位置所存的数据就为12)。

  1. 状态表示:如上题一样,用f[i]表示i位置删除,所获取的最大点数;g[i]表示i位置不删除,所获取的最大点数
  2. 状态转移方程:如按摩师的分析方式,状态转移方程如下: f[i] = hash[i] + g[i - 1];g[i] = max(f[i - 1], g[i - 1]);
  3. 初始化:对于f[0]位置来说,必选后值为0。
  4. 填表顺序:从左往右,两表一次填写。
  5. 返回值:max(f[N - 1], g[N - 1])。

代码如下:

class Solution 
{
public:
    int deleteAndEarn(vector<int>& nums) 
    {
        const int N = 10001;
        int hash[N] = { 0 };
        for (auto& x : nums)
            hash[x] += x;
        
        vector<int> f(N), g(N);
        for (int i = 1; i < N; ++i)
        {
            f[i] = hash[i] + g[i - 1];
            g[i] = max(f[i - 1], g[i - 1]);
        }
        return max(f[N - 1], g[N - 1]);
    }
};

4. 买卖股票的最佳时机含冷冻期(medium)

1.题目链接:买卖股票的最佳时机含冷冻期
2.题目描述:给定一个整数数组prices,其中第 prices[i] 表示第 i 天的股票价格 。​
设计一个算法计算出最大利润。在满足以下约束条件下,你可以尽可能地完成更多的交易(多次买卖一支股票):

卖出股票后,你无法在第二天买入股票 (即冷冻期为 1 天)。
注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

示例 1:

输入: prices = [1,2,3,0,2]
输出: 3 解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

示例 2:

输入: prices = [1]
输出: 0

提示:

1 <= prices.length <= 5000
0 <= prices[i] <= 1000

3.问题分析:
这类题先分状态,然后对每种状态再进行详细讨论。如本题状态该怎么分?在某一天的交易状态可能为买入、冷冻期,冷冻期之后为可交易状态(可交易状态是需要自行找出的)因为卖出的那一刻和进入冷冻期的利润相同,所以买卖股票问题不需要关心卖出状态(如果考虑卖出状态的话,要记得冷冻期的利润是和当天卖出状态利润相同的)。

  1. 状态表示:由于有「买⼊」「可交易」「冷冻期」三个状态,因此我们可以选择⽤三个数组,其中:dp[0][j] 表⽰:第 i 天结束后,处于「买⼊」状态,此时的最⼤利润;dp[1][j] 表⽰:第 i 天结束后,处于「冷冻期」状态,此时的最⼤利润;dp[2][j] 表⽰:第 i 天结束后,处于「可交易」状态,此时的最⼤利润
  2. 状态转移方程:由下图进行分析:
    在这里插入图片描述

箭头末尾表示昨天,箭头前端表示今天。nothing表示什么也不用做。 由买入状态开始分析:由买入能不能到买入状态?什么也不干就可以,由买入到冷冻期?昨天卖出,今天就到冷冻期 ,由买入到可交易?买入后只能卖出到冷冻期,所以不可行。 冷冻期状态:由冷冻期到冷冻期?不行,由冷冻期到买入,显而易见也不行,由冷冻期到可交易?昨天冷冻期,什么也不干,今天就能到达可交易。可交易状态:由可交易到可交易?昨天可交易状态什么也不干,今天就又是可交易状态,由可交易到买入?昨天可交易,今天当然可以买入,由可交易到冷冻期?不行。
所以状态转移方程如下:dp[0][j] = max(dp[0][j - 1], dp[2][j - 1] - prices[j]); dp[1][j] = dp[0][j - 1] + prices[j]; dp[2][j] = max(dp[2][j - 1], dp[1][j - 1]);

  1. 初始化:三种状态都会⽤到前⼀个位置的值,因此需要初始化每⼀⾏的第⼀个位置:
    dp[0][0] :此时要想处于「买⼊」状态,必须把第⼀天的股票买了,因此 dp[0][0] = -prices[0] ;
    dp[1][0] :啥也不⽤⼲即可,因此 dp[1][0] = 0 ;
    dp[2][0] :⼿上没有股票,买⼀下卖⼀下就处于冷冻期,此时收益为 0 ,因此 dp[2][0] = 0 。
  2. 填表顺序:从上到下,从左往右,三个表⼀起填。
  3. 返回值:买入状态的利润肯定不是最大的,所以返回冷冻期状态或可交易状态的最大值即可。

代码如下:

class Solution 
{
public:
    int maxProfit(vector<int>& prices) 
    {
        int n = prices.size();
        vector<vector<int>> dp(3, vector<int>(n));
        dp[0][0] = -prices[0];
        for (int j = 1; j < n; ++j)
        {
            dp[0][j] = max(dp[0][j - 1], dp[2][j - 1] - prices[j]);
            dp[1][j] = dp[0][j - 1] + prices[j];
            dp[2][j] = max(dp[2][j - 1], dp[1][j - 1]);
        }
        return max(dp[1][n - 1], dp[2][n - 1]);
    }
};

5. 买卖股票的最佳时机III(hard)

1.题目链接:买卖股票的最佳时机III
2.题目描述:给定一个数组,它的第 i 个元素是一支给定的股票在第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔(k笔) 交易。

注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。

示例 1:

输入:prices = [3,3,5,0,0,3,1,4]
输出:6 解释:在第 4 天(股票价格 = 0)的时候买入,在第6天(股票价格 = 3)的时候卖出,这笔交易所能获得利润 = 3-0 = 3 。
随后,在第 7 天(股票价格 = 1)的时候买入,在第 8 天 (股票价格 = 4)的时候卖出,这笔交易所能获得利润 = 4-1 = 3 。

示例 2:

输入:prices = [1,2,3,4,5]
输出:4 解释:在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票,之后再将它们卖出。
因为这样属于同时参与了多笔交易,你必须在再次购买前出售掉之前的股票。

示例 3:

输入:prices = [7,6,4,3,1]
输出:0
解释:在这个情况下, 没有交易完成, 所以最大利润为 0。

示例 4:

输入:prices = [1]
输出:0

提示:

1 <= prices.length <= 10^5
0 <= prices[i] <= 10^5

3.问题分析:
这道题与上道题相比,多需要考虑一个交易次数,所以需要再增加一个维度用来表示交易次数。 对于状态来说,只有买入状态和可交易状态,所以用f,g两个数组来进行表示,第二个维度j表示的就是交易次数。 买入股票,交易次数不增加,只有当卖出股票,才算一次完整的交易,交易次数增加。

  1. 状态表示:f[i][j] 表⽰:第 i 天结束后,完成了 j 次交易,处于「买⼊」状态,此时的最⼤利润; g[i][j] 表⽰:第 i 天结束后,完成了 j 次交易,处于「卖出」状态,此时的最⼤利润。
  2. 状态转移⽅程:
    对于 f[i][j] ,有两种情况到这个状态:
    在 i - 1 天的时候,交易了 j 次,处于「买⼊」状态,第 i 天啥也不⼲即可。此时最⼤利润为: f[i - 1][j] ;在 i - 1 天(也就是昨天)的时候,交易了 j 次,处于「可交易」状态,第 i 天的时候把股票买了。此时的最⼤利润为: g[i - 1][j] - prices[i] 。综上,所求的是「最⼤利润」,因此是两者的最⼤值: f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i]) 。
    对于 g[i][j] ,有两种情况可以到达这个状态:
    在 i - 1 天的时候,交易了 j 次,处于「卖出」状态,第 i 天啥也不⼲即可。此时的最⼤利润为: g[i - 1][j] ;在 i - 1 天的时候,交易了 j - 1 次,处于「买⼊」状态,第 i 天把股票卖了,然后就完成了 j ⽐交易。此时的最⼤利润为: f[i - 1][j - 1] + prices[i] 。但是这个状态不⼀定存在,要先判断⼀下。要求的是最⼤利润,因此状态转移⽅程为:g[i][j] = g[i - 1][j]; if(j >= 1) g[i][j] = max(g[i][j], f[i - 1][j - 1] + prices[i]);
  3. 初始化:
    由于需要⽤到 i = 0 时的状态,因此初始化第⼀⾏即可。
    当处于第 0 天的时候,只能处于「买⼊过⼀次」的状态,此时的收益为 -prices[0] ,因此 f[0][0] = - prices[0] 。
    为了取 max 的时候,⼀些不存在的状态「起不到⼲扰」的作⽤,我们统统将它们初始化为 -INF (⽤ INT_MIN 在计算过程中会有「溢出」的⻛险,这⾥ INF 折半取0x3f3f3f3f ,⾜够⼩即可)溢出情况:当初始化为负无穷时,-prices[0]-oo就会溢出。
  4. 填表顺序:从上往下填每⼀⾏,每⼀⾏从左往右,两个表⼀起填。
  5. 返回值:返回每次交易的最大值。

代码如下:

class Solution {
public:
    const int INF = 0x3f3f3f3f;
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        vector<vector<int>> f(n, vector<int>(3, -INF)), g(n, vector<int>(3, -INF));
        f[0][0] = -prices[0], g[0][0] = 0;
        for (int i = 1; i < n; ++i) 
        {
            for (int j = 0; j < 3; ++j)
            {
                f[i][j] = max(f[i - 1][j], g[i - 1][j] - prices[i]);
                if (j >= 1) //防止越界
                    g[i][j] = max(g[i - 1][j], f[i - 1][j - 1] + prices[i]);
                else 
                    g[i][j] = g[i - 1][j];
            }
        }
        int ret = 0;
        for (int j = 0; j < 3; ++j)
            ret = max(ret, g[n - 1][j]);
        return ret;
   }      
 } ;

对于买卖股票的最佳时机IV问题来说,交易k次,分析方式与上道题基本无异,只需将上述代码中的3改为k即可。

;