Binary Exponentiation for Competitive Programming
Last Updated : 14 May, 2024
In competitive programming, we often need to do a lot of big number calculations fast. Binary exponentiation is like a super shortcut for doing powers and can make programs faster. This article will show you how to use this powerful trick to enhance your coding skills.
What is Binary Exponentiation?
Binary Exponentiation or Exponentiation by squaring is the process of calculating a number raised to the power another number (AB) in Logarithmic time of the exponent or power, which speeds up the execution time of the program.
Why to Use Binary Exponentiation?
Whenever we need to calculate (AB), we can simple calculate the result by taking the result as 1 and multiplying A for exactly B times. The time complexity for this approach is O(B) and will fail when values of B in order of 108 or greater. This is when we can use Binary exponentiation because it can calculate the result in O(log(B)) time complexity, so we can easily calculate the results for larger values of B in order of 1018 or less.
Idea Behind Binary Exponentiation:
When we are calculating (AB), we can have 3 possible positive values of B:
- Case 1: If B = 0, whatever be the value of A, our result will be 1.
- Case 2: If B is an even number, then instead of calculating (AB), we can calculate ((A2)B/2) and the result will be same.
- Case 3: If B is an odd number, then instead of calculating (AB), we can calculate (A * (A(B - 1)/2)2),
Examples:
2 12 = (2) 2 * 6
= (4) 6
= (4) 2 * 3
= (16) 3
= 16 * (16) 2
= 16 * (256) 1
Recursive Implementation of Binary Exponentiation:
C++ #include <bits/stdc++.h> using namespace std; long long power(long long A, long long B) { if (B == 0) return 1; long long res = power(A, B / 2); if (B % 2) return res * res * A; else return res * res; } int main() { cout << power(2, 12) << "\n"; return 0; } import java.io.*; class GFG { static long power(long A, long B) { if (B == 0) return 1; long res = power(A, B / 2); if (B % 2 == 1) return res * res * A; else return res * res; } public static void main(String[] args) { System.out.println(power(2, 12)); } } //This code is contributed by Rohit Singh def power(A, B): if B == 0: return 1 res = power(A, B // 2) if B % 2: return res * res * A else: return res * res if __name__ == "__main__": print(power(2, 12))
using System; class Program { // Recursive function to calculate the power of a number (A^B) static long Power(long A, long B) { // Base case: A^0 is always 1 if (B == 0) return 1; // Recursive calculation of A^(B/2) long res = Power(A, B / 2); // Multiply the result by itself res *= res; // If B is odd, multiply by A one more time if (B % 2 != 0) res *= A; return res; } static void Main() { // Example: Calculate and print the result of 2^12 Console.WriteLine(Power(2, 12)); } } // Function to calculate the power of a number A raised to the power of B function power(A, B) { if (B === 0) { return 1; } let res = power(A, Math.floor(B / 2)); if (B % 2 === 1) { return res * res * A; } else { return res * res; } } // Driver code console.log(power(2, 12)); Iterative Implementation of Binary Exponentiation:
C++ #include <bits/stdc++.h> using namespace std; long long power(long long a, long long b) { long long result = 1; while(b) { if (b & 1) result = result * a; a = a * a; b >>= 1; } return result; } int main() { cout<<power(2, 12)<<"\n"; return 0; } public class Main { public static long power(long a, long b) { long result = 1; while (b > 0) { if ((b & 1) == 1) { result *= a; } a *= a; b >>= 1; } return result; } public static void main(String[] args) { System.out.println(power(2, 12)); } } def power(a, b): result = 1 while b: if b & 1: result = result * a a = a * a b >>= 1 return result if __name__ == "__main__": print(power(2, 12))
using System; class Program { // Function to calculate power static long Power(long a, long b) { long result = 1; while (b > 0) { if ((b & 1) == 1) result *= a; a *= a; b >>= 1; } return result; } static void Main() { Console.WriteLine(Power(2, 12)); } } // Function to calculate the power of a number function power(a, b) { let result = 1; while (b > 0) { // If b is odd, multiply result by a if (b & 1) { result *= a; } // Square a a *= a; // Divide b by 2 using bitwise right shift b >>= 1; } return result; } // Main function function main() { // Output the result of power(2, 12) console.log(power(2, 12)); } // Call the main function main(); Even though, both the iterative and recursive approach have the same time complexity, the iterative approach is still faster because there are no overheads for recursive calls.
Use Cases of Binary Exponentiation in Competitive Programming:
1. Fast Computation of Nth Fibonacci Number:
We can compute Nth Fibonacci Number by simply running a loop till N and in every iteration i, we calculate the ith Fibonacci number using (i-1)th and (i-2)th iteration. But this approach runs in linear time complexity, that is O(N). But, if we are concerned with simply the Nth Fibonacci number and not every number before it, then we can compute it in O(logN) by using matrix exponentiation, where we build a 2⨯2 matrix to transition from (i-2)th and (i-1)th Fibonacci number to (i-1)th and ith Fibonacci number.
Click here to expand your knowledge about Matrix Exponentiation
2. Compute a large number modulo M:
It is hardly to see any problem which is all about to compute AB, but Binary Exponentiation comes in handy when our answer becomes too large to be stored as an integer, that is greater than INT_MAX. There are many problems which asks us to count the number of ways to do something and as the number of ways are too large to be stored in an Integer variable, the question asks us to print the answer modulo 1000000007 or modulo 998244353. Since, it is proved here, that
(A * B) mod M = ((A mod M) * (B mod M)) mod M
Therefore, Binary Exponentiation is very useful in computing AB mod M.
C++ #include <bits/stdc++.h>; using namespace std; const int mod = 1e9 + 7; long long power(long long a, long long b) { long long result = 1; while (b) { if (b & 1) result = (result * a) % mod; a = (a * a) % mod; b >>= 1; } return result; } int main() { cout << power(2, 42) << "\n"; return 0; } import java.util.*; public class Main { // Constant representing the modulo value static final int mod = 1000000007; // Function to calculate the power of a number (a) raised to the power of b modulo mod public static long power(long a, long b) { long result = 1; while (b > 0) { // If the current bit of b is set, multiply the result by a if ((b & 1) == 1) result = (result * a) % mod; // Square the value of a and reduce it modulo mod a = (a * a) % mod; // Right shift b to move to the next bit b >>= 1; } return result; } public static void main(String[] args) { // Output the result of 2^42 modulo mod System.out.println(power(2, 42)); } } # Python Implementation mod = 10**9 + 7 def power(a, b): result = 1 while b: if b & 1: result = (result * a) % mod a = (a * a) % mod b >>= 1 return result print(power(2, 42)) # This code is contributed by Sakshi
using System; class Program { const int mod = 1000000007; static long power(long a, long b) { long result = 1; while (b > 0) { if ((b & 1) == 1) result = (result * a) % mod; a = (a * a) % mod; b >>= 1; } return result; } static void Main() { Console.WriteLine(power(2, 42)); } } //this code is contributed by Aman. // Function to calculate the power of a number (a) raised to the power of b modulo mod function power(a, b) { const mod = 1000000007; let result = 1; while (b > 0) { // If the current bit of b is set, multiply the result by a and take modulo mod if (b & 1) result = (result * a) % mod; // Square the value of a and reduce it modulo mod a = (a * a) % mod; // Right shift b to move to the next bit b >>= 1; } return result; } // Output the result of 2^42 modulo mod console.log(power(2, 42)); 3. Apply Permutation of a given Sequence large number of times:
Let's suppose, we are given a Permutation P and a Sequence S and we need to apply P to S for a large number of times (say K), then we can easily compute the final sequence by using Binary Exponentiation.
Examples:
P = [2, 3, 4, 1], S = [2, 1, 3, 4]
After applying permutation P to Sequence S once,
S' = [1, 3, 4, 2]
Explanation:
S'[1] = S[P[1]] = S[2] = 1
S'[2] = S[P[2]] = S[3] = 3
S'[3] = S[P[3]] = S[4] = 4
S'[4] = S[P[4]] = S[1] = 2
After applying permutation P to Sequence S twice,
S'' = [3, 4, 2, 1]
Explanation:
S''[1] = S'[P[1]] = S'[2] = S[P[2]] = S[3] = 3
S''[2] = S'[P[2]] = S'[3] = S[P[3]] = S[4] = 4
S''[3] = S'[P[3]] = S'[4] = S[P[4]] = S[1] = 2
S''[4] = S'[P[4]] = S'[1] = S[P[1]] = S[2] = 1
Observations: If we observe carefully, in the above example instead of applying permutation P to S twice, if we apply permutation P in itself (P') and then apply it on S once, we will get the same result.
P = [2, 3, 4, 1], S = [2, 1, 3, 4]
After applying permutation P to itself once,
P' = [3, 4, 1, 2]
Explanation:
P'[1] = P[P[1]] = P[2] = 3
P'[2] = P[P[2]] = P[3] = 4
P'[3] = P[P[3]] = P[4] = 1
P'[4] = P[P[4]] = P[1] = 2
Now, applying permutation P' to S,
S''[1] = S[P'[1]] = S[3] = 3
S''[2] = S[P'[2]] = S[4] = 4
S''[3] = S[P'[3]] = S[1] = 2
S''[4] = S[P'[4]] = S[2] = 1
Therefore, it is clear that applying a permutation P to a sequence S for N times is equal to applying permutation P' to sequence S for N/2 times and we can simply solve this using Binary Exponentiation:
C++ #include <bits/stdc++.h> using namespace std; // binary exponentiation void apply(vector<int>& S, vector<int>& P) { vector<int> temp(S.size()); for (int i = 1; i < S.size(); i++) { temp[i] = S[P[i]]; } for (int i = 1; i < S.size(); i++) S[i] = temp[i]; } // Function to apply Permutation P to Sequence S // K number of times void solve(vector<int>& S, vector<int>& P, int K) { while (K) { if (K & 1) apply(S, P); apply(P, P); K >>= 1; } } int main() { vector<int> P{ 0, 2, 3, 4, 1 }; vector<int> S{ 0, 2, 1, 3, 4 }; int K = 2; solve(S, P, K); cout << "New Sequence = "; for (int i = 1; i < S.size(); i++) cout << S[i] << " "; return 0; } import java.util.Arrays; public class BinaryExponentiation { // Binary exponentiation static void apply(int[] S, int[] P) { int[] temp = Arrays.copyOf(S, S.length); for (int i = 1; i < S.length; i++) { temp[i] = S[P[i]]; } System.arraycopy(temp, 1, S, 1, S.length - 1); } // Function to apply Permutation P to Sequence S // K number of times static void solve(int[] S, int[] P, int K) { while (K > 0) { if ((K & 1) == 1) { apply(S, P); } apply(P, P); K >>= 1; } } public static void main(String[] args) { int[] P = {0, 2, 3, 4, 1}; int[] S = {0, 2, 1, 3, 4}; int K = 2; solve(S, P, K); System.out.print("New Sequence = "); for (int i = 1; i < S.length; i++) { System.out.print(S[i] + " "); } } } # Binary exponentiation def apply(S, P): temp = [0] * len(S) for i in range(1, len(S)): temp[i] = S[P[i]] for i in range(1, len(S)): S[i] = temp[i] # Function to apply Permutation P to Sequence S K number of times def solve(S, P, K): while K: if K & 1: apply(S, P) apply(P, P) K >>= 1 if __name__ == "__main__": P = [0, 2, 3, 4, 1] S = [0, 2, 1, 3, 4] K = 2 solve(S, P, K) print("New Sequence =", end=" ") for i in range(1, len(S)): print(S[i], end=" ") // Function to apply permutation P to sequence S // K number of times function solve(S, P, K) { // Helper function to apply permutation P to sequence S function apply(S, P) { const temp = Array(S.length); for (let i = 1; i < S.length; i++) { temp[i] = S[P[i]]; } for (let i = 1; i < S.length; i++) { S[i] = temp[i]; } } // Perform binary exponentiation to optimize // the application of permutations while (K > 0) { if (K & 1) { apply(S, P); } apply(P, P); K >>= 1; } } // Main function function main() { // Initial sequence S and permutation P const P = [0, 2, 3, 4, 1]; const S = [0, 2, 1, 3, 4]; const K = 2; // Number of times to apply permutation P to sequence S // Apply permutation P to sequence S K times solve(S, P, K); // Output the new sequence process.stdout.write("New Sequence = "); for (let i = 1; i < S.length; i++) { process.stdout.write(S[i] + " "); } } // Call the main function to execute the program main(); OutputNew Sequence = 3 4 2 1
Complexity Analysis:
- Brute Force: O(N * K)
- Binary Exponentiation: O(N * logK)
4. Compute Product of 2 very Large Numbers Modulo M:
If we have 2 very large number A and B and we need no compute (A * B) mod M but (A * B) in 64-bit integer, then we can use the concept of binary exponentiation to compute the product of these 2 numbers by adding A to the answer B times.
When we are calculating (A * B), we can have 3 possible positive values of B:
Case 1: If B = 0, whatever be the value of A, our result will be 0.
Case 2: If B is an even number, then instead of calculating (A * B) mod M , we can calculate (((A * 2) mod M) * B/2) mod M and the result will be same.
Case 3: If B is an odd number, then instead of calculating (A * B), we can calculate (A + A * (B-1)) mod M, which is same as case 2.
We can recursively follow the above steps to get our result.
Examples:
(25 * 10) mod 60 = ((25 * 2) mod 60 * 5) mod 60
= ((50 mod 60) * 5) mod 60
= (50 + (50 mod 60) * 4) mod 60
= (50 + (100 mod 60) * 2) mod 60
= (50 + (40 mod 60) * 2) mod 60
= (50 + (80 mod 60)) mod 60
= (50 + 20) mod 60
= 10
Therefore, we can compute (A * B) mod M using Binary Exponentiation:
C++ #include <bits/stdc++.h> using namespace std; const int mod = 1e9 + 7; // function to multiply to very large numbers int multiply(int A, int B) { int ans = 0; while(B) { if(B & 1) { ans = (ans + A) % mod; } A = (A + A) % mod; B >>= 1; } return ans; } int main() { int A = 1e9, B = 1e9; cout << multiply(A, B); return 0; } import java.math.BigInteger; public class Main { // Modulo constant static final BigInteger MOD = new BigInteger("1000000007"); // Function to multiply two very large numbers static BigInteger multiply(BigInteger A, BigInteger B) { BigInteger ans = BigInteger.ZERO; while (!B.equals(BigInteger.ZERO)) { if (B.and(BigInteger.ONE).equals(BigInteger.ONE)) { ans = (ans.add(A)).mod(MOD); } A = (A.add(A)).mod(MOD); B = B.shiftRight(1); } return ans; } public static void main(String[] args) { BigInteger A = new BigInteger("1000000000"); BigInteger B = new BigInteger("1000000000"); System.out.println(multiply(A, B)); } } # Function to multiply two very large numbers def multiply(A, B, mod): ans = 0 while B: if B & 1: ans = (ans + A) % mod A = (A + A) % mod B >>= 1 return ans # Main function if __name__ == "__main__": mod = 10**9 + 7 A = int(1e9) B = int(1e9) print(multiply(A, B, mod))
const mod = BigInt(1e9 + 7); // BigInt constant for the modulo operation // Function to multiply two very large numbers function multiply(A, B) { let ans = BigInt(0); // Initialize ans as BigInt while (B) { if (B & BigInt(1)) { // Bitwise AND operation, checking if the least significant bit is set ans = (ans + A) % mod; // BigInt arithmetic } A = (A + A) % mod; // BigInt arithmetic B >>= BigInt(1); // Bitwise right shift by 1 position } return ans; } // Main function function main() { const A = BigInt(1e9); // BigInt constant for A const B = BigInt(1e9); // BigInt constant for B console.log(multiply(A, B).toString()); // Output the result as string } // Call the main function main(); //this code is cintriuted by Adarsh. Complexity Analysis:
- Brute Force: O(1), but not possible for large numbers
- Binary Exponentiation: O(log B), as we have distributed the multiplication operation to a series of log(B) addition operations.
Practice Problems on Binary Exponentiation for Competitive Programming:
Easy Level Problems on Binary Exponentiation:
Medium Level Problems on Binary Exponentiation:
Hard Level Problems on Binary Exponentiation:
Related Article:
Similar Reads
Binary Exponentiation for Competitive Programming In competitive programming, we often need to do a lot of big number calculations fast. Binary exponentiation is like a super shortcut for doing powers and can make programs faster. This article will show you how to use this powerful trick to enhance your coding skills. Table of ContentWhat is Binary
15+ min read
Padovan Sequence Padovan Sequence similar to Fibonacci sequence with similar recursive structure. The recursive formula is, P(n) = P(n-2) + P(n-3) P(0) = P(1) = P(2) = 1 Fibonacci Sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55...... Spiral of squares with side lengths which follow the Fibonacci sequence. Padovan Sequ
4 min read
Count of different ways to express N as the sum of 1, 3 and 4 Given a positive integer n, the task is to count the number of ways to express n as a sum of 1, 3 and 4.Examples: Input: n = 4Output: 4Explanation: There is 4 ways to represent 4 as sum of 1, 3 and 4: (1+1+1+1), (1+3), (3+1) and (4).Input: n = 3Output: 2Explanation: There is 2 ways to represent 3 as
13 min read
Find the Nth element of the modified Fibonacci series Given two integers A and B which are the first two terms of the series and another integer N. The task is to find the Nth number using Fibonacci rule i.e. fib(i) = fib(i - 1) + fib(i - 2)Example: Input: A = 2, B = 3, N = 4 Output: 8 The series will be 2, 3, 5, 8, 13, 21, ... And the 4th element is 8
5 min read
Program to Check Geometric Progression A sequence of numbers is called a Geometric progression if the ratio of any two consecutive terms is always the same.In simple terms, A geometric series is a list of numbers where each number, or term, is found by multiplying the previous term by a common ratio r. The general form of Geometric Progr
6 min read
Carol Number A Carol number is an integer of the form 4n - 2(n+1) - 1. An equivalent formula is (2n-1)2 - 2.An Interesting Property : For n > 2, the binary representation of the n-th Carol number is n-2 consecutive one's, a single zero in the middle, and n + 1 more consecutive one's. Example, n = 4 carol numb
3 min read
Matrix Exponentiation Matrix Exponentiation is a technique used to calculate a matrix raised to a power efficiently, that is in logN time. It is mostly used for solving problems related to linear recurrences.Idea behind Matrix Exponentiation:Similar to Binary Exponentiation which is used to calculate a number raised to a
15+ min read
String hashing using Polynomial rolling hash function Given a string str of length n, your task is to find its hash value using polynomial rolling hash function.Note: If two strings are equal, their hash values should also be equal. But the inverse need not be true.Examples:Input: str = "geeksforgeeks"Output: 609871790Input: str = "polynomial"Output: 9
15+ min read
Compute nCr%p using Fermat Little Theorem Given three numbers n, r and p, compute the value of nCr mod p. Here p is a prime number greater than n. Here nCr is Binomial Coefficient.Example: Input: n = 10, r = 2, p = 13 Output: 6 Explanation: 10C2 is 45 and 45 % 13 is 6. Input: n = 6, r = 2, p = 13 Output: 2Recommended PracticenCrTry It! We h
15+ min read
Generalized Fibonacci Numbers We all know that Fibonacci numbers (Fn) are defined by the recurrence relation Fibonacci Numbers (Fn) = F(n-1) + F(n-2) with seed values F0 = 0 and F1 = 1 Similarly, we can generalize these numbers. Such a number sequence is known as Generalized Fibonacci number (G). Generalized Fibonacci number (G)
10 min read