Count ways of selecting X red balls and Y blue balls

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 10⁹ + 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 = ^AC₂ * ^BC₁ * ^CC₁ * ^DC₂

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

• Total ways of case2 = ^AC₃ * ^DC₃

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

• Total ways of case3 = ^BC₃ * ^CC₃

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 = ^AC₁ * ^BC₂ * ^CC₂ * ^DC₁

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)