动态规划-简单多状态dp问题 -- 粉刷房子

动态规划-简单多状态dp问题 – 粉刷房子

题目重现

题目链接：粉刷房子 - 力扣

假如有一排房子，共 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

提示:

• costs.length == n
• costs[i].length == 3
• 1 <= n <= 100
• 1 <= costs[i][j] <= 20

读懂题目

由于题中条件声明为每个房屋都可以有三种颜色选择，所以注意状态表示需要将 dp[i] 拆分，使得分别有子dp表对应三种颜色。同时注意相邻房屋的颜色不能相同，即 dp[i] 与 dp[i - 1] 和 dp[i + 1] 的颜色需不同。

算法流程

1.状态表示

由于需要建立三排dp表，所以不妨直接建立n行3列的二维数组，将其数组名设为dp，则

• dp[i] [0]：粉刷到 i 位置时，在当前 i 位置刷上 “红色” ，此时的最小花费；
• dp[i] [1]：粉刷到 i 位置时，在当前 i 位置刷上 “蓝色” ，此时的最小花费；
• dp[i] [2]：粉刷到 i 位置时，在当前 i 位置刷上 “绿色” ，此时的最小花费；

2.状态转移方程

对于 dp[i] [0]：

如果第 i 个位置粉刷红色，那么 i - 1 位置上只能是 “蓝色” 或 “绿色”。因此我们知道粉刷到 i 位置时，对应的总花费为 i - 1 位置的 “蓝色” 或 “绿色” 两者最小花费加上 i 位置的花费即可。

对于 dp[i] [1], dp[i] [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] [1], dp[i - 1] [0]) + costs[i] [2];

3.初始化

由于对于每个 i 位置的推断都需要考虑 i - 1 位置，所以需要自行初始化 i = 0 位置的三个表对应值。根据状态表示含义进行初始化：

对于 i = 0, 1, 2 有 dp[0] [i] = costs[0] [i];

4.填表顺序

从左往右，三表同填

5.返回值

根据状态表示，应该返回最后一个位置粉刷上三种颜色情况下的最小值，因此需要返回：

min(dp[n - 1] [0], min(dp[n - 1] [1], dp[n - 1] [2]))

示例代码

class Solution {
public:
    int minCost(vector<vector<int>>& costs) {
        int n = costs.size();
        vector<vector<int>> dp(n, vector<int>(3, 0));

        for(int i = 0; i < 3; i++)
        {
            dp[0][i] = costs[0][i];
        }

        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][1], dp[i - 1][0]) + costs[i][2];
        }

        return min(dp[n - 1][0], min(dp[n - 1][1], dp[n - 1][2]));
    }
};

提交结果：