leetcode1473. 给房子涂色 III

leetcode1473. 给房子涂色 III

在一个小城市里，有 m 个房子排成一排，你需要给每个房子涂上 n 种颜色之一（颜色编号为 1 到 n ）。有的房子去年夏天已经涂过颜色了，所以这些房子不需要被重新涂色。

我们将连续相同颜色尽可能多的房子称为一个街区。（比方说 houses = [1,2,2,3,3,2,1,1] ，它包含 5 个街区 [{1}, {2,2}, {3,3}, {2}, {1,1}] 。）

给你一个数组 houses ，一个 m * n 的矩阵 cost 和一个整数 target ，其中：

• houses[i]：是第 i 个房子的颜色，0 表示这个房子还没有被涂色。
• cost[i][j]：是将第 i 个房子涂成颜色 j+1 的花费。

请你返回房子涂色方案的最小总花费，使得每个房子都被涂色后，恰好组成 target 个街区。如果没有可用的涂色方案，请返回 -1。

示例 1：

输入：houses = [0,0,0,0,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
输出：9
解释：房子涂色方案为 [1,2,2,1,1]
此方案包含 target = 3 个街区，分别是 [{1}, {2,2}, {1,1}]。
涂色的总花费为 (1 + 1 + 1 + 1 + 5) = 9。

示例 2：

输入：houses = [0,2,1,2,0], cost = [[1,10],[10,1],[10,1],[1,10],[5,1]], m = 5, n = 2, target = 3
输出：11
解释：有的房子已经被涂色了，在此基础上涂色方案为 [2,2,1,2,2]
此方案包含 target = 3 个街区，分别是 [{2,2}, {1}, {2,2}]。
给第一个和最后一个房子涂色的花费为 (10 + 1) = 11。

示例 3：

输入：houses = [0,0,0,0,0], cost = [[1,10],[10,1],[1,10],[10,1],[1,10]], m = 5, n = 2, target = 5
输出：5

示例 4：

输入：houses = [3,1,2,3], cost = [[1,1,1],[1,1,1],[1,1,1],[1,1,1]], m = 4, n = 3, target = 3
输出：-1
解释：房子已经被涂色并组成了 4 个街区，分别是 [{3},{1},{2},{3}] ，无法形成 target = 3 个街区。

提示：

• m == houses.length == cost.length
• n == cost[i].length
• 1 <= m <= 100
• 1 <= n <= 20
• 1 <= target <= m
• 0 <= houses[i] <= n
• 1 <= cost[i] [j] <= 10^4

---

方法：动态规划

思路：

又是一个三维dp数组的问题。我们设dp(i,j,k)表示为，染完前i个房子（i+1个），共j个街区，房子i颜色为k+1(注意此处，颜色从1开始，但是下标从0开始)的最小花费。

这样的话，我们的答案就是dp(m-1,target,color)中最小的。color为0到n-1，表示颜色1-n。

下面我们考虑状态转移方程，我们可以知道，对当前房子涂色之后，有多少个街区，取决于前一个房子的颜色，这也是我们为什么在dp的第三个维度存放颜色。当当前屋子颜色与前面房子一致的时候，街区数不增加，不一致的时候，街区数增加。

因此，我们在求dp(i,j,k)的时候，即涂颜色k+1，需要考虑dp(i-1,j,k)以及dp(i-1,j-1,col),col != k。找到它们的最小值，再加上对这个房屋涂k+1的花费cost[i] [k]，即为dp(i,j,k)。值得注意的是，**如果houses[i] = k，即当前房屋已经涂上k+1颜色了，那么就不需要再加cost了。如果houses[i] = 0，需要加上cost，而如果houses[i]是别的数呢，即已经涂上了别的颜色，按照题意，这种情况不符合，我们需要对这个值dp(i,j,k)赋上一个很大的数，来避免最后成为答案，**我们在下面初始化中讲解。

状态转移方程为：
$$\begin{gathered} dp(i,j,k)=min(dp(i-1,j,k),dp(i-1,j-1,col))+x,col=0,1,2,...,n-1,andcol\ne k,ifhouses[i]=kor0 \\ ifhouses[i]=k,x=0;ifhouses[i]=0,x=cost[i][k] \end{gathered}$$
下面讲解初始化，首先定义dp数组的时候，我们把每个位置都赋予一个很大的值，这里使用10^9，这样在遇到不符合题意的情况，pass即可，且这么大的值，在min操作中，也一定会被过滤掉。

初始化的时候，首先判断houses[0]，如果0房子已经被涂色了，涂色为k+1，则dp(0,1,k) = 0

如果没涂色，那么就遍历所有颜色1-k+1，使得dp(0,1,col) = cost[0] [col]。

初始化结束。

最后的答案还需要判断，如果min(dp[m-1] [target] [:])大于等于109，则说明没有方案，返回-1。**

代码：

class Solution:
    def minCost(self, houses: List[int], cost: List[List[int]], m: int, n: int, target: int) -> int:
        N = 10**9
        #初始化dp数组
        dp = [[[N for _ in range(n)] for _ in range(target+1)] for _ in range(m)]
        if houses[0]:
            dp[0][1][houses[0]-1] = 0
        else:
            for i in range(1,n+1):
                dp[0][1][i-1] = cost[0][i-1]
        #开始填写dp数组
        for i in range(1,m):
            for j in range(1,target+1):
                for k in range(1,n+1):
                    #下面找到最小的
                    temp = 10**9
                    for col in range(1,n+1):
                        if col != k:
                            temp = min(temp,dp[i-1][j-1][col-1])
                    temp = min(temp,dp[i-1][j][k-1])
                    #如果houses[i] = 0/k才有意义，才更新dp
                    if houses[i] == 0:
                        dp[i][j][k-1] = temp + cost[i][k-1]
                    elif houses[i] == k:
                        dp[i][j][k-1] = temp
        #返回答案
        ans = min(dp[m-1][target][:])
        return ans if ans < 10**9 else -1

结果：