Skip to content
Related Articles
Open in App
Not now

Related Articles

Count ways of selecting X red balls and Y blue balls

Improve Article
Save Article
Like Article
  • Difficulty Level : Hard
  • Last Updated : 29 Mar, 2023
Improve Article
Save Article
Like Article

Given integers A, B, C, and D, There are two boxes First Box has A red balls and B blue balls and the second box has C red balls and D blue balls, the task is to count ways to select 3 red balls and 3 blue balls so that there are 3 balls drawn from the first box and 3 balls drawn from the second box. (Print the answer modulo 109 + 7).

Examples:

Input: A = 4, B =3, C = 3, D = 4
Output: 485

Input: A = 3, B = 3, C = 3, D = 3
Output: 164

Naive approach: The basic way to solve the problem is as follows:

The basic way to solve this problem is to generate all possible combinations by using a recursive approach.

Time Complexity: O(N!)
Auxiliary Space: O(1)

Efficient Approach:  The above approach can be optimized based on the following idea:

The problem can be solved with combinatorics:

Case 1: 2 red balls and 1 blue ball from box 1 and 1 red ball and 2 blue balls from box 2.

  • Total ways of case1 = AC2 * BC1 * CC1 * DC2 

Case 2: 3 red balls from box 1 and 3 blue balls from box 2.

  • Total ways of case2 = AC3 * DC3

Case 3: 3 blue balls from box1 and 3 red balls from box 2

  • Total ways of case3 = BC3 * CC3

Case 4: 1 red ball and 2 blue balls from box 1 and  2 red balls and 1 blue ball from box 2.

  • Total ways of case4 = AC1 * BC2 * CC2 * DC1 

Total ways = Total ways of case1 + Total ways of case2 + Total ways of case3 + Total ways of case 3 + Total ways of case4

instead of dividing factorials we multiply their modular multiplicative inverses.

Follow the steps below to solve the problem:

  • Initializing fact[] array and Precomputing all factorials from 1 to 100000.
  • initializing ANS variable.
  • Calculating the answer by using the above formula.
  • Print the answer.

Below is the implementation of the above approach:

C++




// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;
 
// to avoid integer overflow
#define int long long
 
const int MOD = 1e9 + 7;
 
// To find GCD of a and b
int gcd(int a, int b);
 
// To compute x raised to power y under
// modulo M
int power(int x, unsigned int y, unsigned int M);
 
// Function to find modular inverse of
// under modulo M
// Assumption: M is prime
int modInverse(int A, int M)
{
    int g = gcd(A, M);
    return power(A, M - 2, M);
}
 
// To compute x^y under modulo m
int power(int x, unsigned int y, unsigned int M)
{
    if (y == 0)
        return 1;
 
    int p = power(x, y / 2, M) % M;
    p = (p * p) % M;
 
    return (y % 2 == 0) ? p : (x * p) % M;
}
 
// Function to return gcd of a and b
int gcd(int a, int b)
{
    if (a == 0)
        return b;
    return gcd(b % a, a);
}
 
// Function to Count number of ways
// of taking 3 red balls and 3 blue
// balls so that 3 balls are from box1
// and 3 balls are from box 2
int countWays(int A, int B, int C, int D)
{
 
    // Precomputation array storing
    // factorials MOD 1e9 + 7
    int fact[100001];
 
    // Initialize the base elements
    fact[1] = 1, fact[0] = 1;
 
    // Filling factorial table
    for (int i = 2; i <= 100000; i++) {
        fact[i] = (fact[i - 1] * i) % MOD;
    }
 
    // case 1 multiplying A!/(A-2)!
    int ans1
        = (fact[A] * modInverse(fact[A - 2], MOD)) % MOD;
 
    // case 1 multiplying B!/(B-1)!
    ans1 = (ans1 * fact[B] * modInverse(fact[B - 1], MOD))
           % MOD;
 
    // case 1 taking into account C!/(C-1)!
    ans1 = (ans1 * fact[C] * modInverse(fact[C - 1], MOD))
           % MOD;
 
    // case 1 taking into account D!/(D-1)!
    ans1 = (ans1 * fact[D] * modInverse(fact[D - 2], MOD))
           % MOD;
 
    // case 1 taking into account / 4
    ans1 = (ans1 * modInverse(4, MOD)) % MOD;
 
    // case 2 multiplying A!/(A-3)!
    int ans2
        = (fact[A] * modInverse(fact[A - 3], MOD)) % MOD;
 
    // case 2 multiplying D!/(D-3)!
    ans2 = (ans2 * fact[D] * modInverse(fact[D - 3], MOD))
           % MOD;
 
    // case 2 taking into account / 36
    ans2 = (ans2 * modInverse(36, MOD)) % MOD;
 
    // case 3 multiplying B!/(B-3)!
    int ans3
        = (fact[B] * modInverse(fact[B - 3], MOD)) % MOD;
 
    // case 3 multiplying C!/(C-3)!
    ans3 = (ans3 * fact[C] * modInverse(fact[C - 3], MOD))
           % MOD;
 
    // case 3 taking into account / 36
    ans3 = (ans3 * modInverse(36, MOD)) % MOD;
 
    // case 4 multiplying A!/(A-1)!
    int ans4
        = (fact[A] * modInverse(fact[A - 1], MOD)) % MOD;
 
    // case 4 multiplying B!/(B-2)!
    ans4 = (ans4 * fact[B] * modInverse(fact[B - 2], MOD))
           % MOD;
 
    // case 4 taking into account C!/(C-2)!
    ans4 = (ans4 * fact[C] * modInverse(fact[C - 2], MOD))
           % MOD;
 
    // case 4 taking into account D!/(D-1)!
    ans4 = (ans4 * fact[D] * modInverse(fact[D - 1], MOD))
           % MOD;
 
    // case 4 taking into accont / 4
    ans4 = (ans4 * modInverse(4, MOD)) % MOD;
 
    // answer
    int ans = (ans1 + ans2 + ans3 + ans4) % MOD;
 
    // Returning the answer
    return ans;
}
 
// Driver Code
int32_t main()
{
 
    // Input 1
    int A = 4, B = 3, C = 3, D = 4;
 
    // Function Call
    cout << countWays(A, B, C, D) << endl;
 
    // Input 2
    int A1 = 3, B1 = 3, C1 = 3, D1 = 3;
 
    // Function Call
    cout << countWays(A1, B1, C1, D1) << endl;
    return 0;
}

Java



// Java code for the above approach
import java.io.*;
class GFG {
 
  static final int MOD = (int)1e9 + 7;
 
  // To find GCD of a and b
  static int gcd(int a, int b)
  {
    if (a == 0)
      return b;
    return gcd(b % a, a);
  }
 
  // To compute x raised to power y under modulo M
  static int power(int x, int y, int M)
  {
    if (y == 0)
      return 1;
 
    int p = power(x, y / 2, M) % M;
    p = (int)((long)p * p % M);
 
    return (y % 2 == 0) ? p : (int)((long)x * p % M);
  }
 
  // Function to find modular inverse of A under modulo M
  // Assumption: M is prime
  static int modInverse(int A, int M)
  {
    int g = gcd(A, M);
    return power(A, M - 2, M);
  }
 
  // Function to Count number of ways
  // of taking 3 red balls and 3 blue
  // balls so that 3 balls are from box1
  // and 3 balls are from box 2
  static int countWays(int A, int B, int C, int D)
  {
 
    // Precomputation array storing factorials MOD 1e9 +
    // 7
    int[] fact = new int[100001];
 
    // Initialize the base elements
    fact[1] = 1;
    fact[0] = 1;
 
    // Fill factorial table
    for (int i = 2; i <= 100000; i++) {
      fact[i] = (int)((long)fact[i - 1] * i % MOD);
    }
 
    // case 1 multiplying A!/(A-2)!
    int ans1
      = (int)((long)fact[A]
              * modInverse(fact[A - 2], MOD) % MOD);
 
    // case 1 multiplying B!/(B-1)!
    ans1 = (int)((long)ans1 * fact[B] % MOD
                 * modInverse(fact[B - 1], MOD) % MOD);
 
    // case 1 taking into account C!/(C-1)!
    ans1 = (int)((long)ans1 * fact[C] % MOD
                 * modInverse(fact[C - 1], MOD) % MOD);
 
    // case 1 taking into account D!/(D-1)!
    ans1 = (int)((long)ans1 * fact[D] % MOD
                 * modInverse(fact[D - 2], MOD) % MOD);
 
    // case 1 taking into account / 4
    ans1 = (int)((long)ans1 * modInverse(4, MOD) % MOD);
 
    // case 2 multiplying A!/(A-3)!
    int ans2
      = (int)((long)fact[A]
              * modInverse(fact[A - 3], MOD) % MOD);
 
    // case 2 multiplying D!/(D-3)!
    ans2 = (int)((long)ans2 * fact[D] % MOD
                 * modInverse(fact[D - 3], MOD) % MOD);
 
    // case 2 taking into account / 36
    ans2
      = (int)((long)ans2 * modInverse(36, MOD) % MOD);
 
    // case 3 multiplying B!/(B-3)!
    int ans3
      = (int)((long)fact[B]
              * modInverse(fact[B - 3], MOD) % MOD);
 
    // case 3 multiplying C!/(C-3)!
    ans3 = (int)((long)ans3 * fact[C] % MOD
                 * modInverse(fact[C - 3], MOD) % MOD);
 
    // case 3 taking into account / 36
    ans3
      = (int)((long)ans3 * modInverse(36, MOD) % MOD);
 
    // case 4 multiplying A!/(A-1)!
    int ans4
      = (int)((long)fact[A]
              * modInverse(fact[A - 1], MOD) % MOD);
 
    // case 4 multiplying B!/(B-2)!
    ans4 = (int)((long)ans4 * fact[B] % MOD
                 * modInverse(fact[B - 2], MOD) % MOD);
 
    // case 4 taking into account C!/(C-2)!
    ans4 = (int)((long)ans4 * fact[C] % MOD
                 * modInverse(fact[C - 2], MOD) % MOD);
 
    // case 4 taking into account D!/(D-2)!
    ans4 = (int)((long)ans4 * fact[D] % MOD
                 * modInverse(fact[D - 1], MOD) % MOD);
 
    // case 4 taking into account / 12
    ans4 = (int)((long)ans4 * modInverse(4, MOD) % MOD);
 
    return (ans1 + ans2 + ans3 + ans4) % MOD;
  }
 
  public static void main(String[] args)
  {
     
    // Input 1
    int A = 4, B = 3, C = 3, D = 4;
 
    // Function Call
    System.out.println(countWays(A, B, C, D));
 
    // Input 2
    int A1 = 3, B1 = 3, C1 = 3, D1 = 3;
 
    // Function Call
    System.out.println(countWays(A1, B1, C1, D1));
  }
}
 
// This code is contributed by lokesh.
Python3



# Python code for the above approach
import math
 
MOD = int(1e9 + 7)
 
# To find GCD of a and b
def gcd(a: int, b: int) -> int:
    if a == 0:
        return b
    return gcd(b % a, a)
 
# To compute x raised to power y under
# modulo M
def power(x: int, y: int, M: int) -> int:
    if y == 0:
        return 1
    p = power(x, y // 2, M) % M
    p = (p * p) % M
    return (p if y % 2 == 0 else (x * p) % M)
 
# Function to find modular inverse of
# under modulo M
# Assumption: M is prime
def modInverse(A: int, M: int) -> int:
    g = gcd(A, M)
    return power(A, M - 2, M)
 
# Function to Count number of ways
# of taking 3 red balls and 3 blue
# balls so that 3 balls are from box1
# and 3 balls are from box 2
def countWays(A: int, B: int, C: int, D: int) -> int:
    # Precomputation array storing
    # factorials MOD 1e9 + 7
    fact = [1 for i in range(100001)]
    # Filling factorial table
    for i in range(2, 100001):
        fact[i] = (fact[i - 1] * i) % MOD
 
    # case 1 multiplying A!/(A-2)!
    ans1 = (fact[A] * modInverse(fact[A - 2], MOD)) % MOD
    # case 1 multiplying B!/(B-1)!
    ans1 = (ans1 * fact[B] * modInverse(fact[B - 1], MOD)) % MOD
    # case 1 taking into account C!/(C-1)!
    ans1 = (ans1 * fact[C] * modInverse(fact[C - 1], MOD)) % MOD
    # case 1 taking into account D!/(D-1)!
    ans1 = (ans1 * fact[D] * modInverse(fact[D - 2], MOD)) % MOD
 
    # case 1 taking into account / 4
    ans1 = (ans1 * modInverse(4, MOD)) % MOD
 
    # case 2 multiplying A!/(A-3)!
    ans2 = (fact[A] * modInverse(fact[A - 3], MOD)) % MOD
    # case 2 multiplying D!/(D-3)!
    ans2 = (ans2 * fact[D] * modInverse(fact[D - 3], MOD)) % MOD
    # case 2 taking into account / 36
    ans2 = (ans2 * modInverse(36, MOD)) % MOD
 
    # case 3 multiplying B!/(B-3)!
    ans3 = (fact[B] * modInverse(fact[B - 3], MOD)) % MOD
    # case 3 multiplying C!/(C-3)!
    ans3 = (ans3 * fact[C] * modInverse(fact[C - 3], MOD)) % MOD
    # case 3 taking into account / 36
    ans3 = (ans3 * modInverse(36, MOD)) % MOD
 
    # case 4 multiplying A!/(A-1)!
    ans4 = (fact[A] * modInverse(fact[A - 1], MOD)) % MOD
    # case 4 multiplying B!/(B-2)!
    ans4 = (ans4 * fact[B] * modInverse(fact[B - 2], MOD)) % MOD
    # case 4 taking into account C!/(C-2)!
    ans4 = (ans4 * fact[C] * modInverse(fact[C - 2], MOD)) % MOD
    # case 4 taking into account D!/(D-2)!
    ans4 = (ans4 * fact[D] * modInverse(fact[D - 1], MOD)) % MOD
    # case 4 taking into account / 12
    ans4 = (ans4 * modInverse(4, MOD)) % MOD
 
    # Return the final answer
    return (ans1 + ans2 + ans3 + ans4) % MOD
   
# Driver code
if __name__ == '__main__':
    A = 4 # Number of red balls in box 1
    B = 3 # Number of blue balls in box 1
    C = 3 # Number of red balls in box 2
    D = 4 # Number of blue balls in box 2
    # Function call to find number of ways
    print(int(countWays(A, B, C, D)))
    A = 3# Number of red balls in box 1
    B = 3 # Number of blue balls in box 1
    C = 3 # Number of red balls in box 2
    D = 3 # Number of blue balls in box 2
    # Function call to find number of ways
    print(int(countWays(A, B, C, D)))
     
# This code is contributed by Potta Lokesh
C#



// C# code to implement the approach
using System;
using System.Collections.Generic;
 
class GFG {
 
  const long MOD = 1000000007;
 
  // Function to return gcd of a and b
  static long gcd(long a, long b)
  {
    if (a == 0)
      return b;
    return gcd(b % a, a);
  }
 
  // To compute x^y under modulo m
  static long power(long x,  long y,  long M)
  {
    if (y == 0)
      return 1;
 
    long p = power(x, y / 2, M) % M;
    p = (p * p) % M;
 
    return (y % 2 == 0) ? p : (x * p) % M;
  }
 
  // Function to find modular inverse of
  // under modulo M
  // Assumption: M is prime
  static long modInverse(long A, long M)
  {
    long g = gcd(A, M);
    return power(A, M - 2, M);
  }
 
  // Function to Count number of ways
  // of taking 3 red balls and 3 blue
  // balls so that 3 balls are from box1
  // and 3 balls are from box 2
  static long countWays(long A, long B, long C, long D)
  {
 
    // Precomputation array storing
    // factorials MOD 1e9 + 7
    long[] fact=new long[100001];
 
    // Initialize the base elements
    fact[1] = 1;
    fact[0] = 1;
 
    // Filling factorial table
    for (long i = 2; i <= 100000; i++) {
      fact[i] = (fact[i - 1] * i) % MOD;
    }
 
    // case 1 multiplying A!/(A-2)!
    long ans1
      = (fact[A] * modInverse(fact[A - 2], MOD)) % MOD;
 
    // case 1 multiplying B!/(B-1)!
    ans1 = (ans1 * fact[B] * modInverse(fact[B - 1], MOD))
      % MOD;
 
    // case 1 taking longo account C!/(C-1)!
    ans1 = (ans1 * fact[C] * modInverse(fact[C - 1], MOD))
      % MOD;
 
    // case 1 taking longo account D!/(D-1)!
    ans1 = (ans1 * fact[D] * modInverse(fact[D - 2], MOD))
      % MOD;
 
    // case 1 taking longo account / 4
    ans1 = (ans1 * modInverse(4, MOD)) % MOD;
 
    // case 2 multiplying A!/(A-3)!
    long ans2
      = (fact[A] * modInverse(fact[A - 3], MOD)) % MOD;
 
    // case 2 multiplying D!/(D-3)!
    ans2 = (ans2 * fact[D] * modInverse(fact[D - 3], MOD))
      % MOD;
 
    // case 2 taking longo account / 36
    ans2 = (ans2 * modInverse(36, MOD)) % MOD;
 
    // case 3 multiplying B!/(B-3)!
    long ans3
      = (fact[B] * modInverse(fact[B - 3], MOD)) % MOD;
 
    // case 3 multiplying C!/(C-3)!
    ans3 = (ans3 * fact[C] * modInverse(fact[C - 3], MOD))
      % MOD;
 
    // case 3 taking longo account / 36
    ans3 = (ans3 * modInverse(36, MOD)) % MOD;
 
    // case 4 multiplying A!/(A-1)!
    long ans4
      = (fact[A] * modInverse(fact[A - 1], MOD)) % MOD;
 
    // case 4 multiplying B!/(B-2)!
    ans4 = (ans4 * fact[B] * modInverse(fact[B - 2], MOD))
      % MOD;
 
    // case 4 taking longo account C!/(C-2)!
    ans4 = (ans4 * fact[C] * modInverse(fact[C - 2], MOD))
      % MOD;
 
    // case 4 taking longo account D!/(D-1)!
    ans4 = (ans4 * fact[D] * modInverse(fact[D - 1], MOD))
      % MOD;
 
    // case 4 taking longo accont / 4
    ans4 = (ans4 * modInverse(4, MOD)) % MOD;
 
    // answer
    long ans = (ans1 + ans2 + ans3 + ans4) % MOD;
 
    // Returning the answer
    return ans;
  }
 
  // Driver Code
  public static void Main()
  {
 
    // Input 1
    long A = 4, B = 3, C = 3, D = 4;
 
    // Function Call
    Console.Write(countWays(A, B, C, D)+"\n");
 
    // Input 2
    long A1 = 3, B1 = 3, C1 = 3, D1 = 3;
 
    // Function Call
    Console.Write(countWays(A1, B1, C1, D1)+"\n");
  }
}
 
// This code is contributed by agrawalpoojaa976.
Javascript



// Javascript code for the above approach
const MOD = BigInt(1e9 + 7);
 
// To find GCD of a and b
function gcd(a, b) {
  if (a == 0n) {
    return b;
  }
  return gcd(b % a, a);
}
// To compute x raised to power y under
// modulo M
function power(x, y, M) {
  if (y == 0n) {
    return 1n;
  }
  let p = power(x, y / 2n, M) % M;
  p = (p * p) % M;
  return (y % 2n == 0n ? p : (x * p) % M);
}
 
// Function to find modular inverse of
// under modulo M
// Assumption: M is prime
function modInverse(A, M) {
  const g = gcd(A, M);
  return power(A, M - 2n, M);
}
 
// Function to Count number of ways
// of taking 3 red balls and 3 blue
// balls so that 3 balls are from box1
// and 3 balls are from box 2
function countWays(A, B, C, D) {
    // Precomputation array storing
    // factorials MOD 1e9 + 7
  const fact = [BigInt(1)];
  // Filling factorial table
  for (let i = 1n; i <= 100000n; i++) {
    fact.push((fact[i - 1n] * i) % MOD);
  }
  // case 1 multiplying A!/(A-2)!
  let ans1 = (fact[A] * modInverse(fact[A - 2n], MOD)) % MOD;
   
  // case 1 multiplying B!/(B-1)!
  ans1 = (ans1 * fact[B] * modInverse(fact[B - 1n], MOD)) % MOD;
   
  // case 1 taking into account C!/(C-1)!
  ans1 = (ans1 * fact[C] * modInverse(fact[C - 1n], MOD)) % MOD;
   
   // case 1 taking into account D!/(D-1)!
  ans1 = (ans1 * fact[D] * modInverse(fact[D - 2n], MOD)) % MOD;
     
  // case 1 taking into account / 4
  ans1 = (ans1 * modInverse(4n, MOD)) % MOD;
 
  // case 2 multiplying A!/(A-3)!
  let ans2 = (fact[A] * modInverse(fact[A - 3n], MOD)) % MOD;
   
   // case 2 multiplying D!/(D-3)!
  ans2 = (ans2 * fact[D] * modInverse(fact[D - 3n], MOD)) % MOD;
   
  // case 2 taking into account / 36
  ans2 = (ans2 * modInverse(36n, MOD)) % MOD;
 
  // case 3 multiplying B!/(B-3)!
  let ans3 = (fact[B] * modInverse(fact[B - 3n], MOD)) % MOD;
   
  // case 3 multiplying C!/(C-3)!
  ans3 = (ans3 * fact[C] * modInverse(fact[C - 3n], MOD)) % MOD;
   
  // case 3 taking into account / 36
  ans3 = (ans3 * modInverse(36n, MOD)) % MOD;
     
  // case 4 multiplying A!/(A-1)!
  let ans4 = (fact[A] * modInverse(fact[A - 1n], MOD)) % MOD;
   
  // case 4 multiplying B!/(B-2)!
  ans4 = (ans4 * fact[B] * modInverse(fact[B - 2n], MOD)) % MOD;
   
  // case 4 taking into account C!/(C-2)!
  ans4 = (ans4 * fact[C] * modInverse(fact[C - 2n], MOD)) % MOD;
   
  // case 4 taking into account D!/(D-2)!
  ans4 = (ans4 * fact[D] * modInverse(fact[D - 1n], MOD)) % MOD;
   
  // case 4 taking into account / 12
  ans4 = (ans4 * modInverse(4n, MOD)) % MOD;
 
  // Return the final answer
  return Number((ans1 + ans2 + ans3 + ans4) % MOD);
}
 
// Driver Code
console.log(countWays(4n, 3n, 3n, 4n));
console.log(countWays(3n, 3n, 3n, 3n));
 
// This code is contributed by sdeadityasharma
Output
485
164
Time Complexity: O(N)
Auxiliary Space: O(N)
Related Articles:

My Personal Notes
arrow_drop_up
Like Article

Save Article

Related Articles
1.
Find ways to arrange K green balls among N balls such that exactly i moves is needed to collect all K green balls
2.
Ways to arrange Balls such that adjacent balls are of different types
3.
Find winner in game of N balls, in which a player can remove any balls in range [A, B] in a single move
4.
Count ways choosing K balls from any given A boxes
5.
Ways of selecting men and women from a group to make a team
6.
Total ways of selecting a group of X men from N men with or without including a particular man
7.
Number of ways of scoring R runs in B balls with at most W wickets
8.
Ways to choose balls such that at least one ball is chosen
9.
Find the number of ways to fill the buckets with balls
10.
How To Troubleshoot and Fix Windows 10 Blue Screen Errors?
Previous
Output Restricted Queue
Next

Introduction to Address Descriptor
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
i_am_gaurav
@i_am_gaurav
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!