GCD of Different SubSequences in Java

An array inArr of the positive numbers is given. The task is to find the number of the various GCD (Greatest Common Divisor) in all of the subsequences that are present in the input array that is unique. Note subsequence of an array is made by taking any one or more than one element at a time.

Example 1:

Input

int inArr[] = {6, 8, 10}

Output: 4

Explanation: The different subsequences of the input array and their GCD are:

For subsequence {6}, the GCD is 6.

For subsequence {8}, the GCD is 8.

For subsequence {10}, the GCD 10.

For subsequence {6, 8}, GCD is 2.

For subsequence {8, 10}, GCD is 2.

For subsequence {6, 10}, GCD is 2.

For subsequence {6, 8, 10}, GCD is 2.

Thus, all the computed GCDs are 6, 8, 10, 2, 2, 2, 2, out of which only 4 are unique (6, 8, 10, 2). Hence, the output is 4.

Example 2:

Input

int inArr[] = {2, 4, 8}

Output: 3

Explanation: The different subsequences of the input array and their GCD are:

For subsequence {2}, the GCD is 2.

For subsequence {4}, the GCD is 4.

For subsequence {8}, the GCD 8.

For subsequence {2, 4}, GCD is 2.

For subsequence {4, 8}, GCD is 4.

For subsequence {2, 8}, GCD is 2.

For subsequence {2, 4, 8}, GCD is 2.

Thus, all the computed GCDs are 2, 4, 8, 2, 4, 2, 2, out of which only 3 are unique (2, 4, 8). Hence, the output is 3.

Approach: Brute Force

In this approach, we will be computing all of the subsequences of the input array and will store those subsequences in an array list. Then, we will compute the GCD of all of the subsequences that are stored in the array list and will put them in a set. As the set only contains unique elements, the size of the set will be our answer. For finding the subsequences, we will be using recursion. Observe the following program.

FileName: DiffSubseqGCD.java

// important import statements
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;


public class DiffSubseqGCD 
{
ArrayList<ArrayList<Integer>> al = new ArrayList<ArrayList<Integer>>();
Set<Integer> st = new HashSet<Integer>();

public void findSubseq(int arr[], int size, int i, ArrayList<Integer> temp) 
{
// handling the base case
if(i >= size)
{

// adding elements to the 2-d array list
ArrayList<Integer> t = new ArrayList<Integer>();
for(int idx = 0; idx < temp.size(); idx++)
{
t.add(temp.get(idx));
}
al.add(t);
return;
}

temp.add(arr[i]);
// including the elements in the temp subarray list
findSubseq(arr, size, i + 1, temp);
int index = temp.size() - 1;
temp.remove(index);
// ignoring the elements in the temp subarray list
findSubseq(arr, size, i + 1, temp);
}

// method for finding the GCD of the two
// numbers a1 and a2 recursively
public int findGCD(int a1, int a2)
{
// handling the base case
if(a1 == 0)
{
return a2;
}

// recursively finding the GCD of two numbers a1 and a2
return findGCD(a2 % a1, a1);
}

public void findGCDSubSeq(ArrayList<Integer> al1)
{
// if the array list is empty
// there is no need to find the GCD
if(al1.size() == 0)
{
return;
}

// For only one element in the array list
// the GCD is considered to be the element itself
if(al1.size() == 1)
{

st.add(al1.get(0));
return;
}


int t1 = al1.get(0);
int t2 = al1.get(1);
int t = findGCD(t1, t2);
for(int i = 2; i < al1.size(); i++)
{
t = findGCD(t, al1.get(i));
}

st.add(t);
}
public void findGCDUtil()
{
int size = al.size();

for(int i = 0; i < size; i++)
{
findGCDSubSeq(al.get(i));
}
}
// main method
public static void main(String argvs[])
{
// creating an object of the class DiffSubseqGCD 
DiffSubseqGCD obj = new DiffSubseqGCD();
// input 1
int inArr[] = {6, 8, 10};
int size = inArr.length;
ArrayList<Integer> temp = new ArrayList<Integer>();
obj.findSubseq(inArr, size, 0, temp);
obj.findGCDUtil();
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(inArr[i] + " ");
}
System.out.println();
System.out.println("The total number of unique GCDs is: " + obj.st.size());
System.out.println();
obj.st = new HashSet<Integer>();
obj.al = new ArrayList<ArrayList<Integer>>();
// input 2
int inArr1[] = {2, 4, 8};
size = inArr1.length;
temp = new ArrayList<Integer>();
obj.findSubseq(inArr1, size, 0, temp);
obj.findGCDUtil();
System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(inArr1[i] + " ");
}
System.out.println();
System.out.println("The total number of unique GCDs is: " + obj.st.size());
}
}

Output:

For the input array: 
6 8 10 
The total number of unique GCDs is: 4

For the input array: 
2 4 8 
The total number of unique GCDs is: 3

Complexity Analysis: Each recursively calls leads to two more recursive calls. Thus, the time complexity of the program is exponential. The space complexity of the program is also exponential.

The above program is not suitable for the larger inputs as the time as well as space complexity of the program is too high. Therefore, we must do some optimization to reduce the time complexity and space complexity.

Efficient Approach:

Using the greedy approach, we can do the optimization. We have to use the fact that the GCD of any two numbers n1 and n2 lies between 1 to a maximum of (n1, n2), and the same concept is valid for any subsequence containing more than two elements. If the maximum element in a subsequence is M, then the GCD will always fall within the range [1, M]. Thus, we can do an iteration from 1 to M, and any number in the given range is a factor of an element of the array, then we can display that element as one of the outcomes of the GCD.

FileName: DiffSubseqGCD1.java

// important import statements
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;

public class DiffSubseqGCD1 
{
// method for finding the GCD of the two
// numbers a1 and a2 recursively
public int findGCD(int a1, int a2)
{
// handling the base case
if(a1 == 0)
{
return a2;
}

// recursively finding the GCD of two numbers a1 and a2
return findGCD(a2 % a1, a1);
}

// A method for finding the different GCDs
public int findGCDsSubseq(ArrayList<Integer> arrList)
{

// for storing all the GCDs that are possible
ArrayList<Integer> answer = new ArrayList<Integer>();

// Stores all array elements in set
HashSet<Integer> hs = new HashSet<Integer>();
for(int i = 0; i < arrList.size(); i++)
{
hs.add(arrList.get(i));
}

int Max = Integer.MIN_VALUE;
for(int i = 0; i < arrList.size(); i++)
{
if (arrList.get(i) > Max)
{
Max = arrList.get(i);
}
}   

// Iterating from 1 to M
for(int j = 1; j <= Max; j++)
{
int computeGCD = 0;

// Checking whether k could be the GCD of any of the subsequence if i can be the GCD of
// any subsequence
for(int k = j; k < Max + 1; k += j)
{
if (hs.contains(k))
{
computeGCD = findGCD(computeGCD, k);
}
}
if (computeGCD == j)
{
answer.add(j);
}
}
return answer.size();
}


// main method
public static void main(String argvs[])
{
// creating an object of the class DiffSubseqGCD1 
DiffSubseqGCD1 obj = new DiffSubseqGCD1();

// input 1
ArrayList<Integer> arrList = new ArrayList<Integer>();
arrList.add(6);
arrList.add(8);
arrList.add(10);
int size = arrList.size();
int answer = obj.findGCDsSubseq(arrList);

System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(arrList.get(i) + " ");
}
System.out.println();
System.out.println("The total number of unique GCDs is: " + answer);


System.out.println();

// input 2
ArrayList<Integer> arrList1 = new ArrayList<Integer>();
arrList1.add(2);
arrList1.add(4);
arrList1.add(8);
size = arrList1.size();
answer = obj.findGCDsSubseq(arrList1);

System.out.println("For the input array: ");
for(int i = 0; i < size; i++)
{
System.out.print(arrList1.get(i) + " ");
}
System.out.println();
System.out.println("The total number of unique GCDs is: " + answer);

}

}

Output:

For the input array: 
6 8 10 
The total number of unique GCDs is: 4

For the input array: 
2 4 8 
The total number of unique GCDs is: 3

Complexity Analysis: The time complexity of the program is O(Max * log(Max)), where Max is the maximum element of the array. The space complexity of the program is O(N), where N is the total number of elements present in the array list.

Next TopicSylvester Sequence in Java

← prev next →