Ways to arrange Balls such that adjacent balls are of different types - GeeksforGeeks

07 Jul, 2021
There are ‘p’ balls of type P, ‘q’ balls of type Q and ‘r’ balls of type R. Using the balls we want to create a straight line such that no two balls of same type are adjacent.Examples : 
Input  : p = 1, q = 1, r = 0
Output : 2
There are only two arrangements PQ and QP

Input  : p = 1, q = 1, r = 1
Output : 6
There are only six arrangements PQR, QPR,
QRP, RQP, PRQ and RPQ

Input  : p = 2, q = 1, r = 1
Output : 6
There are only six arrangements PQRP, QPRP,
PRQP, RPQP, PRPQ and PQPR
 
Naive Solution: The naive solution to this problem is a recursive solution. We recursively call for three cases 1) Last ball to be placed is of type P 2) Last ball to be placed is of type Q 3) Last ball to be placed is of type RBelow is the implementation of above idea.  
C++
Java
Python3
C#
PHP
Javascript
// C++ program to count number of ways to arrange three// types of balls such that no two balls of same color// are adjacent to each other#include<bits/stdc++.h>using namespace std; // Returns count of arrangements where last placed ball is// 'last'.  'last' is 0 for 'p', 1 for 'q' and 2 for 'r'int countWays(int p, int q, int r, int last){    // if number of balls of any color becomes less    // than 0 the number of ways arrangements is 0.    if (p<0 || q<0 || r<0)        return 0;     // If last ball required is of type P and the number    // of balls of P type is 1 while number of balls of    // other color is 0 the number of ways is 1.    if (p==1 && q==0 && r==0 && last==0)        return 1;     // Same case as above for 'q' and 'r'    if (p==0 && q==1 && r==0 && last==1)        return 1;    if (p==0 && q==0 && r==1 && last==2)        return 1;     // if last ball required is P and the number of ways is    // the sum of number of ways to form sequence with 'p-1' P    // balls, q Q Balls and r R balls ending with Q and R.    if (last==0)        return countWays(p-1,q,r,1) + countWays(p-1,q,r,2);     // Same as above case for 'q' and 'r'    if (last==1)        return countWays(p,q-1,r,0) + countWays(p,q-1,r,2);    if (last==2)        return countWays(p,q,r-1,0) + countWays(p,q,r-1,1);} // Returns count of required arrangementsint countUtil(int p, int q, int r){   // Three cases arise:   return countWays(p, q, r, 0) +  // Last required balls is type P          countWays(p, q, r, 1) +  // Last required balls is type Q          countWays(p, q, r, 2); // Last required balls is type R} // Driver code to test aboveint main(){    int p = 1, q = 1, r = 1;    printf("%d", countUtil(p, q, r));    return 0;}
// Java program to count number// of ways to arrange three types of// balls such that no two balls of// same color are adjacent to each otherclass GFG {         // Returns count of arrangements    // where last placed ball is    // 'last'. 'last' is 0 for 'p',    // 1 for 'q' and 2 for 'r'    static int countWays(int p, int q, int r, int last)    {        // if number of balls of any        // color becomes less than 0        // the number of ways arrangements is 0.        if (p < 0 || q < 0 || r < 0)        return 0;             // If last ball required is        // of type P and the number        // of balls of P type is 1        // while number of balls of        // other color is 0 the number        // of ways is 1.        if (p == 1 && q == 0 && r == 0 && last == 0)            return 1;             // Same case as above for 'q' and 'r'        if (p == 0 && q == 1 && r == 0 && last == 1)            return 1;        if (p == 0 && q == 0 && r == 1 && last == 2)            return 1;             // if last ball required is P        // and the number of ways is        // the sum of number of ways        // to form sequence with 'p-1' P        // balls, q Q Balls and r R balls        // ending with Q and R.        if (last == 0)        return countWays(p - 1, q, r, 1) +               countWays(p - 1, q, r, 2);             // Same as above case for 'q' and 'r'        if (last == 1)            return countWays(p, q - 1, r, 0) +                   countWays(p, q - 1, r, 2);                 if (last == 2)        return countWays(p, q, r - 1, 0) +               countWays(p, q, r - 1, 1);             return 0;    }         // Returns count of required arrangements    static int countUtil(int p, int q, int r) {        // Three cases arise:        return countWays(p, q, r, 0) + // Last required balls is type P               countWays(p, q, r, 1) + // Last required balls is type Q               countWays(p, q, r, 2);  // Last required balls is type R    }         // Driver code    public static void main(String[] args)    {        int p = 1, q = 1, r = 1;        System.out.print(countUtil(p, q, r));    }} // This code is contributed by Anant Agarwal.
# Python3 program to count# number of ways to arrange# three types of balls such # that no two balls of same# color are adjacent to each# other # Returns count of arrangements# where last placed ball is# 'last'. 'last' is 0 for 'p',# 1 for 'q' and 2 for 'r'def countWays(p, q, r, last):         # if number of balls of    # any color becomes less    # than 0 the number of    # ways arrangements is 0.    if (p < 0 or q < 0 or r < 0):        return 0;     # If last ball required is    # of type P and the number    # of balls of P type is 1    # while number of balls of    # other color is 0 the number    # of ways is 1.    if (p == 1 and q == 0 and        r == 0 and last == 0):        return 1;     # Same case as above    # for 'q' and 'r'    if (p == 0 and q == 1 and        r == 0 and last == 1):        return 1;             if (p == 0 and q == 0 and        r == 1 and last == 2):        return 1;     # if last ball required is P    # and the number of ways is    # the sum of number of ways    # to form sequence with 'p-1' P    # balls, q Q Balls and r R    # balls ending with Q and R.    if (last == 0):        return (countWays(p - 1, q, r, 1) +                countWays(p - 1, q, r, 2));     # Same as above case    # for 'q' and 'r'    if (last == 1):        return (countWays(p, q - 1, r, 0) +                countWays(p, q - 1, r, 2));    if (last == 2):        return (countWays(p, q, r - 1, 0) +                countWays(p, q, r - 1, 1)); # Returns count of# required arrangementsdef countUtil(p, q, r):         # Three cases arise:    # Last required balls is type P    # Last required balls is type Q    # Last required balls is type R    return (countWays(p, q, r, 0) +            countWays(p, q, r, 1) +            countWays(p, q, r, 2)); # Driver Codep = 1;q = 1;r = 1;print(countUtil(p, q, r));     # This code is contributed by mits
// C# program to count number// of ways to arrange three types of// balls such that no two balls of// same color are adjacent to each otherusing System; class GFG {         // Returns count of arrangements    // where last placed ball is    // 'last'. 'last' is 0 for 'p',    // 1 for 'q' and 2 for 'r'    static int countWays(int p, int q,                            int r, int last)    {                 // if number of balls of any        // color becomes less than 0        // the number of ways        // arrangements is 0.        if (p < 0 || q < 0 || r < 0)            return 0;             // If last ball required is        // of type P and the number        // of balls of P type is 1        // while number of balls of        // other color is 0 the number        // of ways is 1.        if (p == 1 && q == 0 && r == 0                              && last == 0)            return 1;             // Same case as above for 'q' and 'r'        if (p == 0 && q == 1 && r == 0                               && last == 1)            return 1;        if (p == 0 && q == 0 && r == 1                               && last == 2)            return 1;             // if last ball required is P        // and the number of ways is        // the sum of number of ways        // to form sequence with 'p-1' P        // balls, q Q Balls and r R balls        // ending with Q and R.        if (last == 0)            return countWays(p - 1, q, r, 1) +                    countWays(p - 1, q, r, 2);             // Same as above case for 'q' and 'r'        if (last == 1)            return countWays(p, q - 1, r, 0) +                countWays(p, q - 1, r, 2);                 if (last == 2)            return countWays(p, q, r - 1, 0) +                    countWays(p, q, r - 1, 1);             return 0;    }         // Returns count of required arrangements    static int countUtil(int p, int q, int r)    {                 // Three cases arise:        // 1. Last required balls is type P        // 2. Last required balls is type Q        // 3. Last required balls is type R        return countWays(p, q, r, 0) +               countWays(p, q, r, 1) +               countWays(p, q, r, 2);    }         // Driver code    public static void Main()    {        int p = 1, q = 1, r = 1;                 Console.Write(countUtil(p, q, r));    }} // This code is contributed by nitin mittal.
<?php// PHP program to count number// of ways to arrange three// types of balls such that// no two balls of same color// are adjacent to each other // Returns count of arrangements// where last placed ball is// 'last'. 'last' is 0 for 'p',// 1 for 'q' and 2 for 'r'function countWays($p, $q,                   $r, $last){         // if number of balls of    // any color becomes less    // than 0 the number of    // ways arrangements is 0.    if ($p < 0 || $q           < 0 || $r < 0)        return 0;     // If last ball required is    // of type P and the number    // of balls of P type is 1    // while number of balls of    // other color is 0 the number    // of ways is 1.    if ($p == 1 && $q == 0 &&        $r == 0 && $last == 0)        return 1;     // Same case as above    // for 'q' and 'r'    if ($p == 0 && $q == 1 &&        $r == 0 && $last == 1)        return 1;             if ($p == 0 && $q == 0 &&        $r == 1 && $last == 2)        return 1;     // if last ball required is P    // and the number of ways is    // the sum of number of ways    // to form sequence with 'p-1' P    // balls, q Q Balls and r R    // balls ending with Q and R.    if ($last == 0)        return countWays($p - 1, $q, $r, 1) +               countWays($p - 1, $q, $r, 2);     // Same as above case    // for 'q' and 'r'    if ($last == 1)        return countWays($p, $q - 1, $r, 0) +               countWays($p, $q - 1, $r, 2);    if ($last == 2)        return countWays($p, $q, $r - 1, 0) +               countWays($p, $q, $r - 1, 1);} // Returns count of// required arrangementsfunction countUtil($p, $q, $r){         // Three cases arise:    // Last required balls is type P    // Last required balls is type Q    // Last required balls is type R    return countWays($p, $q, $r, 0) +           countWays($p, $q, $r, 1) +           countWays($p, $q, $r, 2);}     // Driver Code    $p = 1;    $q = 1;    $r = 1;    echo(countUtil($p, $q, $r));     // This code is contributed by nitin mittal.?>
<script> // JavaScript program to count number// of ways to arrange three// types of balls such that no// two balls of same color// are adjacent to each other      // Returns count of arrangements    // where last placed ball is    // 'last'. 'last' is 0 for 'p',    // 1 for 'q' and 2 for 'r'    function countWays(p, q, r, last)    {             // if number of balls of any        // color becomes less than 0        // the number of ways arrangements is 0.        if (p < 0 || q < 0 || r < 0)        return 0;               // If last ball required is        // of type P and the number        // of balls of P type is 1        // while number of balls of        // other color is 0 the number        // of ways is 1.        if (p == 1 && q == 0 && r == 0 && last == 0)            return 1;               // Same case as above for 'q' and 'r'        if (p == 0 && q == 1 && r == 0 && last == 1)            return 1;        if (p == 0 && q == 0 && r == 1 && last == 2)            return 1;               // if last ball required is P        // and the number of ways is        // the sum of number of ways        // to form sequence with 'p-1' P        // balls, q Q Balls and r R balls        // ending with Q and R.        if (last == 0)        return countWays(p - 1, q, r, 1) +               countWays(p - 1, q, r, 2);               // Same as above case for 'q' and 'r'        if (last == 1)            return countWays(p, q - 1, r, 0) +                   countWays(p, q - 1, r, 2);                   if (last == 2)        return countWays(p, q, r - 1, 0) +               countWays(p, q, r - 1, 1);               return 0;    }           // Returns count of required arrangements    function countUtil(p, q, r)    {             // Three cases arise:        return countWays(p, q, r, 0) + // Last required balls is type P               countWays(p, q, r, 1) + // Last required balls is type Q               countWays(p, q, r, 2);  // Last required balls is type R    } // Driver Code         let p = 1, q = 1, r = 1;        document.write(countUtil(p, q, r));         // This code is contributed by target_2.</script>
Output: 
6
Time Complexity of this solution is exponential.We can observe that there are many subproblems being solved again and again so the problem can be solved using Dynamic Programming (DP). We can easily make memoization solution to this problem.  
C++
Java
C#
Python3
PHP
Javascript
// C++ program to count number of ways to arrange three// types of balls such that no two balls of same color// are adjacent to each other#include<bits/stdc++.h>using namespace std;#define MAX 100 // table to store to store results of subproblemsint dp[MAX][MAX][MAX][3]; // Returns count of arrangements where last placed ball is// 'last'.  'last' is 0 for 'p', 1 for 'q' and 2 for 'r'int countWays(int p, int q, int r, int last){    // if number of balls of any color becomes less    // than 0 the number of ways arrangements is 0.    if (p<0 || q<0 || r<0)        return 0;     // If last ball required is of type P and the number    // of balls of P type is 1 while number of balls of    // other color is 0 the number of ways is 1.    if (p==1 && q==0 && r==0 && last==0)        return 1;     // Same case as above for 'q' and 'r'    if (p==0 && q==1 && r==0 && last==1)        return 1;    if (p==0 && q==0 && r==1 && last==2)        return 1;     // If this subproblem is already evaluated    if (dp[p][q][r][last] != -1)        return dp[p][q][r][last];     // if last ball required is P and the number of ways is    // the sum of number of ways to form sequence with 'p-1' P    // balls, q Q Balls and r R balls ending with Q and R.    if (last==0)       dp[p][q][r][last] = countWays(p-1,q,r,1) + countWays(p-1,q,r,2);     // Same as above case for 'q' and 'r'    else if (last==1)       dp[p][q][r][last] = countWays(p,q-1,r,0) + countWays(p,q-1,r,2);    else //(last==2)       dp[p][q][r][last] =  countWays(p,q,r-1,0) + countWays(p,q,r-1,1);     return dp[p][q][r][last];} // Returns count of required arrangementsint countUtil(int p, int q, int r){   // Initialize 'dp' array   memset(dp, -1, sizeof(dp));    // Three cases arise:   return countWays(p, q, r, 0) +  // Last required balls is type P          countWays(p, q, r, 1) +  // Last required balls is type Q          countWays(p, q, r, 2); // Last required balls is type R} // Driver code to test aboveint main(){    int p = 1, q = 1, r = 1;    printf("%d", countUtil(p, q, r));    return 0;}
// Java program to count number// of ways to arrange three// types of balls such that no// two balls of same color// are adjacent to each otherimport java.util.Arrays; class GFG{     static final int MAX = 100;         // table to store to store results of subproblems    static int dp[][][][] = new int[MAX][MAX][MAX][3];         // Returns count of arrangements    // where last placed ball is    // 'last'. 'last' is 0 for 'p',    // 1 for 'q' and 2 for 'r'    static int countWays(int p, int q, int r, int last)    {        // if number of balls of any        // color becomes less than 0        // the number of ways arrangements is 0.        if (p < 0 || q < 0 || r < 0)        return 0;             // If last ball required is        // of type P and the number        // of balls of P type is 1        // while number of balls of        // other color is 0 the number        // of ways is 1.        if (p == 1 && q == 0 && r == 0 && last == 0)            return 1;             // Same case as above for 'q' and 'r'        if (p == 0 && q == 1 && r == 0 && last == 1)            return 1;                 if (p == 0 && q == 0 && r == 1 && last == 2)            return 1;             // If this subproblem is already evaluated        if (dp[p][q][r][last] != -1)            return dp[p][q][r][last];             // if last ball required is P and        // the number of ways is the sum        // of number of ways to form sequence        // with 'p-1' P balls, q Q balss and        // r R balls ending with Q and R.        if (last == 0)        dp[p][q][r][last] = countWays(p - 1, q, r, 1) +                            countWays(p - 1, q, r, 2);             // Same as above case for 'q' and 'r'        else if (last == 1)        dp[p][q][r][last] = countWays(p, q - 1, r, 0) +                            countWays(p, q - 1, r, 2);        //(last==2)        else        dp[p][q][r][last] = countWays(p, q, r - 1, 0) +                            countWays(p, q, r - 1, 1);             return dp[p][q][r][last];    }         // Returns count of required arrangements    static int countUtil(int p, int q, int r)    {        // Initialize 'dp' array        for (int[][][] row : dp)        {            for (int[][] innerRow : row)            {                for (int[] innerInnerRow : innerRow)                {                    Arrays.fill(innerInnerRow, -1);                }            }        };             // Three cases arise:        return countWays(p, q, r, 0) + // Last required balls is type P            countWays(p, q, r, 1) +    // Last required balls is type Q            countWays(p, q, r, 2);       // Last required balls is type R    }     // Driver code    public static void main(String[] args)    {        int p = 1, q = 1, r = 1;        System.out.print(countUtil(p, q, r));    }} // This code is contributed by Anant Agarwal.
// C# program to count number// of ways to arrange three// types of balls such that no// two balls of same color// are adjacent to each otherusing System; class GFG{     static int MAX = 101;         // table to store to store results of subproblems    static int[,,,] dp = new int[MAX, MAX, MAX, 4];         // Returns count of arrangements    // where last placed ball is    // 'last'. 'last' is 0 for 'p',    // 1 for 'q' and 2 for 'r'    static int countWays(int p, int q, int r, int last)    {        // if number of balls of any        // color becomes less than 0        // the number of ways arrangements is 0.        if (p < 0 || q < 0 || r < 0)        return 0;             // If last ball required is        // of type P and the number        // of balls of P type is 1        // while number of balls of        // other color is 0 the number        // of ways is 1.        if (p == 1 && q == 0 && r == 0 && last == 0)            return 1;             // Same case as above for 'q' and 'r'        if (p == 0 && q == 1 && r == 0 && last == 1)            return 1;                 if (p == 0 && q == 0 && r == 1 && last == 2)            return 1;             // If this subproblem is already evaluated        if (dp[p, q, r, last] != -1)            return dp[p, q, r, last];             // if last ball required is P and        // the number of ways is the sum        // of number of ways to form sequence        // with 'p-1' P balls, q Q balss and        // r R balls ending with Q and R.        if (last == 0)        dp[p, q, r, last] = countWays(p - 1, q, r, 1) +                            countWays(p - 1, q, r, 2);             // Same as above case for 'q' and 'r'        else if (last == 1)        dp[p, q, r, last] = countWays(p, q - 1, r, 0) +                            countWays(p, q - 1, r, 2);        //(last==2)        else        dp[p, q, r, last] = countWays(p, q, r - 1, 0) +                            countWays(p, q, r - 1, 1);             return dp[p, q, r, last];    }         // Returns count of required arrangements    static int countUtil(int p, int q, int r)    {        // Initialize 'dp' array        for(int i = 0; i < MAX; i++)        for(int j = 0; j < MAX; j++)        for(int k = 0; k < MAX; k++)        for(int l = 0; l < 4; l++)        dp[i, j, k, l] = -1;             // Three cases arise:        return countWays(p, q, r, 0) + // Last required balls is type P            countWays(p, q, r, 1) + // Last required balls is type Q            countWays(p, q, r, 2); // Last required balls is type R    }     // Driver code    static void Main()    {        int p = 1, q = 1, r = 1;        Console.WriteLine(countUtil(p, q, r));    }} // This code is contributed by mits.
# Python3 program to count number of ways to# arrange three types of balls such that no# two balls of same color are adjacent to each otherMAX = 100; # table to store to store results of subproblemsdp = [[[[-1] * 4 for i in range(MAX)]                 for j in range(MAX)]                 for k in range(MAX)]; # Returns count of arrangements where last# placed ball is 'last'. 'last' is 0 for 'p',# 1 for 'q' and 2 for 'r'def countWays(p, q, r, last):     # if number of balls of any color becomes less    # than 0 the number of ways arrangements is 0.    if (p < 0 or q < 0 or r < 0):        return 0;     # If last ball required is of type P and the    # number of balls of P type is 1 while number    # of balls of other color is 0 the number of    # ways is 1.    if (p == 1 and q == 0 and        r == 0 and last == 0):        return 1;     # Same case as above for 'q' and 'r'    if (p == 0 and q == 1 and        r == 0 and last == 1):        return 1;    if (p == 0 and q == 0 and        r == 1 and last == 2):        return 1;     # If this subproblem is already evaluated    if (dp[p][q][r][last] != -1):        return dp[p][q][r][last];     # if last ball required is P and the number    # of ways is the sum of number of ways to     # form sequence with 'p-1' P balls, q Q Balls    # and r R balls ending with Q and R.    if (last == 0):        dp[p][q][r][last] = (countWays(p - 1, q, r, 1) +                             countWays(p - 1, q, r, 2));     # Same as above case for 'q' and 'r'    elif (last == 1):        dp[p][q][r][last] = (countWays(p, q - 1, r, 0) +                             countWays(p, q - 1, r, 2));    else:                 #(last==2)        dp[p][q][r][last] = (countWays(p, q, r - 1, 0) +                             countWays(p, q, r - 1, 1));     return dp[p][q][r][last]; # Returns count of required arrangementsdef countUtil(p, q, r):         # Three cases arise:    # Last required balls is type P    # Last required balls is type Q    # Last required balls is type R    return (countWays(p, q, r, 0) +            countWays(p, q, r, 1) +            countWays(p, q, r, 2)); # Driver Codep, q, r = 1, 1, 1;print(countUtil(p, q, r)); # This code is contributed by mits
<?php// PHP program to count number of ways to// arrange three types of balls such that// no two balls of same color are adjacent// to each other$MAX = 100; // table to store to store results of subproblems$dp = array_fill(0, $MAX, array_fill(0, $MAX,      array_fill(0, $MAX, array_fill(0, 3, -1)))); // Returns count of arrangements where last// placed ball is 'last'. 'last' is 0 for 'p',// 1 for 'q' and 2 for 'r'function countWays($p, $q, $r, $last){    global $dp;         // if number of balls of any color becomes less    // than 0 the number of ways arrangements is 0.    if ($p < 0 || $q < 0 || $r < 0)        return 0;     // If last ball required is of type P and the    // number of balls of P type is 1 while number    // of balls of other color is 0 the number of    // ways is 1.    if ($p == 1 && $q == 0 && $r == 0 && $last == 0)        return 1;     // Same case as above for 'q' and 'r'    if ($p == 0 && $q == 1 && $r == 0 && $last == 1)        return 1;    if ($p == 0 && $q == 0 && $r == 1 && $last == 2)        return 1;     // If this subproblem is already evaluated    if ($dp[$p][$q][$r][$last] != -1)        return $dp[$p][$q][$r][$last];     // if last ball required is P and the number of    // ways is the sum of number of ways to form    // sequence with 'p-1' P balls, q Q Balls and r    // R balls ending with Q and R.    if ($last == 0)    $dp[$p][$q][$r][$last] = countWays($p - 1, $q, $r, 1) +                             countWays($p - 1, $q, $r, 2);     // Same as above case for 'q' and 'r'    else if ($last == 1)    $dp[$p][$q][$r][$last] = countWays($p, $q - 1, $r, 0) +                             countWays($p, $q - 1, $r, 2);    else //(last==2)    $dp[$p][$q][$r][$last] = countWays($p, $q, $r - 1, 0) +                             countWays($p, $q, $r - 1, 1);     return $dp[$p][$q][$r][$last];} // Returns count of required arrangementsfunction countUtil($p, $q, $r){ // Three cases arise:return countWays($p, $q, $r, 0) + // Last required balls is type P       countWays($p, $q, $r, 1) + // Last required balls is type Q       countWays($p, $q, $r, 2); // Last required balls is type R} // Driver code$p = 1;$q = 1;$r = 1;print(countUtil($p, $q, $r)); // This code is contributed by mits?>
<script> // javascript program to count number// of ways to arrange three// types of balls such that no// two balls of same color// are adjacent to each other  var MAX = 100; // table to store to store results of subproblemsvar dp = Array(MAX).fill(-1).map(x =>Array(MAX).fill(-1).map(x =>Array(MAX).fill(-1).map(x => Array(3).fill(-1)))); // Returns count of arrangements// where last placed ball is// 'last'. 'last' is 0 for 'p',// 1 for 'q' and 2 for 'r'function countWays( p , q , r , last){    // if number of balls of any    // color becomes less than 0    // the number of ways arrangements is 0.    if (p < 0 || q < 0 || r < 0)    return 0;     // If last ball required is    // of type P and the number    // of balls of P type is 1    // while number of balls of    // other color is 0 the number    // of ways is 1.    if (p == 1 && q == 0 && r == 0 && last == 0)        return 1;     // Same case as above for 'q' and 'r'    if (p == 0 && q == 1 && r == 0 && last == 1)        return 1;         if (p == 0 && q == 0 && r == 1 && last == 2)        return 1;     // If this subproblem is already evaluated    if (dp[p][q][r][last] != -1)        return dp[p][q][r][last];     // if last ball required is P and    // the number of ways is the sum    // of number of ways to form sequence    // with 'p-1' P balls, q Q balss and    // r R balls ending with Q and R.    if (last == 0)    dp[p][q][r][last] = countWays(p - 1, q, r, 1) +                        countWays(p - 1, q, r, 2);     // Same as above case for 'q' and 'r'    else if (last == 1)    dp[p][q][r][last] = countWays(p, q - 1, r, 0) +                        countWays(p, q - 1, r, 2);    //(last==2)    else    dp[p][q][r][last] = countWays(p, q, r - 1, 0) +                        countWays(p, q, r - 1, 1);     return dp[p][q][r][last];} // Returns count of required arrangementsfunction countUtil(p , q , r){     // Three cases arise:    return countWays(p, q, r, 0) + // Last required balls is type P        countWays(p, q, r, 1) +    // Last required balls is type Q        countWays(p, q, r, 2);       // Last required balls is type R} // Driver codevar p = 1, q = 1, r = 1;document.write(countUtil(p, q, r)); // This code contributed by Princi Singh</script>
Output: 
6
Time complexity : O(p*q*r) Auxiliary Space : O(p*q*r*3)This article is contributed by Bhavuk Chawla. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
nitin mittal
Mithun Kumar
target_2
princi singh
Dynamic Programming
Mathematical
Dynamic Programming
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Overlapping Subproblems Property in Dynamic Programming | DP-1
Edit Distance | DP-5
Write a program to print all permutations of a given string
C++ Data Types
Set in C++ Standard Template Library (STL)
Merge two sorted arrays
Program to find GCD or HCF of two numbers