Skip to content
Related Articles
Count pairs whose product modulo 10^9 + 7 is equal to 1
• Last Updated : 21 Jan, 2021

Given an array arr[], the task is to count the number of unordered pairs (arr[i], arr[j]) from the given array such that (arr[i] * arr[j]) % 109 + 7 is equal to 1.

Example:

Input: arr[] = {2, 236426, 280311812, 500000004}
Output: 2
Explanation: Two such pairs from the given array are:

1. (2 * 500000004) % 1000000007 = 1
2. (236426 * 280311812) % 1000000007 = 1

Input: arr[] = {4434, 923094278, 6565}
Output: 1

Naive Approach: The simplest approach to solve the problem is to traverse the array and generate all possible pairs from the given array. For each pair, calculate their product modulo 109 + 7. If it is found to be equal to 1, increase count of such pairs. Finally, print the final count obtained.

Time Complexity: O(N2
Auxiliary Space: O(N)

Efficient Approach: To optimize the above approach, use the property that if (arr[i] * arr[j]) % 1000000007 =1, then arr[j] is modular inverse of arr[i] under modulo 109 + 7 which is always unique. Follow the steps given below to solve the problem:

• Initialize a Map hash, to store the frequencies of each element in the array arr[].
• Initialize a variable pairCount, to store the count of required pairs.
• Traverse the array and calculate modularInverse which is inverse of arr[i] under 109 + 7 and increase pairCount by hash[modularInverse] and decrease the count of pairCount by 1, if modularInverse is found to be equal to arr[i].
• Finally, print pairCount / 2 as the required answer as every pair has been counted twice by the above approach.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;``#define MOD 1000000007` `// Iterative Function to calculate (x^y) % MOD``long` `long` `int` `modPower(``long` `long` `int` `x,``                       ``long` `long` `int` `y)``{``    ``// Initialize result``    ``long` `long` `int` `res = 1;` `    ``// Update x if it exceeds MOD``    ``x = x % MOD;` `    ``// If x is divisible by MOD``    ``if` `(x == 0)``        ``return` `0;` `    ``while` `(y > 0) {` `        ``// If y is odd``        ``if` `(y & 1)` `            ``// Multiply x with res``            ``res = (res * x) % MOD;` `        ``// y must be even now``        ``y = y / 2;``        ``x = (x * x) % MOD;``    ``}``    ``return` `res;``}` `// Function to count number of pairs``// whose product modulo 1000000007 is 1``int` `countPairs(``long` `long` `int` `arr[], ``int` `N)``{``    ``// Stores the count of``    ``// desired pairs``    ``int` `pairCount = 0;` `    ``// Stores the frequencies of``    ``// each array element``    ``map<``long` `long` `int``, ``int``> hash;` `    ``// Traverse the array and update``    ``// frequencies in hash``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``hash[arr[i]]++;``    ``}` `    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Calculate modular inverse of``        ``// arr[i] under modulo 1000000007``        ``long` `long` `int` `modularInverse``            ``= modPower(arr[i], MOD - 2);` `        ``// Update desired count of pairs``        ``pairCount += hash[modularInverse];` `        ``// If arr[i] and its modular inverse``        ``// is equal under modulo MOD``        ``if` `(arr[i] == modularInverse) {` `            ``// Updating count of desired pairs``            ``pairCount--;``        ``}``    ``}` `    ``// Return the final count``    ``return` `pairCount / 2;``}` `int` `main()``{``    ``long` `long` `int` `arr[]``        ``= { 2, 236426, 280311812, 500000004 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << countPairs(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.util.*;` `class` `GFG{``    ` `static` `final` `int` `MOD = ``1000000007``;` `// Iterative Function to calculate (x^y) % MOD``static` `long` `modPower(``long` `x, ``int` `y)``{``    ` `    ``// Initialize result``    ``long` `res = ``1``;` `    ``// Update x if it exceeds MOD``    ``x = x % MOD;` `    ``// If x is divisible by MOD``    ``if` `(x == ``0``)``        ``return` `0``;` `    ``while` `(y > ``0``)``    ``{``        ` `        ``// If y is odd``        ``if` `(y % ``2` `== ``1``)``        ` `            ``// Multiply x with res``            ``res = (res * x) % MOD;` `        ``// y must be even now``        ``y = y / ``2``;``        ``x = (x * x) % MOD;``    ``}``    ``return` `res;``}` `// Function to count number of pairs``// whose product modulo 1000000007 is 1``static` `int` `countPairs(``long` `arr[], ``int` `N)``{``    ` `    ``// Stores the count of``    ``// desired pairs``    ``int` `pairCount = ``0``;` `    ``// Stores the frequencies of``    ``// each array element``    ``HashMap hash = ``new` `HashMap<>();` `    ``// Traverse the array and update``    ``// frequencies in hash``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ``if` `(hash.containsKey(arr[i]))``        ``{``            ``hash.put(arr[i], hash.get(arr[i]) + ``1``);``        ``}``        ``else``        ``{``            ``hash.put(arr[i], ``1``);``        ``}``    ``}``    ` `    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Calculate modular inverse of``        ``// arr[i] under modulo 1000000007``        ``long` `modularInverse = modPower(arr[i],``                                       ``MOD - ``2``);` `        ``// Update desired count of pairs``        ``if` `(hash.containsKey(modularInverse))``            ``pairCount += hash.get(modularInverse);``        ` `        ``// If arr[i] and its modular inverse``        ``// is equal under modulo MOD``        ``if` `(arr[i] == modularInverse)``        ``{``            ` `            ``// Updating count of desired pairs``            ``pairCount--;``        ``}``    ``}` `    ``// Return the final count``    ``return` `pairCount / ``2``;``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``long` `arr[] = { ``2``, ``236426``, ``280311812``, ``500000004` `};``    ``int` `N = arr.length;` `    ``System.out.print(countPairs(arr, N));``}``}` `// This code is contributed by Amit Katiyar`

## Python3

 `# Python3 program to implement``# the above approach``from` `collections ``import` `defaultdict``MOD ``=` `1000000007` `# Iterative Function to``# calculate (x^y) % MOD``def` `modPower(x, y):` `    ``# Initialize result``    ``res ``=` `1` `    ``# Update x if it exceeds``    ``# MOD``    ``x ``=` `x ``%` `MOD` `    ``# If x is divisible by``    ``# MOD``    ``if` `(x ``=``=` `0``):``        ``return` `0` `    ``while` `(y > ``0``):` `        ``# If y is odd``        ``if` `(y & ``1``):` `            ``# Multiply x with res``            ``res ``=` `(res ``*` `x) ``%` `MOD` `        ``# y must be even now``        ``y ``=` `y ``/``/` `2``        ``x ``=` `(x ``*` `x) ``%` `MOD` `    ``return` `res` `# Function to count number``# of pairs whose product``# modulo 1000000007 is 1``def` `countPairs(arr, N):` `    ``# Stores the count of``    ``# desired pairs``    ``pairCount ``=` `0` `    ``# Stores the frequencies of``    ``# each array element``    ``hash1 ``=` `defaultdict(``int``)` `    ``# Traverse the array and``    ``# update frequencies in hash``    ``for` `i ``in` `range``(N):``        ``hash1[arr[i]] ``+``=` `1` `    ``for` `i ``in` `range``(N):` `        ``# Calculate modular inverse``        ``# of arr[i] under modulo``        ``# 1000000007``        ``modularInverse ``=` `modPower(arr[i],``                                  ``MOD ``-` `2``)` `        ``# Update desired count of pairs``        ``pairCount ``+``=` `hash1[modularInverse]` `        ``# If arr[i] and its modular``        ``# inverse is equal under``        ``# modulo MOD``        ``if` `(arr[i] ``=``=` `modularInverse):` `            ``# Updating count of``            ``# desired pairs``            ``pairCount ``-``=` `1` `    ``# Return the final count``    ``return` `pairCount ``/``/` `2` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``2``, ``236426``,``           ``280311812``,``           ``500000004``]``    ``N ``=` `len``(arr)``    ``print``(countPairs(arr, N))` `# This code is contributed by Chitranayal`

## C#

 `// C# program to implement``// the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `static` `int` `MOD = 1000000007;` `// Iterative Function to calculate (x^y) % MOD``static` `long` `modPower(``long` `x, ``int` `y)``{``    ` `    ``// Initialize result``    ``long` `res = 1;` `    ``// Update x if it exceeds MOD``    ``x = x % MOD;` `    ``// If x is divisible by MOD``    ``if` `(x == 0)``        ``return` `0;` `    ``while` `(y > 0)``    ``{``        ` `        ``// If y is odd``        ``if` `(y % 2 == 1)``        ` `            ``// Multiply x with res``            ``res = (res * x) % MOD;` `        ``// y must be even now``        ``y = y / 2;``        ``x = (x * x) % MOD;``    ``}``    ``return` `res;``}` `// Function to count number of pairs``// whose product modulo 1000000007 is 1``static` `int` `countPairs(``long` `[]arr, ``int` `N)``{``    ` `    ``// Stores the count of``    ``// desired pairs``    ``int` `pairCount = 0;` `    ``// Stores the frequencies of``    ``// each array element``    ``Dictionary<``long``,``               ``int``> hash = ``new` `Dictionary<``long``,``                                          ``int``>();` `    ``// Traverse the array and update``    ``// frequencies in hash``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ``if` `(hash.ContainsKey(arr[i]))``        ``{``            ``hash.Add(arr[i], hash[arr[i]] + 1);``        ``}``        ``else``        ``{``            ``hash.Add(arr[i], 1);``        ``}``    ``}``    ` `    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Calculate modular inverse of``        ``// arr[i] under modulo 1000000007``        ``long` `modularInverse = modPower(arr[i],``                                       ``MOD - 2);` `        ``// Update desired count of pairs``        ``if` `(hash.ContainsKey(modularInverse))``            ``pairCount += hash[modularInverse];``        ` `        ``// If arr[i] and its modular inverse``        ``// is equal under modulo MOD``        ``if` `(arr[i] == modularInverse)``        ``{``            ` `            ``// Updating count of desired pairs``            ``pairCount--;``        ``}``    ``}` `    ``// Return the final count``    ``return` `pairCount / 2;``}` `// Driver code``public` `static` `void` `Main()``{``    ``long` `[]arr = { 2, 236426, 280311812, 500000004 };``    ``int` `N = arr.Length;` `    ``Console.WriteLine(countPairs(arr, N));``}``}` `// This code is contributed by bgangwar59`
Output:
`2`

Time Complexity: O(NlogN)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up