265. Paint House II

题目：

There are a row of n houses, each house can be painted with one of the k colors. The cost of painting each house with a certain color is different. You have to paint all the houses such that no two adjacent houses have the same color.

The cost of painting each house with a certain color is represented by a n x k cost matrix. For example,costs[0][0] is the cost of painting house 0 with color 0; costs[1][2] is the cost of painting house 1 with color 2, and so on... Find the minimum cost to paint all houses.

Note:
All costs are positive integers.

Follow up:
Could you solve it in O(nk) runtime?

链接： http://leetcode.com/problems/paint-house-ii/

题解：

是Paint House I的generalized版本。这回颜色不是RGB三种，而是扩展到了K种。正好可以试试在Paint House I中没用上的想法。思路还是使用DP, 这回我们需要维护一个刷当前房子之前所有房子最小的花费min1，以及倒数第二小的花费min2。然后我们再遍历当前房子i所有color的花费，假如这个颜色与之前i-1号房子的颜色相同，我们选择min2，否则选择min1。比较完所有颜色以后我们记录下来当前的curMin1，curMin2以及current color， 更新min1，min2和lastColor，就可以继续计算下一个房子了。

Time Complexity - O(n)， Space Complexity - O(1)

public class Solution {
    public int minCostII(int[][] costs) {
        if(costs == null || costs.length == 0) {
            return 0;
        }
        int min1 = 0, min2 = 0, lastColor = -1;

        for(int i = 0; i < costs.length; i++) {
            int curMin1 = Integer.MAX_VALUE, curMin2 = Integer.MAX_VALUE, curColor = -1;
            for(int j = 0; j < costs[0].length; j++) {          // loop through all colors
                int cost = costs[i][j] + (j == lastColor ? min2 : min1);
                if(cost < curMin1) {
                    curMin2 = curMin1;
                    curColor = j;
                    curMin1 = cost;
                } else if(cost < curMin2) {
                    curMin2 = cost;
                }
            }
            min1 = curMin1;
            min2 = curMin2;
            lastColor = curColor;
        }

        return min1;
    }
}

二刷:

方法跟一刷一样。

主要就是保存一个min，一个secondMin，以及刷上次房子所用的颜色lastColor。  在遍历整个数组的过程中，通过比较不断尝试更新min和secondMin，最后返回结果min.

这里要注意的是，在遍历时，当前颜色等于上次刷房颜色时，我们当前的cost是 cost[j] + secondMinCost，即使用不同的两种颜色。而不同颜色的时候，我们直接使用cost[j] + minCost就可以了。

也就是在数组里找到最小和次小两个元素，以及他们的坐标，然后跟之前保存下来的minCost和secondMinCost以及lastColor进行组合判断。

有些操作还是多余，下次希望可以进一步简化。

Java:

public class Solution {
    public int minCostII(int[][] costs) {
        if (costs == null || costs.length == 0) return 0;
        int minCost = 0, secondMinCost = 0, lastColor = -1;

        for (int[] cost : costs) {
            int curMin = Integer.MAX_VALUE, curSecondMin = Integer.MAX_VALUE, curColor = -1;
            for (int j = 0; j < cost.length; j++) {
                int curCost = cost[j] + (j == lastColor ? secondMinCost : minCost);
                if (curCost < curMin) {
                    curSecondMin = curMin;
                    curMin = curCost;
                    curColor = j;
                } else if (curCost < curSecondMin) {
                    curSecondMin = curCost;
                }
            }
            minCost = curMin;
            secondMinCost = curSecondMin;
            lastColor = curColor;
        }

        return minCost;
    }
}

Reference:

https://leetcode.com/discuss/71995/easiest-o-1-space-java-solution

https://leetcode.com/discuss/52982/c-dp-time-o-nk-space-o-k

https://leetcode.com/discuss/54415/ac-java-solution-without-extra-space

https://leetcode.com/discuss/54290/accepted-simple-java-o-nk-solution

https://leetcode.com/discuss/60625/fast-dp-java-solution-runtime-o-nk-space-o-1

https://leetcode.com/discuss/68971/5-ms-java-solution-with-o-kn

http://www.cnblogs.com/jcliBlogger/p/4729957.html

https://leetcode.com/discuss/52937/1-line-python-solution-update-to-o-nk

https://www.zhihu.com/question/33113457