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; } |
Yes, I did the same thing,
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;
}
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..
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];
}
}
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;
}