LeetCode – Paint House II (Java)

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.

Java Solution

public int minCostII(int[][] costs) {
    if(costs==null || costs.length==0)
        return 0;
 
    int preMin=0;
    int preSecond=0;
    int preIndex=-1; 
 
    for(int i=0; i<costs.length; i++){
        int currMin=Integer.MAX_VALUE;
        int currSecond = Integer.MAX_VALUE;
        int currIndex = 0;
 
        for(int j=0; j<costs[0].length; j++){
            if(preIndex==j){
                costs[i][j] += preSecond;
            }else{
                costs[i][j] += preMin;
            }
 
            if(currMin>costs[i][j]){
                currSecond = currMin;
                currMin=costs[i][j];
                currIndex = j;
            } else if(currSecond>costs[i][j] ){
                currSecond = costs[i][j];
            }
        }
 
        preMin=currMin;
        preSecond=currSecond;
        preIndex =currIndex;
    }
 
    int result = Integer.MAX_VALUE;
    for(int j=0; j<costs[0].length; j++){
        if(result>costs[costs.length-1][j]){
            result = costs[costs.length-1][j];
        }
    }
    return result;
}

Category >> Algorithms

If you want someone to read your code, please put the code inside <pre><code> and </code></pre> tags. For example:

<pre><code> 
String foo = "bar";
</code></pre>

Siddhant Kumar

Yes, I did the same thing,
mayur patel

Guys, What about this ?

//Time Complexity is O(n*m)
int findMinCost(int[][] cost) {
if (cost.length == 0 || cost[0].length == 0) {
return 0;
}

int totCost = 0, curColor = Integer.MIN_VALUE, minCost, preindex;
for (int i = 0; i < cost.length; i++) {
minCost = Integer.MAX_VALUE;
preindex = curColor;
for (int j = 0; j cost[i][j]) {
minCost = cost[i][j];
preindex = j;
}
}
}
curColor = preindex;
totCost += minCost;
}
return totCost;
}
Justo Equis

def nkhouseOpt(matr_cop,i,kth): --if i == 0: ----temp = [] ----temp = matr_cop[0][:] ----temp[kth] = 9999 ----return temp --for k in range(len(matr_cop[i])): ----temp1 = [] ----temp1 = nkhouseOpt(matr_cop,i-1,k) ----temp2 = temp1[:] ----temp2[k] = 9999
----if matrix[i][k] != matr_cop[i][k]: ------matr_cop[i][k] = min(matr_cop[i][k] + min(temp2), matr_cop[i][k]) ----else: ------matr_cop[i][k] = matr_cop[i][k] + min(temp2) #print(matrix) --return matr_cop[i]
from copy import deepcopy matrix = [[2,4,5,5,5], [2,5,6,5,7], [2,3,1,2,4], [1,2,1,3,2], [3,5,1,6,7], [4,3,1,2,5], [2,2,4,3,5], [2,5,6,5,7], [2,3,1,2,4], [1,2,1,3,2], [3,5,1,6,7], [4,3,1,2,5], ] y = deepcopy(matrix) tt = nkhouseOpt(y,len(y)-1,0)

For the sample matrix it will take almost 60 seconds, so the best is to turn it into a memoized version.. that it will improve execution time.
The problem with a greedy solution is that not always work.
PS. it was losing indentation so that was my fast solution, sorry about that..
Satish

Not required as we already find minimum from preMin
int result = Integer.MAX_VALUE; for(int j=0; jcosts[costs.length-1][j]){ result = costs[costs.length-1][j]; } }
Omender Sharma

Providing o(n^3) solution here but yea for understanding purpose i think it will be good.

public class Solution {

/**

* @param costs n x k cost matrix

* @return an integer, the minimum cost to paint all houses

*/

public int minCostII(int[][] costs) {

// Write your code here

if(costs==null || costs.length==0)

return 0;

for(int i = 1; i < costs.length; i++){

for(int j = 0; j < costs[i].length; j++){

int value = Integer.MAX_VALUE;

for(int k = 0; k < costs[i].length; k++){

if(k == j){

continue;

}

value = Math.min(value, costs[i-1][k]);

}

costs[i][j] += value;

//System.out.println(costs[i][j]);

}

}

int m = costs.length – 1;

int result = Integer.MAX_VALUE;

for(int h = 0; h < costs[m].length; h++){

result = Math.min(result, costs[m][h]);

}

return result;

}

LeetCode – Paint House II (Java)

Related posts: