Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Ways to fill N positions using M colors such that there are exactly K pairs of adjacent different colors

  • Difficulty Level : Hard
  • Last Updated : 23 May, 2022

Given three integers N, M and K. The task is to find the number of ways to fill N positions using M colors such that there are exactly K pairs of different adjacent colors.

Examples: 

Input: N = 3, M = 2, K = 1 
Output: 4 
Let the colors be 1 and 2, so the ways are: 
1, 1, 2 
1, 2, 2 
2, 2, 1 
2, 1, 1 
The above 4 ways have exactly one pair of adjacent elements with different colors.

Input: N = 3, M = 3, K = 2 
Output: 12 

Approach: We can use Dynamic Programming with memoization to solve the above problem. There are N positions to fill, hence the recursive function will be composed of two calls, one if the next position is filled with the same color and the other if it is filled with a different color. Hence, the recursive calls will be: 

  • countWays(index + 1, cnt), if the next index is filled with the same color.
  • (m – 1) * countWays(index + 1, cnt + 1), if the next index is filled with a different color. The number of ways is multiplied by (m – 1).

The basic cases will be: 

  • If index = n, then a check for the value of cnt is done. If cnt = K then it is a possible way, hence return 1, else return 0.
  • To avoid repetitive calls, memoize the returned value in a 2-D array and return this value if the recursive call with the same parameters is done again.

Below is the implementation of the above approach: 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
#define max 4
 
// Recursive function to find the required number of ways
int countWays(int index, int cnt, int dp[][max], int n, int m, int k)
{
 
    // When all positions are filled
    if (index == n) {
 
        // If adjacent pairs are exactly K
        if (cnt == k)
            return 1;
        else
            return 0;
    }
 
    // If already calculated
    if (dp[index][cnt] != -1)
        return dp[index][cnt];
 
    int ans = 0;
 
    // Next position filled with same color
    ans += countWays(index + 1, cnt, dp, n, m, k);
 
    // Next position filled with different color
    // So there can be m-1 different colors
    ans += (m - 1) * countWays(index + 1, cnt + 1, dp, n, m, k);
 
    return dp[index][cnt] = ans;
}
 
// Driver Code
int main()
{
    int n = 3, m = 3, k = 2;
    int dp[n + 1][max];
    memset(dp, -1, sizeof dp);
 
    cout << m * countWays(1, 0, dp, n, m, k);
}
Java



//Java implementation of the approach
class solution
{
static final int  max=4;
  
// Recursive function to find the required number of ways
static int countWays(int index, int cnt, int dp[][], int n, int m, int k)
{
  
    // When all positions are filled
    if (index == n) {
  
        // If adjacent pairs are exactly K
        if (cnt == k)
            return 1;
        else
            return 0;
    }
  
    // If already calculated
    if (dp[index][cnt] != -1)
        return dp[index][cnt];
  
    int ans = 0;
  
    // Next position filled with same color
    ans += countWays(index + 1, cnt, dp, n, m, k);
  
    // Next position filled with different color
    // So there can be m-1 different colors
    ans += (m - 1) * countWays(index + 1, cnt + 1, dp, n, m, k);
  
    return dp[index][cnt] = ans;
}
  
// Driver Code
public static void main(String args[])
{
    int n = 3, m = 3, k = 2;
    int dp[][]= new int [n + 1][max];
    for(int i=0;i<n+1;i++)
    for(int j=0;j<max;j++)
    dp[i][j]=-1;
  
    System.out.println(m * countWays(1, 0, dp, n, m, k));
}
}
//contributed by Arnab Kundu
Python 3



# Python 3 implementation of the approach
 
max = 4
 
# Recursive function to find the
# required number of ways
def countWays(index, cnt, dp, n, m, k):
 
    # When all positions are filled
    if (index == n) :
 
        # If adjacent pairs are exactly K
        if (cnt == k):
            return 1
        else:
            return 0
 
    # If already calculated
    if (dp[index][cnt] != -1):
        return dp[index][cnt]
 
    ans = 0
 
    # Next position filled with same color
    ans += countWays(index + 1, cnt, dp, n, m, k)
 
    # Next position filled with different color
    # So there can be m-1 different colors
    ans += (m - 1) * countWays(index + 1,
                               cnt + 1, dp, n, m, k)
 
    dp[index][cnt] = ans
    return dp[index][cnt]
 
# Driver Code
if __name__ == "__main__":
     
    n = 3
    m = 3
    k = 2
    dp = [[-1 for x in range(n + 1)]
              for y in range(max)]
 
    print(m * countWays(1, 0, dp, n, m, k))
 
# This code is contributed by ita_c
C#



// C# implementation of the approach
 
using System;
 
class solution
{
static int max=4;
 
// Recursive function to find the required number of ways
static int countWays(int index, int cnt, int [,]dp, int n, int m, int k)
{
 
    // When all positions are filled
    if (index == n) {
 
        // If adjacent pairs are exactly K
        if (cnt == k)
            return 1;
        else
            return 0;
    }
 
    // If already calculated
    if (dp[index,cnt] != -1)
        return dp[index,cnt];
 
    int ans = 0;
 
    // Next position filled with same color
    ans += countWays(index + 1, cnt, dp, n, m, k);
 
    // Next position filled with different color
    // So there can be m-1 different colors
    ans += (m - 1) * countWays(index + 1, cnt + 1, dp, n, m, k);
 
    return dp[index,cnt] = ans;
}
 
// Driver Code
public static void Main()
{
    int n = 3, m = 3, k = 2;
    int [,]dp= new int [n + 1,max];
    for(int i=0;i<n+1;i++)
        for(int j=0;j<max;j++)
            dp[i,j]=-1;
 
    Console.WriteLine(m * countWays(1, 0, dp, n, m, k));
}
// This code is contributed by Ryuga
}
PHP



<?php
// PHP implementation of the approach
 
$GLOBALS['max'] = 4;
 
// Recursive function to find the
// required number of ways
function countWays($index, $cnt, $dp,
                         $n, $m, $k)
{
 
    // When all positions are filled
    if ($index == $n)
    {
 
        // If adjacent pairs are exactly K
        if ($cnt == $k)
            return 1;
        else
            return 0;
    }
 
    // If already calculated
    if ($dp[$index][$cnt] != -1)
        return $dp[$index][$cnt];
 
    $ans = 0;
 
    // Next position filled with same color
    $ans += countWays($index + 1, $cnt,
                      $dp, $n, $m, $k);
 
    // Next position filled with different color
    // So there can be m-1 different colors
    $ans += ($m - 1) * countWays($index + 1, $cnt + 1,
                                 $dp, $n, $m, $k);
 
    $dp[$index][$cnt] = $ans;
     
    return $dp[$index][$cnt];
}
 
// Driver Code
$n = 3;
$m = 3;
$k = 2;
$dp = array(array());
 
for($i = 0; $i < $n + 1; $i++)
    for($j = 0; $j < $GLOBALS['max']; $j++)
        $dp[$i][$j] = -1;
 
echo $m * countWays(1, 0, $dp, $n, $m, $k);
 
// This code is contributed by aishwarya.27
?>
Javascript



<script>
//Javascript implementation of the approach
 
let max=4;
 
// Recursive function to find the required number of ways
function countWays(index,cnt,dp,n,m,k)
{
    // When all positions are filled
    if (index == n) {
    
        // If adjacent pairs are exactly K
        if (cnt == k)
            return 1;
        else
            return 0;
    }
    
    // If already calculated
    if (dp[index][cnt] != -1)
        return dp[index][cnt];
    
    let ans = 0;
    
    // Next position filled with same color
    ans += countWays(index + 1, cnt, dp, n, m, k);
    
    // Next position filled with different color
    // So there can be m-1 different colors
    ans += (m - 1) * countWays(index + 1, cnt + 1, dp, n, m, k);
    
    return dp[index][cnt] = ans;
}
 
// Driver Code
let n = 3, m = 3, k = 2;
let dp=new Array(n+1);
for(let i=0;i<n+1;i++)
{   
    dp[i]=new Array(max);
    for(let j=0;j<max;j++)
        dp[i][j]=-1;
}   
document.write(m * countWays(1, 0, dp, n, m, k));   
     
// This code is contributed by rag2127
</script>
Output: 
12
 
Time Complexity: O(n*4), where N is the number of positions to be filled.
Auxiliary Space: O(n*4), where N is the number of positions to be filled.

My Personal Notes
arrow_drop_up
Previous
Color N boxes using M colors such that K boxes have different color from the box on its left
Next

Ways to arrange Balls such that adjacent balls are of different types
Recommended Articles
Page :
Minimize cost of painting N houses such that adjacent houses have different colors
15, Feb 21
Ways to arrange Balls such that adjacent balls are of different types
21, Mar 16
Flood fill Algorithm - how to implement fill() in paint?
16, Dec 14
Color N boxes using M colors such that K boxes have different color from the box on its left
21, Jan 19
Count ways to remove pairs from a matrix such that remaining elements can be grouped in vertical or horizontal pairs
26, Jan 21
Count ways to select N pairs of candies of distinct colors (Dynamic Programming + Bitmasking)
15, Mar 21
Count number of ways to fill a "n x 4" grid using "1 x 4" tiles
09, Mar 16
Maximum sum in an array such that every element has exactly one adjacent element to it
23, May 19
Maximum sum such that exactly half of the elements are selected and no two adjacent
27, Apr 20
Minimize the count of adjacent pairs with different parity
14, Apr 20
Check if there exists a non adjacent pair with given sum
08, Mar 22
Count ways to generate N-length array with 0s, 1s, and 2s such that sum of all adjacent pairwise products is K
28, Oct 20
Minimize swaps of pairs of characters required such that no two adjacent characters in the string are same
09, Jul 21
Balanced expressions such that given positions have opening brackets
22, Jan 18
Balanced expressions such that given positions have opening brackets | Set 2
13, Sep 18
Count ways to reach Nth Stairs by taking 1 and 2 steps with exactly one 3 step
18, Feb 20
Number of ways to make exactly C components in a 2*N matrix
26, Jun 20
Number of ways to select exactly K even numbers from given Array
18, Jul 20
Number of ways to reach at starting node after travelling through exactly K edges in a complete graph
05, Jul 21
Number of binary strings such that there is no substring of length ≥ 3
20, Jan 20
Minimum labelled node to be removed from undirected Graph such that there is no cycle
24, Apr 20
Different ways to sum n using numbers greater than or equal to m
15, Dec 17
Number of pairs such that path between pairs has the two vertices A and B
10, Apr 20
Find the number of distinct pairs of vertices which have a distance of exactly k in a tree
15, Feb 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Striver
@Striver
Vote for difficulty
Current difficulty :
Hard





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

Start Your Coding Journey Now!