---

♥♥♥~~~~~~欢迎光临知星小度博客空间~~~~~~♥♥♥

♥♥♥零星地变得优秀~也能拼凑出星河~♥♥♥

♥♥♥我们一起努力成为更好的自己~♥♥♥

♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥

♥♥♥如果有什么问题可以评论区留言或者私信我哦~♥♥♥

✨✨✨✨✨✨ 个人主页✨✨✨✨✨✨

---

        这一篇博客我们继续来看看动态规划系列里面的简单多状态问题，准备好了吗~我们发车去探索奥秘啦~🚗🚗🚗🚗🚗🚗

目录

粉刷房子

买卖股票的最佳时机（含冷冻期）

---

粉刷房子

粉刷房子

        可以看到题目要求给房子上颜色，并且相邻的房子颜色不能相同~这显然是是一个多状态的问题，接下来我们来一步步分析一下~

分析：

1、状态表示

        题目要求：相邻的房子颜色不能相同，每一个房子有三种颜色可以选择~我们创建三个dp表来进行表示，事实上，题目给出的二维数组，行号就是房子号数，列号是涂某一种颜色的花费，我们也可以用这样一个二维数组来形成我们的dp表~每一个房子都有三种不同的情况~

        结合这里的题目要求+经验：

        dp表中的dp1[i][0]表示为到达该位置并且选择该位置选择涂红色的最小花费~

        dp表中的dp1[i][1]表示为到达该位置并且选择该位置选择涂蓝色的最小花费~

        dp表中的dp1[i][2]表示为到达该位置并且选择该位置选择涂绿色的最小花费~

2、状态转移方程

       我们以离【i】位置最近的状态分析状态转移方程，处理dp表

1、

        dp【i】【0】选择【i】位置涂红色，那么说明前面的位置是一定不可以涂蓝色和绿色的，取两者最小值再加上当前位置涂红色的花费，那么

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

2、

        dp【i】【1】选择【i】位置涂蓝色，那么说明前面的位置是一定不可以涂红色和绿色的，取两者最小值再加上当前位置涂蓝色的花费，那么

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

3、

        dp【i】【2】选择【i】位置涂绿色，那么说明前面的位置是一定不可以涂蓝色和红色的，取两者最小值再加上当前位置涂绿色的花费，那么

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

3、初始化

        我们可以看到，状态转移方程里面有i-1当i=0的时候显然会出现越界的情况，所以我们需要进行初始化

        结合前面如果不想初始化太麻烦，我们可以多申请一些空间，但是事实上这个题目初始化比较简单，直接初始化dp[0][0],dp[0][1],dp[0][2]就可以了，所以我们直接进行初始化~

        dp[0][0]就是选择0位置涂红色花费nums[0][0]， dp[0][1]就是选择0位置涂蓝色花费nums[0][1]， dp[0][2]就是选择0位置涂绿色花费nums[0][2]那么我们初始化结果就是

                dp[0][0]=nums[0][0] , dp[0][1]=nums[0][1] , dp[0][2]=nums[0][2]

4、填表顺序

        我们这里的逻辑是从前面依次推出后面的，所以填表顺序是从前往后

5、返回结果

      这里返回结果是到最后一个房子的最小花费，最后一个房子有三种情况，一种是选择涂红色，一种是选择涂蓝色，还有一种是选择涂绿色，返回三种情况最小值就可以了，即返回min(min(dp[m-1][0],dp[m-1][1]),dp[m-1][2])

注意点：结合题目给出的范围，这里不需要处理边界情况~

代码实现：

class Solution
{
public:
    int minCost(vector<vector<int>>& costs)
    {
        //1、创建dp表
        int m = costs.size();//房子号
        int n = costs[0].size();//颜色
        vector<vector<int>> dp(m, vector<int>(n));
        //2、初始化
        dp[0][0] = costs[0][0];
        dp[0][1] = costs[0][1];
        dp[0][2] = costs[0][2];
        //3、填表
        for (int i = 1; i < m; i++)
        {
            dp[i][0] = min(dp[i - 1][1], dp[i - 1][2]) + costs[i][0];
            dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]) + costs[i][1];
            dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]) + costs[i][2];
        }
        //4、返回结果
        return min(min(dp[m - 1][0], dp[m - 1][1]), dp[m - 1][2]);
    }
};

顺利通过~

我们也可以采用有趣提到的增加虚拟节点的方法，这里相当于多增加一个空房子，有下面两个注意点：

1、虚拟节点值是多少？

        虚拟节点会影响到第一个房子的最小花费，事实上，到第一个房子的最小花费也就是第一个房子的花费，不想让虚拟节点影响，就把虚拟节点值设置为0~

2、注意下标映射关系

        相当于增加了一个房子，注意与原来的数组的下标映射~

代码实现：

class Solution
{
public:
    int minCost(vector<vector<int>>& costs)
    {
        //使用虚拟节点
        //1、创建dp表
        int m = costs.size();
        int n = costs[0].size();//也可以直接写为已知的3
        vector<vector<int>> dp(m + 1, vector<int>(n));
        //2、初始化虚拟节点
        dp[0][0] = 0;
        dp[0][1] = 0;
        dp[0][2] = 0;
        //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];
        }
        //4、返回结果
        return min(min(dp[m][0], dp[m][1]), dp[m][2]);
    }
};

顺利通过~不难发现，代码量其实是差不多的，大家选择自己喜欢的方式就好~

买卖股票的最佳时机（含冷冻期）

买卖股票的最佳时机（含冷冻期）

        这个题目显然是一个多状态问题，那么我们首先得分析它有哪几个状态：

1、买入状态（也就是手上有股票的状态，可以进行卖出）

2、冷冻期状态（不可以进行买入）

3、可以交易的状态（可以进行买入）

接下来画图分析这几个状态之间的关系（也就是讨论状态相互之间是否可达以及是否可以自己到自己）

知道了这三个状态之间的关系，我们就可以利用动态规划的思想进行分析：

1、状态表示

        题目要求：既然有三个状态，那么我们就需要创建三个dp表表示不同位置可能的状态~

        结合这里的题目要求+经验：

        dp1表中的dp1[i]表示为到达该位置进行操作后处于买入状态的最大利润~

        dp2表中的dp2[i]表示为到达该位置进行操作后处于可交易状态的最大利润~

        dp3表中的dp3[i]表示为到达该位置进行操作后处于冷冻期状态的最大利润~

        注意是在该位置进行操作后处于什么状态，而不是到达该位置是什么状态，这样会比较麻烦~

2、状态转移方程

       我们以离【i】位置最近的状态分析状态转移方程，处理dp表

1、

       怎么样会处于买入状态呢？结合前面的画图分析可能是前一天可交易状态下，在今天买入股票变成买入状态；也可能是前一天买入状态下，今天什么都不干依然是买入状态，取两种情况的较大值~

        dp1表状态转移方程：

        dp1[i]=max(dp1[i-1],dp2[i-1]-prices[i]);

2、

        怎么样会处于可交易状态呢？结合前面的画图分析可能是前一天冷冻期状态，今天就是可交易的状态；也可能是前一天可交易状态下，今天什么都不干依然是可交易状态，取两种情况的较大值~

        dp2表状态转移方程：

        dp2[i]=max(dp2[i-1],dp3[i-1]);

3、

       怎么样会处于冷冻期状态呢？结合前面的画图分析可能是前一天处于买入状态，在今天进行卖出也就处于冷冻期状态了~没有其他情况

        dp3表状态转移方程：

        dp3[i]=dp1[i-1]+prices[i];

3、初始化

        我们可以看到，状态转移方程里面有i-1当i=0的时候显然会出现越界的情况，所以我们需要进行初始化

        结合前面如果不想初始化太麻烦，我们可以多申请一些空间，但是事实上这个题目初始化比较简单，直接初始化dp1[0],dp2[0]，dp3[0]就可以了，所以我们直接进行初始化~

        dp1[0]就是第一天操作后处于买入状态，那么利润为-prices[0];

        dp2[0]就是第一天操作后处于可交易状态，那就是什么都不干，那么利润为0;

        dp3[0]就是第一天操作后处于冷冻期状态，这是不可能的，那么利润为0;

        那么我们初始化结果就是

                dp1[0]=-prices[0] , dp2[0]=0 , dp3[0]=0

4、填表顺序

        我们这里的逻辑是从前面依次推出后面的，所以填表顺序是从前往后

5、返回结果

      这里返回结果是到最后一天的最大利润，最后一天有三种情况，返回三种情况最大值就可以了，即返回return max(max(dp1[n-1],dp2[n-1]),dp3[n-1]);

        当然，最后一天是不可能还处于买入状态的，这样就亏了，也就可以返回return max(dp2[n-1],dp3[n-1]);

注意点：结合题目给出的范围，这里不需要处理边界情况~

代码实现：

class Solution 
{
public:
    int maxProfit(vector<int>& prices) 
    {
        //1、创建dp表
        int n=prices.size();
        vector<int> dp1(n);//买入状态
        vector<int> dp2(n);//可以交易状态
        vector<int> dp3(n);//冷冻期状态

        //2、初始化
        dp1[0]=-prices[0];
        dp2[0]=0;
        dp3[0]=0;

        //3、填表
        for(int i=1;i<n;i++)
        {
            dp1[i]=max(dp1[i-1],dp2[i-1]-prices[i]);
            dp2[i]=max(dp2[i-1],dp3[i-1]);
            dp3[i]=dp1[i-1]+prices[i];
        }

        //4、返回结果
        //return max(max(dp1[n-1],dp2[n-1]),dp3[n-1]);
        return max(dp2[n-1],dp3[n-1]);
    }
};

顺利通过~

除了这种创建dp表的方式，我们也可以像前面那样创建二维数组（n*3）来实现三个dp表~

我们重新来进行分析一下：

1、状态表示

        题目要求：既然有三个状态，那么我们就需要创建三个dp表表示不同位置可能的状态~这里创建一个n*3的二维数组来表示~

        结合这里的题目要求+经验：

        dp表中的dp[i][0]表示为到达该位置进行操作后处于买入状态的最大利润~

        dp表中的dp[i][1]表示为到达该位置进行操作后处于可交易状态的最大利润~

        dp表中的dp[i][2]表示为到达该位置进行操作后处于冷冻期状态的最大利润~

2、状态转移方程

       我们以离【i】位置最近的状态分析状态转移方程，处理dp表

1、

       怎么样会处于买入状态呢？结合前面的画图分析可能是前一天可交易状态下，在今天买入股票变成买入状态；也可能是前一天买入状态下，今天什么都不干依然是买入状态，取两种情况的较大值~

        dp表状态转移方程：

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

2、

        怎么样会处于可交易状态呢？结合前面的画图分析可能是前一天冷冻期状态，今天就是可交易的状态；也可能是前一天可交易状态下，今天什么都不干依然是可交易状态，取两种情况的较大值~

        dp表状态转移方程：

        dp[i][1]=max(dp[i-1][1],dp[i-1][2]);

3、

       怎么样会处于冷冻期状态呢？结合前面的画图分析可能是前一天处于买入状态，在今天进行卖出也就处于冷冻期状态了~没有其他情况

        dp表状态转移方程：

        dp[i][2]=dp[i-1][0]+prices[i];

3、初始化

        我们可以看到，状态转移方程里面有i-1当i=0的时候显然会出现越界的情况，所以我们需要进行初始化

        结合前面如果不想初始化太麻烦，我们可以多申请一些空间，但是事实上这个题目初始化比较简单，直接初始化dp[0][0],dp[0][1],dp[0][2]就可以了，所以我们直接进行初始化~

        dp[0][0]就是第一天操作后处于买入状态，那么利润为-prices[0];

        dp[0][1]就是第一天操作后处于可交易状态，那就是什么都不干，那么利润为0;

        dp[0][2]就是第一天操作后处于冷冻期状态，这是不可能的，那么利润为0;

        那么我们初始化结果就是

               

        dp[0][0]=-prices[0];//买入状态

        dp[0][1]=0;//可交易状态

        dp[0][2]=0;//冷冻期状态

4、填表顺序

        我们这里的逻辑是从前面依次推出后面的，所以填表顺序是从前往后

5、返回结果

      这里返回结果是到最后一天的最大利润，最后一天有三种情况，返回三种情况最大值就可以了，即返回return max(max(dp[n-1][0],dp[n-1][1]),dp[n-1][2]);

        当然，最后一天是不可能还处于买入状态的，这样就亏了，也就可以返回return max(dp[n-1][1],dp[n-1][2]);

代码实现：（逻辑都是差不多的，只不过实现上有区别）

class Solution
{
public:
    int maxProfit(vector<int>& prices)
    {
        //1、创建二维数组dp表
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(3, 0));

        //2、初始化
        dp[0][0] = -prices[0];//买入状态
        dp[0][1] = 0;//可交易状态
        dp[0][2] = 0;//冷冻期状态

        //3、填表
        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];
        }

        //4、返回结果
        return max(max(dp[n - 1][0], dp[n - 1][1]), dp[n - 1][2]);
        //return max(dp[n-1][1],dp[n-1][2]);
    }
};

顺利通过~

---

♥♥♥本篇博客内容结束，期待与各位优秀程序员交流，有什么问题请私信♥♥♥

♥♥♥如果这一篇博客对你有帮助~别忘了点赞分享哦~♥♥♥

✨✨✨✨✨✨个人主页✨✨✨✨✨✨

---