FB Tag Hard
最基本的方法是开一个2d dp array, dp[i][j]这里表示的是当第i个房子是j color时所需要的最小花费，所以我们最后要得到的是k个dp[n – 1][k]中的最小值.
初始状态：house 0涂任何颜色所需要的最小话费就是color[0][j], 之后的house我们先将每种color的最小花费初始化为Integer.MAX_VALUE再更新。为了简化代码这个可以写在一起写成一个3层for loop. 我们在house i的每一种color下遍历color s = 0 – k来代表第i-1 house的color, 如果两次color相同就跳过；否则就用i-1 house所花的mincost 加上house i所选这个color需要的钱来更新dp[i][j], 以这个方法来找到目前最小花费。
时间复杂度：O(nkk)
空间复杂度：O(n*k)

class Solution {
    public int minCostII(int[][] costs) {
        if (costs == null || costs.length == 0){
            return 0;
        }
        int n = costs.length;
        int k = costs[0].length;
        //dp[i][j]: the minimum total cost when i-th house painted color j
        int[][] dp = new int[n][k];
        for (int i = 0; i < k; i++){
            dp[0][i] = costs[0][i];
        }
        for (int i = 1; i < n; i++){
            for (int j = 0; j < k; j++){
                dp[i][j] = Integer.MAX_VALUE;
                for (int s = 0; s < k; s++){
                    if (j == s){
                        continue;
                    }
                    dp[i][j] = Math.min(dp[i][j], dp[i-1][s] + costs[i][j]);
                }
            }
        }
        int res = Integer.MAX_VALUE;
        for (int i = 0; i < k; i++){
            res = Math.min(res, dp[n-1][i]);
        }
        return res;
    }
}

优化到空间O(1) 时间O(N*k)的思路还是比较巧妙的,保持两个变量min1, min2代表最小和第二小的当前cost. 都初始化为Integer.MAX_VALUE. 用min1Index来更新上一部达到min cost所选的color index. 初始化的时候，对于house 0直接用cost[0][k]各自比较去更新min1, min2. 从house1 到house n-1, 我们每次先用两个变量temp1, temp2记录下上一次所求得的min1, min2, 用tempIndex记录上一次确定的min1Index. 同时注意到这里要再次更新min1, min2到Integer.MAX_VALUE, 因为每一间房子我们都会尝试每种color来步步更新，所以第一步具体是多少我们也不知道，所以从最大的初始值开始更新。 然后每种 color来刷当前的房子，我们有两种方法去选择使得总花费最小：

• 选择上一轮的最小值 + 现在这种color
• 上一轮达到最小值选择的color就是当前color，因为不能连着选两个相同color，这一次我们选择上一轮的第二小的总花费 + 现在这种color

这样我们就得到house i的最小花费，我们更新min1, min2.
最后的答案直接就是当前（总）最小花费min1.

class Solution {
    public int minCostII(int[][] costs) {
        if (costs == null || costs.length == 0){
            return 0;
        }
        int n = costs.length;
        int k = costs[0].length;
        int min1 = Integer.MAX_VALUE;
        int min2 = Integer.MAX_VALUE;
        int min1Index = -1;
        for (int i = 0; i < k; i++){
            if (costs[0][i] < min1){
                min2 = min1;
                min1 = costs[0][i];
                min1Index = i;
            } else if (costs[0][i] < min2){
                min2 = costs[0][i];
            }
        }
        for (int i = 1; i < n; i++){
            int temp1 = min1;
            int temp2 = min2;
            int tempIndex = min1Index;
            min1 = Integer.MAX_VALUE;
            min2 = Integer.MAX_VALUE;
            for (int j = 0; j < k; j++){
                int minCost = 0;
                if (j != tempIndex){
                    minCost = temp1 + costs[i][j];
                } else {
                    minCost = temp2 + costs[i][j];
                }
                if (minCost < min1){
                    min2 = min1;
                    min1 = minCost;
                    min1Index = j;
                } else if (minCost < min2){
                    min2 = minCost;
                }
            }
        }
        return min1;
    }
}