256. Paint House

1. 把整个图色看成是一棵树，然后dfs

根节点有三个分叉：r,g,b

第二层(g,b),(r,b),(r,g)

所以就是相当于path sum

    int min = Integer.MAX_VALUE;
    
    public int minCost(int[][] costs) {
        if(costs.length == 0 || costs[0].length == 0) {
            return 0;
        }
        for(int i = 0; i < 3; i++) {
            sum(costs, 0, 0, i);
        }
        return min;
    }
    
    private void sum(int[][] costs, int houseNo, int lastSum, int curColor) {
        if(houseNo == costs.length - 1) {
            min = Math.min(min, lastSum + costs[houseNo][curColor]);
            return;
        }
        List<Integer> list = new ArrayList<Integer>(Arrays.asList(0,1,2));
        list.remove(curColor);
        for(int i: list) {
            sum(costs, houseNo + 1, lastSum + costs[houseNo][curColor], i);
        }
    }

时间复杂度应该是O(2^n)

哈哈然后LTE了

2. 动规

既然递归会超时，那就动规了

    public int minCost(int[][] costs) {
        int len = costs.length;
        if(len == 0 || costs.length == 0) {
            return 0;
        }
        int[][] path = new int[len][3];
        int min = Integer.MIN_VALUE;
        for(int i = 0; i < 3; i++) {
            path[0][i] = costs[0][i];
        }
        for(int i = 1; i < len; i++) {
            path[i][0] = Math.min(path[i-1][1], path[i-1][2]) + costs[i][0];
            path[i][1] = Math.min(path[i-1][0], path[i-1][2]) + costs[i][1];
            path[i][2] = Math.min(path[i-1][0], path[i-1][1]) + costs[i][2];
        }
        return Math.min(path[len-1][0], Math.min(path[len-1][1], path[len-1][2]));
    }

这样只有O(N)了