Skip to content
Related Articles

Related Articles

Generate an N-length array having GCD of all its pairs present in a given 2D array

View Discussion
Improve Article
Save Article
  • Last Updated : 30 Jul, 2021
View Discussion
Improve Article
Save Article

Given a 2D array arr[][] consisting of N*N positive integers, the task is to generate an N-length array such that Greatest Common Divisors(GCD) of all possible pairs of that array is present in the array arr[][].

Examples:

Input: N = 4, arr[] = {2, 1, 2, 3, 4, 3, 2, 6, 1, 1, 2, 2, 1, 2, 3, 2}
Output: 4, 3, 6, 2
Explanation:
Considering the array A[] as {4, 3, 6, 2}, then the GCD of all possible pairs of this array is given below which is the given array arr[].
{{4, 1, 2, 2},
{1, 3, 3, 1},
{2, 3, 6, 2},
{2, 1, 2, 2}}

Input: N = 1, mat = {100}
Output: 100

Approach: The above problem can be solved by using the fact that, GCD of the largest element in the original array with itself is the largest in the arr[] and after removing the gcd pairs with that element, the next element can be found. Follow the steps below to solve the given problem:

  • Initialize a map say, M store the frequency of negation of array element in the map M.
  • Initialize a variable, say pos as (N – 1).
  • Now, for all array elements arr[] find the maximum element.
  • Traverse the map M.
  • For each element of the original array, find the element with the maximum frequency and store it in the ans.
  • Find ans[pos] and remove all GCD from pos+1 to N-1 of the ans.
  • Update pos as pos-1.
  • Repeat above steps to find all elements of the original array.
  • Finally, print the ans.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
int n;
  
// Function to calculate GCD of two numbers
int gcd(int a, int b)
{
    return b == 0 ? a : gcd(b, a % b);
}
  
// Function to generate an N-length
// array having GCD of all pairs
// present in the array mat[][]
void restoreArray(vector<int> mat)
{
    map<int, int> cnt;
  
    // Stores the required array
    vector<int> ans(n);
  
    for (int i = 0; i < (n * n); ++i) {
  
        // Store frequencies in map
        // in decreasing order
        cnt[-mat[i]]++;
    }
  
    int pos = n - 1;
  
    for (auto it = cnt.begin();
         it != cnt.end(); ++it) {
  
        int x = -it->first;
        while (it->second) {
  
            // gcd(x, x)
            ans[pos] = x;
            --it->second;
  
            // Remove all GCDs for
            // indices pos + 1 -> n - 1
            for (int i = pos + 1; i < n; ++i)
  
                cnt[-gcd(ans[pos], ans[i])] -= 2;
  
            // Decreasing pos
            pos--;
        }
    }
  
    // Print restored array
    for (int i = 0; i < n; ++i)
        printf("%d ", ans[i]);
}
  
// Driver Code
int main()
{
  
    // Given Input
    n = 4;
    vector<int> mat{ 2, 1, 2, 3, 4, 3,
                     2, 6, 1, 1, 2,
                     2, 1, 2, 3, 2 };
  
    // Function Call
    restoreArray(mat);
    return 0;
}

Output:

2 3 4 6

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


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!