Related Articles
Count of pairs in an array whose product is a perfect square
• Difficulty Level : Medium
• Last Updated : 22 Jun, 2020

Given an array arr[] of N integers, the task is to find the number of pairs (arr[i], arr[j]) such that arr[i]*arr[j] is a perfect square.

Examples:

Input: arr[] = { 1, 2, 4, 8, 5, 6}
Output: 2
Explanation:
The pairs such that product of element is perfect square are (1, 4) and (8, 2).

Input: arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }
Output: 4
Explanation:
The pairs such that product of element is perfect square are (1, 4), (1, 9), (2, 8) and (4, 9).

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach:
Run two loops from 1 to n and count all the pairs (i, j) where arr[i]*arr[j] is a perfect square. The time complexity of this approach will be O(N2).

Efficient Approach:
Each integers in arr[] can be represented in following form:

```arr[i] = k*x          ..............(1)
where k is not divisible by any perfect square other than 1,
and x = perfect square,
```

Steps:

1. Represent every element in the form of equation(1).
2. Then, for every pair (arr[i], arr[j]) in arr[] can be represented as:
```arr[i] = ki*x;
arr[j] = kj*y;
where x and y are perfect square
```

For pairs (arr[i], arr[j]), product of arr[i] and arr[j] can be perfect square if and only if ki = kj

3. Use Sieve of Eratosthenes to pre compute the value of k for every element in array arr[].
4. Store the frequency of k for every element in arr[] in map.
5. Therefore, the total number of pair is given by number of pair formed by element with frequency greater than 1.
6. The total number of pairs form by n elements is given by:
```Number of Pairs = (f*(f-1))/2
where f is the frequency of an element.
```

Below is the implementation of the above approach:

## C++

 `// C++ program to calculate the number of``// pairs with product is perfect square``#include ``using` `namespace` `std;`` ` `// Prime[] array to calculate Prime Number``int` `prime = { 0 };`` ` `// Array k[] to store the value of k for``// each element in arr[]``int` `k = { 0 };`` ` `// For value of k, Sieve function is``// implemented``void` `Sieve()``{``    ``// Initialize k[i] to i``    ``for` `(``int` `i = 1; i < 100001; i++)``        ``k[i] = i;`` ` `    ``// Prime Sieve``    ``for` `(``int` `i = 2; i < 100001; i++) {`` ` `        ``// If i is prime then remove all``        ``// factors of prime from it``        ``if` `(prime[i] == 0)``            ``for` `(``int` `j = i; j < 100001; j += i) {`` ` `                ``// Update that j is not``                ``// prime``                ``prime[j] = 1;`` ` `                ``// Remove all square divisors``                ``// i.e. if k[j] is divisible``                ``// by i*i then divide it by i*i``                ``while` `(k[j] % (i * i) == 0)``                    ``k[j] /= (i * i);``            ``}``    ``}``}`` ` `// Function that return total count``// of pairs with pefect square product``int` `countPairs(``int` `arr[], ``int` `n)``{``    ``// Map used to store the frequency of k``    ``unordered_map<``int``, ``int``> freq;`` ` `    ``// Store the frequency of k``    ``for` `(``int` `i = 0; i < n; i++) {``        ``freq[k[arr[i]]]++;``    ``}`` ` `    ``int` `sum = 0;`` ` `    ``// The total number of pairs is the``    ``// summation of (fi * (fi - 1))/2``    ``for` `(``auto` `i : freq) {``        ``sum += ((i.second - 1) * i.second) / 2;``    ``}`` ` `    ``return` `sum;``}`` ` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 2, 4, 8, 5, 6 };`` ` `    ``// Size of arr[]``    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);`` ` `    ``// To pre-compute the value of k``    ``Sieve();`` ` `    ``// Function that return total count``    ``// of pairs with perfect square product``    ``cout << countPairs(arr, n) << endl;`` ` `    ``return` `0;``}`

## Java

 `// Java program to calculate the number of``// pairs with product is perfect square``import` `java.util.*;`` ` `class` `GFG{``  ` `// Prime[] array to calculate Prime Number``static` `int` `[]prime = ``new` `int``[``100001``];``  ` `// Array k[] to store the value of k for``// each element in arr[]``static` `int` `[]k = ``new` `int``[``100001``];``  ` `// For value of k, Sieve function is``// implemented``static` `void` `Sieve()``{``    ``// Initialize k[i] to i``    ``for` `(``int` `i = ``1``; i < ``100001``; i++)``        ``k[i] = i;``  ` `    ``// Prime Sieve``    ``for` `(``int` `i = ``2``; i < ``100001``; i++) {``  ` `        ``// If i is prime then remove all``        ``// factors of prime from it``        ``if` `(prime[i] == ``0``)``            ``for` `(``int` `j = i; j < ``100001``; j += i) {``  ` `                ``// Update that j is not``                ``// prime``                ``prime[j] = ``1``;``  ` `                ``// Remove all square divisors``                ``// i.e. if k[j] is divisible``                ``// by i*i then divide it by i*i``                ``while` `(k[j] % (i * i) == ``0``)``                    ``k[j] /= (i * i);``            ``}``    ``}``}``  ` `// Function that return total count``// of pairs with pefect square product``static` `int` `countPairs(``int` `arr[], ``int` `n)``{``    ``// Map used to store the frequency of k``    ``HashMap freq = ``new` `HashMap();``  ` `    ``// Store the frequency of k``    ``for` `(``int` `i = ``0``; i < n; i++) {``        ``if``(freq.containsKey(k[arr[i]])) {``            ``freq.put(k[arr[i]], freq.get(k[arr[i]])+``1``);``        ``}``        ``else``            ``freq.put(k[arr[i]], ``1``);``    ``}``  ` `    ``int` `sum = ``0``;``  ` `    ``// The total number of pairs is the``    ``// summation of (fi * (fi - 1))/2``    ``for` `(Map.Entry i : freq.entrySet()){``        ``sum += ((i.getValue() - ``1``) * i.getValue()) / ``2``;``    ``}``  ` `    ``return` `sum;``}``  ` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``1``, ``2``, ``4``, ``8``, ``5``, ``6` `};``  ` `    ``// Size of arr[]``    ``int` `n = arr.length;``  ` `    ``// To pre-compute the value of k``    ``Sieve();``  ` `    ``// Function that return total count``    ``// of pairs with perfect square product``    ``System.out.print(countPairs(arr, n) +``"\n"``);``  ` `}``}`` ` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python3 program to calculate the number  ``# of pairs with product is perfect square`` ` `# prime[] array to calculate Prime Number``prime ``=` `[``0``] ``*` `100001`` ` `# Array to store the value of k ``# for each element in arr[]``k ``=` `[``0``] ``*` `100001`` ` `# For value of k, Sieve implemented``def` `Sieve():`` ` `    ``# Initialize k[i] to i``    ``for` `i ``in` `range``(``1``, ``100001``):``        ``k[i] ``=` `i`` ` `    ``# Prime sieve``    ``for` `i ``in` `range``(``2``, ``100001``):`` ` `        ``# If i is prime then remove all``        ``# factors of prime from it``        ``if` `(prime[i] ``=``=` `0``):``            ``for` `j ``in` `range``(i, ``100001``, i):`` ` `                ``# Update that j is not prime``                ``prime[j] ``=` `1`` ` `                ``# Remove all square divisors ``                ``# i.e if k[j] is divisible by``                ``# i*i then divide it by i*i``                ``while` `(k[j] ``%` `(i ``*` `i) ``=``=` `0``):``                    ``k[j] ``/``=` `(i ``*` `i)`` ` `# Function that return total count of``# pairs with perfect square product``def` `countPairs (arr, n):`` ` `    ``# Store the frequency of k``    ``freq ``=` `dict``()`` ` `    ``for` `i ``in` `range``(n):``        ``if` `k[arr[i]] ``in` `freq.keys():``            ``freq[k[arr[i]]] ``+``=` `1``        ``else``:``            ``freq[k[arr[i]]] ``=` `1`` ` `    ``Sum` `=` `0`` ` `    ``# The total number of pairs is the ``    ``# summation of (fi * (fi - 1))/2``    ``for` `i ``in` `freq:``        ``Sum` `+``=` `(freq[i] ``*` `(freq[i] ``-` `1``)) ``/` `2`` ` `    ``return` `Sum`` ` `# Driver code ``arr ``=` `[ ``1``, ``2``, ``4``, ``8``, ``5``, ``6` `]`` ` `# Length of arr``n ``=` `len``(arr) `` ` `# To pre-compute the value of k``Sieve()`` ` `# Function that return total count ``# of pairs with perfect square product ``print``(``int``(countPairs(arr, n)))`` ` `# This code is contributed by himanshu77`

## C#

 `// C# program to calculate the number of``// pairs with product is perfect square``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG{``   ` `// Prime[] array to calculate Prime Number``static` `int` `[]prime = ``new` `int``;``   ` `// Array k[] to store the value of k for``// each element in []arr``static` `int` `[]k = ``new` `int``;``   ` `// For value of k, Sieve function is``// implemented``static` `void` `Sieve()``{``    ``// Initialize k[i] to i``    ``for` `(``int` `i = 1; i < 100001; i++)``        ``k[i] = i;``   ` `    ``// Prime Sieve``    ``for` `(``int` `i = 2; i < 100001; i++) {``   ` `        ``// If i is prime then remove all``        ``// factors of prime from it``        ``if` `(prime[i] == 0)``            ``for` `(``int` `j = i; j < 100001; j += i) {``   ` `                ``// Update that j is not``                ``// prime``                ``prime[j] = 1;``   ` `                ``// Remove all square divisors``                ``// i.e. if k[j] is divisible``                ``// by i*i then divide it by i*i``                ``while` `(k[j] % (i * i) == 0)``                    ``k[j] /= (i * i);``            ``}``    ``}``}``   ` `// Function that return total count``// of pairs with pefect square product``static` `int` `countPairs(``int` `[]arr, ``int` `n)``{``    ``// Map used to store the frequency of k``    ``Dictionary<``int``,``int``> freq = ``new` `Dictionary<``int``,``int``>();``   ` `    ``// Store the frequency of k``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if``(freq.ContainsKey(k[arr[i]])) {``            ``freq[k[arr[i]]] = freq[k[arr[i]]]+1;``        ``}``        ``else``            ``freq.Add(k[arr[i]], 1);``    ``}``   ` `    ``int` `sum = 0;``   ` `    ``// The total number of pairs is the``    ``// summation of (fi * (fi - 1))/2``    ``foreach` `(KeyValuePair<``int``,``int``> i ``in` `freq){``        ``sum += ((i.Value - 1) * i.Value) / 2;``    ``}``   ` `    ``return` `sum;``}``   ` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 1, 2, 4, 8, 5, 6 };``   ` `    ``// Size of []arr``    ``int` `n = arr.Length;``   ` `    ``// To pre-compute the value of k``    ``Sieve();``   ` `    ``// Function that return total count``    ``// of pairs with perfect square product``    ``Console.Write(countPairs(arr, n) +``"\n"``);  ``}``}`` ` `// This code is contributed by PrinciRaj1992`
Output:
```2
```

Time Complexity: O(N*log(log N))

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up