leetcode--给房子涂色III

 题目是LeetCode第192场周赛的第四题，链接：1473. 给房子涂色 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 个街区。

 很明显又是一道动态规划的题目，因为我们在染某个房子的时候，如果颜色跟上一个房子的不一样，那街区数就会加1，否则不变，所以在状态数组里面必然是要有颜色这个变量存在的。不妨记dp[i][j][k]为0~i的房子被分成j+1个街区且第i个房子染的颜色为k+1的最小总花费。那么我们在求dp[i][j][k]时就有以下情况：

• 第i个房子已经涂过颜色（houses[i]!=0），那么很明显，所有的dp[i][j][k](k!=houses[i]-1)都是不存在的（可以设置为一个特定值，比如整型的最大值），那么对于dp[i][j][k](k==houses[i]-1)，则根据上一个房子的颜色可以知道到当前房子为止的街区数（相同不增不减，不同加1），遍历上一个房子的颜色，找到最小值即可：dp[i][j][k]=min(dp[i-1][j-1][p!=k],dp[i-1][j][k])
• 第i个房子没涂过颜色（houses[i]==0），我们要做的就是给这个房子涂上所有可能的颜色，然后这个过程中同样需要跟上一个房子的颜色相比决定到当前房子为止的街区数，同样找最小值即可：dp[i][j][k]=min(dp[i-1][j][k]+cost[i][k],dp[i-1][j-1][p!=k]+cost[i][p!=k])

 时间复杂度为$O(m{n}^{2}t)$，空间复杂度为$O(mnt)$。

 JAVA版代码如下：

class Solution {
    public int minCost(int[] houses, int[][] cost, int m, int n, int target) {
        // dp[i][j][k]: 0~i这些房子分成了j+1个区，且第i个房子的颜色为k + 1
        int[][][] dp = new int[m][target][n];
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < target; ++j) {
                Arrays.fill(dp[i][j], Integer.MAX_VALUE);
            }
        }
        if (houses[0] != 0) {
            dp[0][0][houses[0] - 1] = 0;
        }
        else {
            for (int k = 0; k < n; ++k) {
                dp[0][0][k] = cost[0][k];
            }
        }
        for (int i = 1; i < m; ++i) {
            for (int j = 0; j < target; ++j) {
                for (int k = 0; k < n; ++k) {
                    // 当前房子如果已经染过色了，花费不增加
                    if (houses[i] != 0 && houses[i] - 1 != k) {
                        continue;
                    }
                    int c = cost[i][k];
                    int color = k;
                    if (houses[i] != 0) {
                        c = 0;
                        color = houses[i] - 1;
                    }
                    // 遍历上一个房子可能的颜色，颜色相同时当前街区数不变，否则需要+1
                    int min = dp[i - 1][j][color];
                    if (j > 0) {
                        for (int p = 0; p < n; ++p) {
                            if (p == color) {
                                continue;
                            }
                            min = Math.min(min, dp[i - 1][j - 1][p]);
                        }
                    }
                    if (min != Integer.MAX_VALUE) {
                        dp[i][j][k] = Math.min(min + c, dp[i][j][k]);
                    }
                }
            }
        }
        int result = Integer.MAX_VALUE;
        for (int k = 0; k < n; ++k) {
            if (dp[m - 1][target - 1][k] != Integer.MAX_VALUE) {
                result = Math.min(dp[m - 1][target - 1][k], result);
            }
        }
        return result == Integer.MAX_VALUE ? -1 : result;
    }
}

 提交结果如下:

 Python版代码如下：

class Solution:
    def minCost(self, houses: List[int], cost: List[List[int]], m: int, n: int, target: int) -> int:
        MAX_VALUE = 10_000_000
        dp = [[[MAX_VALUE for _ in range(n)] for _ in range(target)] for _ in range(m)]
        if houses[0] == 0:
            for k in range(n):
                dp[0][0][k] = cost[0][k]
        else:
            dp[0][0][houses[0] - 1] = 0
        for i in range(1, m):
            for j in range(target):
                for k in range(n):
                    if houses[i] != 0 and k != houses[i] - 1:
                        continue
                    c = cost[i][k] if houses[i] == 0 else 0
                    color = k if houses[i] == 0 else houses[i] - 1
                    minc = dp[i - 1][j][color]
                    if j > 0:
                        for p in range(n):
                            if p == k:
                                continue
                            minc = min(minc, dp[i - 1][j - 1][p])
                    dp[i][j][k] = min(dp[i][j][k], minc + c)
        result = min(dp[m - 1][target - 1][:])
        return -1 if result == MAX_VALUE else result

 提交结果如下: