 Open in App
Not now

# Count distinct pair of indices in Array whose GCD and LCM are same

• Last Updated : 30 Dec, 2022

Given an array A[] of length N, the task is to find the total number of distinct pairs (i, j) of indices where 1 ≤ i < j ≤ N such that the greatest common divisor(gcd) and least common multiple(lcm) of these elements are equal.

Examples:

Input: A[] = {2, 5, 5, 5, 6}
Output:
Explanation: Here pair (i, j) are: (2, 3), (3, 4), and (2, 4).
To elaborate, gcd(A2, A3) = lcm(A2, A3) = 5.

Input: A[] = {22, 22, 38, 38}
Output: 2

Approach: The problem can be solved based on the following observation:

Observations:

• The observation to be made here is as follows: gcd(Ai, Aj) = lcm(Ai, Aj)⟺ Ai = Aj
• So, the problem reduces to simply counting the number of pairs of equal elements in A.
• Build a frequency map of the elements of A (using map/unordered_map in C++, TreeMap/Hashmap in Java, or dict in python) and then iterate across its elements.
• If an element x has a frequency of fx, then it contributes fx⋅(fx−1)/2 pairs to the answer, so sum this value across all x.

Follow the below steps to solve the problem:

• Declare a hash map.
• Start iterating over the entire array
• If the element is present in the map, then increase the value of frequency by 1.
• Otherwise, insert that element into the map.
• After that start traversing the map and get the value(frequency of element).
• If an element x has a frequency of fx, then it contributes fx⋅(fx − 1) / 2 pairs to the answer, so sum this value across all x.

Below is the implementation of the above approach:

## C++

 `// C++ code to implement the approach``#include ``using` `namespace` `std;` `long` `pairCount(``int` `arr[], ``int` `size)``{` `  ``// Function to find number of``  ``// distinct pair``  ``unordered_map<``int``, ``int``> freqMap;` `  ``for` `(``int` `i = 0; i < size; i++) {``    ``freqMap[arr[i]]++;``  ``}``  ``long` `ans = 0;` `  ``for` `(``auto` `it : freqMap) {``    ``ans += (``long``)it.second * (``long``)(it.second - 1) / 2;``  ``}``  ``return` `ans;``}` `// Driver code``int` `main()``{` `  ``// Function call``  ``int` `A[] = { 2, 5, 5, 5, 6 };``  ``int` `size = ``sizeof``(A) / ``sizeof``(A);``  ``cout << pairCount(A, size);``}` `// This code is contributed by aarohi2616.`

## Java

 `// Java code to implement the approach``import` `java.io.*;``import` `java.util.*;` `public` `class` `GFG {``    ``// Function to find number of``    ``// distinct pair``    ``public` `static` `long` `pairCount(``int` `a[], ``int` `n)``    ``{``        ``Map mp = ``new` `HashMap<>();``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(mp.containsKey(a[i])) {``                ``mp.put(a[i], mp.get(a[i]) + ``1``);``            ``}``            ``else` `{``                ``mp.put(a[i], ``1``);``            ``}``        ``}``        ``long` `ans = ``0``;``        ``for` `(``int` `i : mp.values()) {``            ``ans += (``long``)i * (``long``)(i - ``1``) / ``2``;``        ``}``        ``return` `ans;``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `A[] = { ``2``, ``5``, ``5``, ``5``, ``6` `};``        ``int` `N = A.length;` `        ``// Function call``        ``System.out.println(pairCount(A, N));``    ``}``}`

## C#

 `// C# code to implement the approach` `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `    ``// Function to find number of distinct pair``    ``public` `static` `long` `pairCount(``int``[] a, ``int` `n)``    ``{``        ``Dictionary<``int``, ``int``> mp``            ``= ``new` `Dictionary<``int``, ``int``>();``        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(mp.ContainsKey(a[i])) {``                ``mp[a[i]] += 1;``            ``}``            ``else` `{``                ``mp.Add(a[i], 1);``            ``}``        ``}``        ``long` `ans = 0;` `        ``Dictionary<``int``, ``int``>.ValueCollection valueColl``            ``= mp.Values;` `        ``foreach``(``int` `i ``in` `valueColl)``        ``{``            ``ans += (``long``)i * (``long``)(i - 1) / 2;``        ``}``        ``return` `ans;``    ``}` `    ``static` `public` `void` `Main()``    ``{` `        ``// Code``        ``int``[] A = { 2, 5, 5, 5, 6 };``        ``int` `N = A.Length;` `        ``// Function call``        ``Console.WriteLine(pairCount(A, N));``    ``}``}` `// This code is contributed by lokeshmvs21.`

## Python3

 `class` `GFG :``    ``# Function to find number of``    ``# distinct pair``    ``@staticmethod``    ``def`  `pairCount( a,  n) :``        ``mp ``=`  `dict``()``        ``i ``=` `0``        ``while` `(i < n) :``            ``if` `((a[i] ``in` `mp.keys())) :``                ``mp[a[i]] ``=` `mp.get(a[i]) ``+` `1``            ``else` `:``                ``mp[a[i]] ``=` `1``            ``i ``+``=` `1``        ``ans ``=` `0``        ``for` `i ``in` `mp.values() :``            ``ans ``+``=` `int``(i) ``*` `int``((i ``-` `1``)) ``/` `2``        ``return` `ans``      ` `    ``# Driver code``    ``@staticmethod``    ``def` `main( args) :``        ``A ``=` `[``2``, ``5``, ``5``, ``5``, ``6``]``        ``N ``=` `len``(A)``        ` `        ``# Function call``        ``print``(GFG.pairCount(A, N))``    ` `if` `__name__``=``=``"__main__"``:``    ``GFG.main([])``    ` `    ``# This code is contributed by aadityaburujwale.`

## Javascript

 `class GFG``{``    ``// Function to find number of``    ``// distinct pair``    ``static pairCount(a, n)``    ``{``        ``var` `mp = ``new` `Map();``        ``for` `(i; i < n; i++)``        ``{``            ``if` `(mp.has(a[i]))``            ``{``                ``mp.set(a[i],mp.get(a[i]) + 1);``            ``}``            ``else``            ``{``                ``mp.set(a[i],1);``            ``}``        ``}``        ``var` `ans = 0;``        ``for` `( const  i of mp.values()) {``        ``ans += parseInt(i) * parseInt((i - 1)) / 2;``}``        ``return` `ans;``    ``}``    ``// Driver code``    ``static main(args)``    ``{``        ``var` `A = [2, 5, 5, 5, 6];``        ``var` `N = A.length;``        ``// Function call``        ``console.log(GFG.pairCount(A, N));``    ``}``}``GFG.main([]);` `// This code is contributed by aadityaburujwale.`

Output

`3`

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

My Personal Notes arrow_drop_up