Count all possible pairs in given Array with product K

• Difficulty Level : Medium
• Last Updated : 28 Feb, 2022

Given an integer array arr[] of size N and a positive integer K, the task is to count all the pairs in the array with a product equal to K.

Examples:

Input: arr[] = {1, 2, 16, 4, 4, 4, 8 }, K=16
Output: 5
Explanation: Possible pairs are (1, 16), (2, 8), (4, 4), (4, 4), (4, 4)

Input: arr[] = {1, 10, 20, 10, 4, 5, 5, 2 }, K=20
Output: 5
Explanation: Possible pairs are (1, 20), (2, 10), (2, 10), (4, 5), (4, 5)

Approach: The idea is to use hashing to store the elements and check if K/arr[i] exists in the array or not using the map and increase the count accordingly.

Follow the steps below to solve the problem:

• Initialize the variable count as 0 to store the answer.
• Initialize the unordered_map<int, int> mp[].
• Iterate over the range [0, N) using the variable i and store the frequencies of all elements of the array arr[] in the map mp[].
• Iterate over the range [0, N) using the variable i and perform the following tasks:
• Initialize the variable index as K/arr[i].
• If K is not a power of 2 and index is present in map mp[] then increase the value of count by mp[arr[i]]*mp[index] and erase both of them from the map mp[].
• If K is a power of 2 and index is present in map mp[] then increase the value of count by mp[index]*(mp[index]-1)/2 and erase it from the map mp[].
• After performing the above steps, print the value of count as the answer.

Below is the implementation of the above approach.

C++14

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count``// the total number of pairs``int` `countPairsWithProductK(``    ``int` `arr[], ``int` `n, ``int` `k)` `{` `    ``int` `count = 0;` `    ``// Initialize hashmap.``    ``unordered_map<``int``, ``int``> mp;` `    ``// Insert array elements to hashmap``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``mp[arr[i]]++;``    ``}` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``double` `index = 1.0 * k / arr[i];` `        ``// If k is not power of two``        ``if` `(index >= 0``            ``&& ((index - (``int``)(index)) == 0)``            ``&& mp.find(k / arr[i]) != mp.end()``            ``&& (index != arr[i])) {` `            ``count += mp[arr[i]] * mp[index];` `            ``// After counting erase the element``            ``mp.erase(arr[i]);` `            ``mp.erase(index);``        ``}` `        ``// If k is power of 2``        ``if` `(index >= 0``            ``&& ((index - (``int``)(index)) == 0)``            ``&& mp.find(k / arr[i]) != mp.end()``            ``&& (index == arr[i])) {` `            ``// Pair count``            ``count += (mp[arr[i]]``                      ``* (mp[arr[i]] - 1))``                     ``/ 2;` `            ``// After counting erase the element;``            ``mp.erase(arr[i]);``        ``}``    ``}` `    ``return` `count;``}` `// Driver Code``int` `main()` `{` `    ``int` `arr[] = { 1, 2, 16, 4, 4, 4, 8 };` `    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `K = 16;` `    ``cout << countPairsWithProductK(arr, N, K);` `    ``return` `0;``}`

Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `  ``// Function to count``  ``// the total number of pairs``  ``static` `int` `countPairsWithProductK(``    ``int` `arr[], ``int` `n, ``int` `k)` `  ``{` `    ``int` `count = ``0``;` `    ``// Initialize hashmap.``    ``HashMap mp = ``new` `HashMap();` `    ``// Insert array elements to hashmap``    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``if``(mp.containsKey(arr[i])){``        ``mp.put(arr[i], mp.get(arr[i])+``1``);``      ``}``else``{``        ``mp.put(arr[i], ``1``);``      ``}``    ``}` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``int` `index = (``int``) (``1.0` `* k / arr[i]);` `      ``// If k is not power of two``      ``if` `(index >= ``0``          ``&& ((index - (``int``)(index)) == ``0``)``          ``&& mp.containsKey(k / arr[i])``          ``&& (index != arr[i])) {` `        ``count += mp.get(arr[i]) * mp.get(index);` `        ``// After counting erase the element``        ``mp.remove(arr[i]);` `        ``mp.remove(index);``      ``}` `      ``// If k is power of 2``      ``if` `(index >= ``0``          ``&& ((index - (``int``)(index)) == ``0``)``          ``&& mp.containsKey(k / arr[i])``          ``&& (index == arr[i])) {` `        ``// Pair count``        ``count += (mp.get(arr[i])``                  ``* (mp.get(arr[i]) - ``1``))``          ``/ ``2``;` `        ``// After counting erase the element;``        ``mp.remove(arr[i]);``      ``}``    ``}` `    ``return` `count;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``int` `arr[] = { ``1``, ``2``, ``16``, ``4``, ``4``, ``4``, ``8` `};``    ``int` `N = arr.length;``    ``int` `K = ``16``;``    ``System.out.print(countPairsWithProductK(arr, N, K));` `  ``}``}` `// This code is contributed by 29AjayKumar`

Python3

 `# Python 3 program for the above approach``from` `collections ``import` `defaultdict` `# Function to count``# the total number of pairs``def` `countPairsWithProductK(arr, n, k):` `    ``count ``=` `0` `    ``# Initialize hashmap.``    ``mp ``=` `defaultdict(``int``)` `    ``# Insert array elements to hashmap``    ``for` `i ``in` `range``(n):` `        ``mp[arr[i]] ``+``=` `1` `    ``for` `i ``in` `range``(n):` `        ``index ``=` `1.0` `*` `k ``/` `arr[i]` `        ``# If k is not power of two``        ``if` `(index >``=` `0``            ``and` `((index ``-` `(``int``)(index)) ``=``=` `0``)``            ``and` `(k ``/` `arr[i]) ``in` `mp``                ``and` `(index !``=` `arr[i])):` `            ``count ``+``=` `mp[arr[i]] ``*` `mp[index]` `            ``# After counting erase the element``            ``del` `mp[arr[i]]` `            ``del` `mp[index]` `        ``# If k is power of 2``        ``if` `(index >``=` `0``            ``and` `((index ``-` `(``int``)(index)) ``=``=` `0``)``            ``and` `(k ``/` `arr[i]) ``in` `mp``                ``and` `(index ``=``=` `arr[i])):` `            ``# Pair count``            ``count ``+``=` `((mp[arr[i]]``                       ``*` `(mp[arr[i]] ``-` `1``)) ``/` `2``)` `            ``# After counting erase the element;``            ``del` `mp[arr[i]]` `    ``return` `count` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``arr ``=` `[``1``, ``2``, ``16``, ``4``, ``4``, ``4``, ``8``]` `    ``N ``=` `len``(arr)` `    ``K ``=` `16` `    ``print``(``int``(countPairsWithProductK(arr, N, K)))` `    ``# This code is contributed by ukasp.`

C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG{` `  ``// Function to count``  ``// the total number of pairs``  ``static` `int` `countPairsWithProductK(``    ``int` `[]arr, ``int` `n, ``int` `k)` `  ``{` `    ``int` `count = 0;` `    ``// Initialize hashmap.``    ``Dictionary<``int``,``int``> mp = ``new` `Dictionary<``int``,``int``>();` `    ``// Insert array elements to hashmap``    ``for` `(``int` `i = 0; i < n; i++) {` `      ``if``(mp.ContainsKey(arr[i])){``        ``mp[arr[i]] = mp[arr[i]]+1;``      ``}``else``{``        ``mp.Add(arr[i], 1);``      ``}``    ``}` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``int` `index = (``int``) (1.0 * k / arr[i]);` `      ``// If k is not power of two``      ``if` `(index >= 0``          ``&& ((index - (``int``)(index)) == 0)``          ``&& mp.ContainsKey(k / arr[i])``          ``&& (index != arr[i])) {` `        ``count += mp[arr[i]] * mp[index];` `        ``// After counting erase the element``        ``mp.Remove(arr[i]);` `        ``mp.Remove(index);``      ``}` `      ``// If k is power of 2``      ``if` `(index >= 0``          ``&& ((index - (``int``)(index)) == 0)``          ``&& mp.ContainsKey(k / arr[i])``          ``&& (index == arr[i])) {` `        ``// Pair count``        ``count += (mp[arr[i]]``                  ``* (mp[arr[i]] - 1))``          ``/ 2;` `        ``// After counting erase the element;``        ``mp.Remove(arr[i]);``      ``}``    ``}` `    ``return` `count;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{` `    ``int` `[]arr = { 1, 2, 16, 4, 4, 4, 8 };``    ``int` `N = arr.Length;``    ``int` `K = 16;``    ``Console.Write(countPairsWithProductK(arr, N, K));` `  ``}``}` `// This code is contributed by Rajput-Ji`

Javascript

 ``

Output
`5`

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

My Personal Notes arrow_drop_up