剑指 Offer II 091. 粉刷房子——动态规划

题目概述：

题目链接：点我做题

题解：

  本题的难点在于建立出合适的动态规划模型。
  仔细想一想，本题求得是最终的最小费用，给的规则是相邻的两个房子不能涂成一样的颜色，注意到当前房子如果涂成红色，那么前面的房子就必须涂成蓝色或绿色。
  我们对下标为i的房子图不同的颜色，$0i$的房子的涂色方案也要发生变化，
  因此我们可以对下标为i的房子建立一个向量$\overrightarrow{s[i]}=(s_0[i],s_1[i],s_2[i])$
  $s_0[i]$的含义是下标为i的房子涂色成红色时的这0_{i个房子的最小涂色费用和，$s_1[i]$的含义是下标为i的房子涂色涂成蓝色时，这0}i个房子的最小涂色费用和，$s_2[i]$的含义是下标为i的房子涂色涂成绿色时，这0~i个房子的最小涂色费用和.
  由于规则，我们下标为i的房子涂色成了红色时，下标为i-1的房子就只能涂成蓝色或绿色，所以下标为i的房子涂色成红色的最小费用就等于下标为i-1的房子涂色成蓝色或绿色时，下标为0~i-1的房子的费用中的较小者加上下标为i的房子涂色成红色的费用，其它颜色类似，因此有状态转移方程：
$$\begin{gathered} s_0[i]=min(s_1[i-1],s_2[i-1])+costs[i][0] \\ {s}_1[i]=min(s_0[i-1],s_2[i-1])+costs[i][1] \\ {s}_2[i]=min(s_0[i-1],s_1[i-1])+costs[i][2] \end{gathered}$$
  显然第一个房子涂色不受前面房子影响，最后我们的最小值就是下标为n-1的房子的三种涂色方案最小费用中的最小者。
代码：

public:
    int minCost(vector<vector<int>>& costs) 
    {
        //dp[i][0]下标为i的房子要求涂成红色时，i+1个房子涂色所需的最小费用
        //dp[i][1]下标为i的房子要求涂成蓝色时，i+1个房子涂色所需的最小费用
        //dp[i][2]下标为i的房子要求涂成绿色时，i+1个房子涂色所需的最小费用
        //根据题意 第i个房子被涂成红色 那么前面的那个房子就必须涂成绿色或蓝色
        //所以下标为i的房子要求涂成红色，这i+1个房子涂色的总费用等于
        //下标为i的房子涂成红色的费用costs[i][0]加上前面的下标为i-1的房子
        //要求涂成绿色或蓝色(取小)时 下标0~i-1个房子涂色的总成本
        //即min(dp[i - 1][1], dp[i - 1][2])
        //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]
        int size = costs.size();
        vector<vector<int>> dp(size, vector<int>(3));
        dp[0][0] = costs[0][0];
        dp[0][1] = costs[0][1];
        dp[0][2] = costs[0][2];
        for (int i = 1; i < size; ++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];
        }
        return (dp[size - 1][0] > dp[size - 1][1]) ?
        (dp[size - 1][1] > dp[size - 1][2] ? dp[size - 1][2] : dp[size - 1][1]) :
        (dp[size - 1][0] > dp[size - 1][2] ? dp[size - 1][2] : dp[size - 1][0]);
        
    }
};

  注意到状态转移方程中，计算下标为i的状态只和下标为i-1时的状态有关，因此可以进一步优化压缩空间复杂度：

class Solution {
public:
    int minCost(vector<vector<int>>& costs) 
    {
        int prev[3];
        int prevred = prev[0] = costs[0][0];
        int prevblue = prev[1] = costs[0][1];
        int prevgreen = prev[2] = costs[0][2];
        int size = costs.size();
        for (int i = 1; i < size; ++i)
        {
            prevred  = min(prev[1], prev[2]) + costs[i][0];
            prevblue = min(prev[0], prev[2]) + costs[i][1];
            prevgreen = min(prev[0], prev[1]) + costs[i][2];
            //用完了上一轮的状态转化为本轮状态后 再覆盖掉上一轮的状态为本轮的状态
            prev[0] = prevred;
            prev[1] = prevblue;
            prev[2] = prevgreen;
        }
        return (prevred < prevblue) ? ((prevred < prevgreen) ? prevred : prevgreen) :
        ((prevblue < prevgreen) ? prevblue : prevgreen);
    }
};

时间复杂度：$O(n)$
空间复杂度：$O(1)$