粉刷房子IIIJava

文章发布较早，内容可能过时，阅读注意甄别。

# 题目

在一个小城市里，有 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

# 思路

Arrays.fill

# 解法

class Solution {
    
    public int minCost(int[] houses, int[][] cost, int m, int n, int target) {
        int INF = Integer.MAX_VALUE;
        int[][][] f = new int[m][n][target];
        for(int i = 0 ;i<m;i++) houses[i]--;
        for(int i = 0;i<m;i++) for(int j = 0;j<n;j++) Arrays.fill(f[i][j],INF);
        for(int i = 0;i<m;i++){
            for(int j = 0 ;j<n;j++){
                if(houses[i]==-1){
                    for(int k = 0;k<=i&&k<target;k++){
                        if(i==0){
                            f[i][j][k] = cost[i][j];
                            continue;
                        }
                        for(int pj = 0;pj<n;pj++){
                            if(pj==j){
                                f[i][j][k] = Math.min(f[i][j][k],f[i-1][pj][k]);
                            }else {
                                if(k>=1){
                                    f[i][j][k] = Math.min(f[i][j][k],f[i-1][pj][k-1]);
                                }
                            }
                        }
                        if(f[i][j][k]!=INF) f[i][j][k] += cost[i][j];
                    }
                }else{
                    if(houses[i]!=j) continue;
                    for(int k = 0;k<=i&&k<target;k++){
                        if(i==0){
                            f[i][j][k] = 0;
                            continue;
                        }                        
                        for(int pj = 0;pj<n;pj++){
                            if(pj==j){
                                f[i][j][k] = Math.min(f[i][j][k],f[i-1][pj][k]);
                            }else if(k>=1){
                                f[i][j][k] = Math.min(f[i][j][k],f[i-1][pj][k-1]);
                            }
                        }
                    }
                }
            }
        }
        int ans = INF;
        for(int j = 0;j<n;j++) ans = Math.min(ans,f[m-1][j][target-1]);
        return ans==INF?-1:ans;

    } 

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

# 总结

分析出几种情况，然后分别对各个情况实现

#Java