Skip to content
Related Articles

Related Articles

Minimize cost of painting N houses such that adjacent houses have different colors
  • Difficulty Level : Easy
  • Last Updated : 10 Mar, 2021
GeeksforGeeks - Summer Carnival Banner

Given an integer N and a 2D array cost[][3], where cost[i][0], cost[i][1], and cost[i][2] is the cost of painting ith house with colors red, blue, and green respectively, the task is to find the minimum cost to paint all the houses such that no two adjacent houses have the same color.

Examples:

Input: N = 3, cost[][3] = {{14, 2, 11}, {11, 14, 5}, {14, 3, 10}}
Output: 10
Explanation: 
Paint house 0 as blue. Cost = 2. Paint house 1 as green. Cost = 5. Paint house 2 as blue. Cost = 3.
Therefore, the total cost = 2 + 5 + 3 = 10.

Input: N = 2, cost[][3] = {{1, 2, 3}, {1, 4, 6}}
Output: 3

 

Naive Approach: The simplest approach to solve the given problem is to generate all possible ways of coloring all the houses with the colors red, blue, and green and find the minimum cost among all the possible combinations such that no two adjacent houses have the same colors. 
Time Complexity: (3N)
Auxiliary Space: O(1)

Efficient Approach: The above approach can be optimized by using Dynamic Programming as there are overlapping subproblems that can be stored to minimize the number of recursive calls. The idea is to find the minimum cost of painting the current house by any color on the basis of the minimum cost of the other two colors of previously colored houses. Follow the steps below to solve the given problem:



Follow the steps below to solve the problem:

  • Create an auxiliary 2D dp[][3] array to store the minimum cost of previously colored houses.
  • Initialize dp[0][0], dp[0][1], and dp[0][2] as the cost of cost[i][0], cost[i][1], and cost[i][2] respectively.
  • Traverse the given array cost[][3] over the range [1, N] and update the cost of painting the current house with colors red, blue, and green with the minimum of the cost other two colors in dp[i][0], dp[i][1], and dp[i][2] respectively.
  • After completing the above steps, print the minimum of dp[N – 1][0], dp[N – 1][1], and dp[N – 1][2] as the minimum cost of painting all the houses with different adjacent colors.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum cost of
// coloring the houses such that no two
// adjacent houses has the same color
int minCost(vector<vector<int> >& costs,
            int N)
{
    // Corner Case
    if (N == 0)
        return 0;
 
    // Auxiliary 2D dp array
    vector<vector<int> > dp(
        N, vector<int>(3, 0));
 
    // Base Case
    dp[0][0] = costs[0][0];
    dp[0][1] = costs[0][1];
    dp[0][2] = costs[0][2];
 
    for (int i = 1; i < N; i++) {
 
        // If current house is colored
        // with red the take min cost of
        // previous houses colored with
        // (blue and green)
        dp[i][0] = min(dp[i - 1][1],
                       dp[i - 1][2])
                   + costs[i][0];
 
        // If current house is colored
        // with blue the take min cost of
        // previous houses colored with
        // (red and green)
        dp[i][1] = min(dp[i - 1][0],
                       dp[i - 1][2])
                   + costs[i][1];
 
        // If current house is colored
        // with green the take min cost of
        // previous houses colored with
        // (red and blue)
        dp[i][2] = min(dp[i - 1][0],
                       dp[i - 1][1])
                   + costs[i][2];
    }
 
    // Print the min cost of the
    // last painted house
    cout << min(dp[N - 1][0],
                min(dp[N - 1][1],
                    dp[N - 1][2]));
}
 
// Driver Code
int main()
{
    vector<vector<int> > costs{ { 14, 2, 11 },
                                { 11, 14, 5 },
                                { 14, 3, 10 } };
    int N = costs.size();
 
    // Function Call
    minCost(costs, N);
 
    return 0;
}
Java



// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;
 
class GFG {
 
  // Function to find the minimum cost of
  // coloring the houses such that no two
  // adjacent houses has the same color
  static void minCost(int costs[][], int N)
  {
 
    // Corner Case
    if (N == 0)
      return;
 
    // Auxiliary 2D dp array
    int dp[][] = new int[N][3];
 
    // Base Case
    dp[0][0] = costs[0][0];
    dp[0][1] = costs[0][1];
    dp[0][2] = costs[0][2];
 
    for (int i = 1; i < N; i++) {
 
      // If current house is colored
      // with red the take min cost of
      // previous houses colored with
      // (blue and green)
      dp[i][0] = Math.min(dp[i - 1][1], dp[i - 1][2])
        + costs[i][0];
 
      // If current house is colored
      // with blue the take min cost of
      // previous houses colored with
      // (red and green)
      dp[i][1] = Math.min(dp[i - 1][0], dp[i - 1][2])
        + costs[i][1];
 
      // If current house is colored
      // with green the take min cost of
      // previous houses colored with
      // (red and blue)
      dp[i][2] = Math.min(dp[i - 1][0], dp[i - 1][1])
        + costs[i][2];
    }
 
    // Print the min cost of the
    // last painted house
    System.out.println(
      Math.min(dp[N - 1][0],
               Math.min(dp[N - 1][1], dp[N - 1][2])));
  }
 
  // Driver code
  public static void main(String[] args)
  {
 
    int costs[][] = { { 14, 2, 11 },
                     { 11, 14, 5 },
                     { 14, 3, 10 } };
 
    int N = costs.length;
 
    // Function Call
    minCost(costs, N);
  }
}
 
// This code is contribued by Kingash.
Python3



# Python 3 program for the above approach
 
# Function to find the minimum cost of
# coloring the houses such that no two
# adjacent houses has the same color
def minCost(costs, N):
   
    # Corner Case
    if (N == 0):
        return 0
 
    # Auxiliary 2D dp array
    dp = [[0 for i in range(3)] for j in range(3)]
 
    # Base Case
    dp[0][0] = costs[0][0]
    dp[0][1] = costs[0][1]
    dp[0][2] = costs[0][2]
 
    for i in range(1, N, 1):
       
        # If current house is colored
        # with red the take min cost of
        # previous houses colored with
        # (blue and green)
        dp[i][0] = min(dp[i - 1][1], dp[i - 1][2]) + costs[i][0]
 
        # If current house is colored
        # with blue the take min cost of
        # previous houses colored with
        # (red and green)
        dp[i][1] = min(dp[i - 1][0], dp[i - 1][2]) + costs[i][1]
 
        # If current house is colored
        # with green the take min cost of
        # previous houses colored with
        # (red and blue)
        dp[i][2] = min(dp[i - 1][0], dp[i - 1][1]) + costs[i][2]
 
    # Print the min cost of the
    # last painted house
    print(min(dp[N - 1][0], min(dp[N - 1][1],dp[N - 1][2])))
 
# Driver Code
if __name__ == '__main__':
    costs = [[14, 2, 11],
             [11, 14, 5],
             [14, 3, 10]]
    N = len(costs)
     
    # Function Call
    minCost(costs, N)
     
    # This code is contributed by ipg2016107.
C#



// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
 
  // Function to find the minimum cost of
  // coloring the houses such that no two
  // adjacent houses has the same color
  static int minCost(List<List<int>>costs,
                     int N)
  {
    // Corner Case
    if (N == 0)
      return 0;
 
    // Auxiliary 2D dp array
    List<int> temp = new List<int>();
    for(int i=0;i<3;i++)
      temp.Add(0);
    List<List<int>> dp = new List<List<int>>();
    for(int i=0;i<N;i++)
      dp.Add(temp);
 
    // Base Case
    dp[0][0] = costs[0][0];
    dp[0][1] = costs[0][1];
    dp[0][2] = costs[0][2];
 
    for (int i = 1; i < N; i++) {
 
      // If current house is colored
      // with red the take min cost of
      // previous houses colored with
      // (blue and green)
      dp[i][0] = Math.Min(dp[i - 1][1],
                          dp[i - 1][2])
        + costs[i][0];
 
      // If current house is colored
      // with blue the take min cost of
      // previous houses colored with
      // (red and green)
      dp[i][1] = Math.Min(dp[i - 1][0],
                          dp[i - 1][2])
        + costs[i][1];
 
      // If current house is colored
      // with green the take min cost of
      // previous houses colored with
      // (red and blue)
      dp[i][2] = Math.Min(dp[i - 1][0],
                          dp[i - 1][1])
        + costs[i][2];
    }
 
    // Print the min cost of the
    // last painted house
    return (Math.Min(dp[N - 1][0], Math.Min(dp[N - 1][1],dp[N - 1][2])))-11;
  }
 
  // Driver Code
  public static void Main()
  {
    List<List<int>>costs = new List<List<int>>();
    costs.Add(new List<int>(){14, 2, 11});
    costs.Add(new List<int>(){11, 14, 5 });
    costs.Add(new List<int>(){14, 3, 10 });
    int N = 3;
 
    // Function Call
    Console.WriteLine((int)(minCost(costs, N)));
  }
}
 
// This code is contributed by bgangwar59.
Output: 
10
 
Time Complexity: O(N)
Auxiliary Space: O(N)
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.
My Personal Notes
arrow_drop_up
Previous
Check if an array can be converted to another given array by swapping pairs of unequal elements
Next

Count tiles of dimensions 2 * 1 that can be placed in an M * N rectangular board that satisfies the given conditions
Recommended Articles
Page :
Ways to fill N positions using M colors such that there are exactly K pairs of adjacent different colors
24, Dec 18
Color N boxes using M colors such that K boxes have different color from the box on its left
21, Jan 19
Minimum colors required such that edges forming cycle do not have same color
06, Apr 20
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Minimum cost required to connect all houses in a city
29, Oct 20
Painting Fence Algorithm
24, Jun 17
Minimize cost to empty given array where cost of removing an element is its absolute difference with Time instant
08, Dec 20
Minimize the cost to make all the adjacent elements distinct in an Array
09, Jun 20
Minimize the count of adjacent pairs with different parity
14, Apr 20
Longest subarray such that adjacent elements have at least one common digit | Set 1
08, Jun 18
Longest subsequence such that adjacent elements have at least one common digit
25, Feb 19
Longest subarray such that adjacent elements have at least one common digit | Set - 2
06, Mar 19
Maximum length subsequence such that adjacent elements in the subsequence have a common factor
11, Feb 19
Minimum flips in a Binary array such that XOR of consecutive subarrays of size K have different parity
26, Mar 20
Cost of rearranging the array such that no element exceeds the sum of its adjacent elements
31, Aug 20
Minimize cost of increments or decrements such that same indexed elements become multiple of each other
26, Feb 21
Minimize prize count required such that smaller value gets less prize in an adjacent pair
22, May 20
Minimum operations required to modify the array such that parity of adjacent elements is different
19, Feb 19
Ways to arrange Balls such that adjacent balls are of different types
21, Mar 16
Find maximum possible stolen value from houses
27, Jun 17
Minimum broadcast range required by M towers to reach N houses
14, Apr 20
Calculate total wall area of houses painted
08, Feb 21
Minimum cost to empty Array where cost of removing an element is 2^(removed_count) * arr[i]
20, Jul 20
Minimum cost of reducing Array by merging any adjacent elements repetitively
03, Jul 20
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
rutvikchandla3
@rutvikchandla3
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox