（算法）粉刷房⼦————＜动态规划＞

1. 题⽬链接：剑指OfferII091.粉刷房⼦

2. 题⽬描述：

3. 解法（动态规划）：

算法思路：

1. 状态表⽰：

对于线性dp ，我们可以⽤「经验+题⽬要求」来定义状态表⽰：

        i. 以某个位置为结尾，巴拉巴拉；

        ii. 以某个位置为起点，巴拉巴拉。 这⾥我们选择⽐较常⽤的⽅式，以某个位置为结尾，结合题⽬要求，定义⼀个状态表⽰： 但是我们这个题在i 位置的时候，会⾯临「红」「蓝」「绿」三种抉择，所依赖的状态需要细 分：

        ▪ dp[i][0] 表⽰：粉刷到i 位置的时候，最后⼀个位置粉刷上「红⾊」，此时的最⼩花 费；

        ▪ dp[i][1] 表⽰：粉刷到i 位置的时候，最后⼀个位置粉刷上「蓝⾊」，此时的最⼩花 费；

        ▪ dp[i][2] 表⽰：粉刷到i 位置的时候，最后⼀个位置粉刷上「绿⾊」，此时的最⼩花 费。

2. 状态转移⽅程：

因为状态表⽰定义了三个，因此我们的状态转移⽅程也要分析三个： 对于dp[i][0] ：

▪ 如果第i个位置粉刷上「红⾊」，那么i-1位置上可以是「蓝⾊」或者「绿⾊」。因此我们 需要知道粉刷到i-1位置上的时候，粉刷上「蓝⾊」或者「绿⾊」的最⼩花费，然后加上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] 。

3. 初始化：

可以在最前⾯加上⼀个「辅助结点」，帮助我们初始化。

使⽤这种技巧要注意两个点：

        i. 辅助结点⾥⾯的值要「保证后续填表是正确的」；

        ii. 「下标的映射关系」。 在本题中，添加⼀个节点，并且初始化为0即可。

4. 填表顺序

根据「状态转移⽅程」得「从左往右，三个表⼀起填」。

5. 返回值

根据「状态表⽰」，应该返回最后⼀个位置粉刷上三种颜⾊情况下的最⼩值，因此需要返回： min(dp[n][0], min(dp[n][1], dp[n][2])) 。

C++算法代码： 

class Solution 
{
public:
    int minCost(vector<vector<int>>& costs) 
    {
        int n=costs.size();
        //建表
        vector<vector<int>>dp(n,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<n;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 min(dp[n-1][0],min(dp[n-1][1],dp[n-1][2]));
    }
};

Java算法代码：

class Solution
{
	public int minCost(int[][] costs)
	{
		// 1. 创建 dp 表 
		// 2. 初始化 
		// 3. 填表 
		// 4. 返回结果 
		int n = costs.length;
		int[][] dp = new int[n + 1][3];
		for (int i = 1; i <= n; i++)
		{
			dp[i][0] = Math.min(dp[i - 1][1], dp[i - 1][2]) + costs[i - 1][0];
			dp[i][1] = Math.min(dp[i - 1][0], dp[i - 1][2]) + costs[i - 1][1];
			dp[i][2] = Math.min(dp[i - 1][0], dp[i - 1][1]) + costs[i - 1][2];
		}
		return Math.min(dp[n][0], Math.min(dp[n][1], dp[n][2]));
	}
}