Queries of nCr%p in O(1) time complexity

19 Jan, 2022
Given Q queries and P where P is a prime number, each query has two numbers N and R and the task is to calculate nCr mod p. Constraints: 
N <= 106
R <= 106
p is a prime number
Examples:
Input: Q = 2 p = 1000000007 1st query: N = 15, R = 4 2nd query: N = 20, R = 3 Output: 1st query: 1365 2nd query: 1140 15!/(4!*(15-4)!)%1000000007 = 1365 20!/(20!*(20-3)!)%1000000007 = 1140
A naive approach is to calculate nCr using formulae by applying modular operations at any time. Hence time complexity will be O(q*n).
A better approach is to use fermat little theorem. According to it nCr can also be written as (n!/(r!*(n-r)!) ) mod which is equivalent to (n!*inverse(r!)*inverse((n-r)!) ) mod p. So, precomputing factorial of numbers from 1 to n will allow queries to be answered in O(log n). The only calculation that needs to be done is calculating inverse of r! and (n-r)!. Hence overall complexity will be q*( log(n)) .
A efficient approach will be to reduce the better approach to an efficient one by precomputing the inverse of factorials. Precompute inverse of factorial in O(n) time and then queries can be answered in O(1) time. Inverse of 1 to N natural number can be computed in O(n) time using Modular multiplicative inverse. Using recursive definition of factorial, the following can be written:
n! = n * (n-1) !
taking inverse on both side 
inverse( n! ) = inverse( n ) * inverse( (n-1)! )
Since N’s maximum value is 106, precomputing values till 106 will do.
Below is the implementation of the above approach:
C++
Java
Python3
C#
Javascript
// C++ program to answer queries// of nCr in O(1) time.#include <bits/stdc++.h>#define ll long longconst int N = 1000001;using namespace std; // array to store inverse of 1 to Nll factorialNumInverse[N + 1]; // array to precompute inverse of 1! to N!ll naturalNumInverse[N + 1]; // array to store factorial of first N numbersll fact[N + 1]; // Function to precompute inverse of numbersvoid InverseofNumber(ll p){    naturalNumInverse[0] = naturalNumInverse[1] = 1;    for (int i = 2; i <= N; i++)        naturalNumInverse[i] = naturalNumInverse[p % i] * (p - p / i) % p;}// Function to precompute inverse of factorialsvoid InverseofFactorial(ll p){    factorialNumInverse[0] = factorialNumInverse[1] = 1;     // precompute inverse of natural numbers    for (int i = 2; i <= N; i++)        factorialNumInverse[i] = (naturalNumInverse[i] * factorialNumInverse[i - 1]) % p;} // Function to calculate factorial of 1 to Nvoid factorial(ll p){    fact[0] = 1;     // precompute factorials    for (int i = 1; i <= N; i++) {        fact[i] = (fact[i - 1] * i) % p;    }} // Function to return nCr % p in O(1) timell Binomial(ll N, ll R, ll p){    // n C r = n!*inverse(r!)*inverse((n-r)!)    ll ans = ((fact[N] * factorialNumInverse[R])              % p * factorialNumInverse[N - R])             % p;    return ans;} // Driver Codeint main(){    // Calling functions to precompute the    // required arrays which will be required    // to answer every query in O(1)    ll p = 1000000007;    InverseofNumber(p);    InverseofFactorial(p);    factorial(p);     // 1st query    ll N = 15;    ll R = 4;    cout << Binomial(N, R, p) << endl;     // 2nd query    N = 20;    R = 3;    cout << Binomial(N, R, p) << endl;     return 0;}
// Java program to answer queries// of nCr in O(1) timeimport java.io.*; class GFG{     static int N = 1000001;  // Array to store inverse of 1 to Nstatic long[] factorialNumInverse = new long[N + 1]; // Array to precompute inverse of 1! to N!static long[] naturalNumInverse = new long[N + 1]; // Array to store factorial of first N numbersstatic long[] fact = new long[N + 1]; // Function to precompute inverse of numberspublic static void InverseofNumber(int p){    naturalNumInverse[0] = naturalNumInverse[1] = 1;         for(int i = 2; i <= N; i++)        naturalNumInverse[i] = naturalNumInverse[p % i] *                                 (long)(p - p / i) % p;} // Function to precompute inverse of factorialspublic static void InverseofFactorial(int p){    factorialNumInverse[0] = factorialNumInverse[1] = 1;     // Precompute inverse of natural numbers    for(int i = 2; i <= N; i++)        factorialNumInverse[i] = (naturalNumInverse[i] *                           factorialNumInverse[i - 1]) % p;} // Function to calculate factorial of 1 to Npublic static void factorial(int p){    fact[0] = 1;     // Precompute factorials    for(int i = 1; i <= N; i++)    {        fact[i] = (fact[i - 1] * (long)i) % p;    }} // Function to return nCr % p in O(1) timepublic static long Binomial(int N, int R, int p){         // n C r = n!*inverse(r!)*inverse((n-r)!)    long ans = ((fact[N] * factorialNumInverse[R]) %                       p * factorialNumInverse[N - R]) % p;         return ans;} // Driver codepublic static void main (String[] args){         // Calling functions to precompute the    // required arrays which will be required    // to answer every query in O(1)    int p = 1000000007;    InverseofNumber(p);    InverseofFactorial(p);    factorial(p);         // 1st query    int n = 15;    int R = 4;    System.out.println(Binomial(n, R, p));         // 2nd query    n = 20;    R = 3;    System.out.println(Binomial(n, R, p));}} // This code is contributed by RohitOberoi
# Python3 program to answer queries# of nCr in O(1) time.N = 1000001 # array to store inverse of 1 to NfactorialNumInverse = [None] * (N + 1) # array to precompute inverse of 1! to N!naturalNumInverse = [None] * (N + 1) # array to store factorial of# first N numbersfact = [None] * (N + 1) # Function to precompute inverse of numbersdef InverseofNumber(p):    naturalNumInverse[0] = naturalNumInverse[1] = 1    for i in range(2, N + 1, 1):        naturalNumInverse[i] = (naturalNumInverse[p % i] *                                   (p - int(p / i)) % p) # Function to precompute inverse# of factorialsdef InverseofFactorial(p):    factorialNumInverse[0] = factorialNumInverse[1] = 1     # precompute inverse of natural numbers    for i in range(2, N + 1, 1):        factorialNumInverse[i] = (naturalNumInverse[i] *                                  factorialNumInverse[i - 1]) % p # Function to calculate factorial of 1 to Ndef factorial(p):    fact[0] = 1     # precompute factorials    for i in range(1, N + 1):        fact[i] = (fact[i - 1] * i) % p # Function to return nCr % p in O(1) timedef Binomial(N, R, p):         # n C r = n!*inverse(r!)*inverse((n-r)!)    ans = ((fact[N] * factorialNumInverse[R])% p *                      factorialNumInverse[N - R])% p    return ans # Driver Codeif __name__ == '__main__':         # Calling functions to precompute the    # required arrays which will be required    # to answer every query in O(1)    p = 1000000007    InverseofNumber(p)    InverseofFactorial(p)    factorial(p)     # 1st query    N = 15    R = 4    print(Binomial(N, R, p))     # 2nd query    N = 20    R = 3    print(Binomial(N, R, p)) # This code is contributed by# Surendra_Gangwar
// C# program to answer queries // of nCr in O(1) timeusing System; class GFG{     static int N = 1000001;   // Array to store inverse of 1 to N static long[] factorialNumInverse = new long[N + 1];    // Array to precompute inverse of 1! to N! static long[] naturalNumInverse = new long[N + 1];   // Array to store factorial of first N numbers static long[] fact = new long[N + 1];    // Function to precompute inverse of numbers static void InverseofNumber(int p) {     naturalNumInverse[0] = naturalNumInverse[1] = 1;            for(int i = 2; i <= N; i++)         naturalNumInverse[i] = naturalNumInverse[p % i] *                                 (long)(p - p / i) % p; }    // Function to precompute inverse of factorials static void InverseofFactorial(int p) {     factorialNumInverse[0] = factorialNumInverse[1] = 1;        // Precompute inverse of natural numbers     for(int i = 2; i <= N; i++)         factorialNumInverse[i] = (naturalNumInverse[i] *                             factorialNumInverse[i - 1]) % p; }    // Function to calculate factorial of 1 to N static void factorial(int p) {     fact[0] = 1;        // Precompute factorials     for(int i = 1; i <= N; i++)    {         fact[i] = (fact[i - 1] * (long)i) % p;     } }    // Function to return nCr % p in O(1) time static long Binomial(int N, int R, int p) {            // n C r = n!*inverse(r!)*inverse((n-r)!)     long ans = ((fact[N] * factorialNumInverse[R]) %                        p * factorialNumInverse[N - R]) % p;            return ans; } // Driver codestatic void Main(){         // Calling functions to precompute the     // required arrays which will be required     // to answer every query in O(1)     int p = 1000000007;     InverseofNumber(p);     InverseofFactorial(p);     factorial(p);            // 1st query     int n = 15;     int R = 4;     Console.WriteLine(Binomial(n, R, p));           // 2nd query     n = 20;     R = 3;     Console.WriteLine(Binomial(n, R, p));}} // This code is contributed by divyeshrabadiya07
<script> // Javascript program to answer queries// of nCr in O(1) time.var N = 1000001; // array to store inverse of 1 to NfactorialNumInverse = Array(N+1).fill(0); // array to precompute inverse of 1! to N!naturalNumInverse = Array(N+1).fill(0); // array to store factorial of first N numbersfact = Array(N+1).fill(0); // Function to precompute inverse of numbersfunction InverseofNumber(p){    naturalNumInverse[0] = naturalNumInverse[1] = 1;    for (var i = 2; i <= N; i++)        naturalNumInverse[i] = (naturalNumInverse[p % i] * (p - parseInt(p / i))) % p;} // Function to precompute inverse of factorialsfunction InverseofFactorial(p){    factorialNumInverse[0] = factorialNumInverse[1] = 1;     // precompute inverse of natural numbers    for (var i = 2; i <= N; i++)        factorialNumInverse[i] = ((naturalNumInverse[i] * factorialNumInverse[i - 1])) % p;} // Function to calculate factorial of 1 to Nfunction factorial(p){    fact[0] = 1;     // precompute factorials    for (var i = 1; i <= N; i++) {        fact[i] = (fact[i - 1] * i) % p;    }} // Function to return nCr % p in O(1) timefunction Binomial(N, R, p){     // n C r = n!*inverse(r!)*inverse((n-r)!)    var ans = ((((fact[N] * factorialNumInverse[R])% p) * factorialNumInverse[N - R]))% p;    return ans;} // Driver Code // Calling functions to precompute the// required arrays which will be required// to answer every query in O(1)p = 100000007;InverseofNumber(p);InverseofFactorial(p);factorial(p); // 1st queryN = 15;R = 4;document.write(Binomial(N, R, p)+"<br>") // 2nd queryN = 20;R = 3;document.write(Binomial(N, R, p)); // This code is contributed by noob2000.</script>
1365
1140
Time Complexity: O(N) for precomputing and O(1) for every query.Auxiliary Space: O(N) 
SURENDRA_GANGWAR
RohitOberoi
divyeshrabadiya07
noob2000
pankajsharmagfg
surinderdawra388
binomial coefficient
factorial
Modular Arithmetic
Permutation and Combination
Prime Number
Algorithms
Prime Number
Modular Arithmetic
factorial
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
DSA Sheet by Love Babbar
SDE SHEET - A Complete Guide for SDE Preparation
What is Hashing | A Complete Tutorial
Understanding Time Complexity with Simple Examples
CPU Scheduling in Operating Systems
Find if there is a path between two vertices in an undirected graph
A* Search Algorithm
What is Algorithm | Introduction to Algorithms
Analysis of Algorithms | Set 2 (Worst, Average and Best Cases)
Analysis of Algorithms | Set 3 (Asymptotic Notations)