Size of longest Divisible Subset in an Array in Java

In a given input array, the task is to find the size of the longest divisible subset. A subset is known as divisible only if, for each pair (p, q) in the subset, either p divides q (p % q = 0) or q divides p (q % p = 0).

Example 1:

Input

int arr[] = {1, 16, 7, 19, 28, 8, 4, 64, 256}

Output: 6

Explanation: Consider the subset {1, 16, 8, 4, 64, 256}. In this subset, we can make 15 (⁶C₂ = 15) pairs of elements. In any of the pairs (comprising of two elements, p and q), either p % q = 0 or q % p = 0. Also, the considered subset is the longest subset that satisfies the given condition, whose size is 6. Hence, the output is 6.

Example 2:

Input

int arr[] = {2, 2, 2, 2, 2, 2, 2}

Output: 7

Explanation: All the elements of the input array divide each other completely as, all the elements are of the same value. Therefore, the longest subset is the input array itself, whose size is 7. Hence, the output is 7.

Approach: Using Recursion

The simple approach is to generate all of the possible subsets from the given input array and then check whether the generated subsets are valid or not as per the given condition. If the subset is valid, then compare its size with the previously computed maximum size of the previously computed valid subset and update the answer accordingly. All of the subsets can be generated by excluding or including the current element in the current subset. We will be generating and validating the side of the subset by the side in the same method. Observe the following implementation.

FileName: LongestDivisibleSubset.java

// import statement required in the program
import java.util.ArrayList;

public class LongestDivisibleSubset 
{
int maxSize = 0;
// Method that displays the median of running or stream integers
public boolean isValidSubset(ArrayList<Integer> subsetArrList)
{
int s = subsetArrList.size();
boolean isValid = true;

// nested loop for generating all pairs
for(int i = 0; i < s - 1; i++)
{
for(int j = i + 1; j < s; j++)
{
if((subsetArrList.get(i) % subsetArrList.get(j) != 0) && (subsetArrList.get(j) % subsetArrList.get(i) != 0))
{
// we have got a pair that is violating the condition (p % q == 0 or q % p == 0)
// therefore, it is not required to proceed further
isValid = false;
break;
}
}

if(!isValid)
{
// terminate the outer loop too if we have got at least one 
// pair that is not abiding by the given condition
break;
}

}

return isValid;
}

// a method that generates all of the subsets and checks whether the subset is a valid
// one or not as per the required condition
public void generateSubsets(int inputArr[], int size, int i, ArrayList<Integer> subsetAL)
{
// the following if condition checks the validity of the subset
if(i >= size)
{
if(isValidSubset( subsetAL ) )
{
// if the subset is a valid one, compare its size with the maximum size of the 
// previously computed
maxSize = (maxSize > subsetAL.size()) ? maxSize : subsetAL.size();    
}
return;
}

// including the element inputArr[i] in the subsetAL and applying recursion
subsetAL.add(inputArr[i]);
generateSubsets(inputArr, size, i + 1, subsetAL);

// excluding the element inputArr[i] in the subsetAL and applying recursion
subsetAL.remove(subsetAL.size() - 1);
generateSubsets(inputArr, size, i + 1, subsetAL);
}



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

// input 1
int inputArr[] = {1, 16, 7, 19, 28, 8, 4, 64, 256};
int s = inputArr.length;

ArrayList<Integer> al = new ArrayList<Integer>();

// invoking the method generateSubsets()
obj.generateSubsets(inputArr, s, 0, al);

System.out.println("For the input array: ");
for(int i = 0; i < s; i++)
{
System.out.print(inputArr[i] + " ");
}
System.out.println( );
System.out.println("The maximum size of the longest divisible subset is: " + obj.maxSize );

System.out.println( "\n" );
obj.maxSize = 0;
al = new ArrayList<Integer>();

// input 2
int inputArr1[] = {2, 2, 2, 2, 2, 2, 2};
s = inputArr1.length;

// invoking the method generateSubsets()
obj.generateSubsets(inputArr1, s, 0, al);

System.out.println("For the input array: ");
for(int i = 0; i < s; i++)
{
System.out.print(inputArr1[i] + " ");
}
System.out.println( );
System.out.println("The maximum size of the longest divisible subset is: " + obj.maxSize );

}
}

Output:

For the input array: 
1 16 7 19 28 8 4 64 256 
The maximum size of the longest divisible subset is: 6


For the input array: 
2 2 2 2 2 2 2 
The maximum size of the longest divisible subset is: 7

Complexity Analysis: The program generates two recursive calls in each recursive call. It leads to exponential time complexity. Therefore, the time complexity of the program is O(2n). The array list that stores all of the subsets (subsetAL in our case) make the space complexity of the program exponential, which is also O(2n), where n is the total number of elements present in the input array.

The time, as well as the space complexity of the above program, is very high and is not suitable for larger inputs. Therefore, it is required to reduce both complexities.

Efficient Approach: Using Sorting

With the help of sorting, one can reduce the time as well the space complexity of the program. Observe the following steps.

Step 1: Sort all of the elements of the input array in ascending order. The reason for sorting is to ensure that all of the divisors of an element come before it.

Step 2: Create an array divisibleCount[] whose size is the same as the input array. divisibleCount[i] keeps the size of divisible subset ending with arr[i] (In the sorted array). The minimum value of divisibleCount [i] would be 1.

Step 3: Traverse all array elements. For every element, find a divisor arr[j] with the largest value of divisibleCount[j] and store the value of divisibleCount[i] as divisibleCount[j] + 1.

Observe the implementation of the above steps.

FileName: LongestDivisibleSubset1.java

// importing Arrays that is required in the 
// program
import java.util.Arrays;

public class LongestDivisibleSubset1 
{

// finds the largest subset of the input array inputArr
public int findLargest(int[] inputArr) 
{
// computing the size
int size = inputArr.length;
Arrays.sort(inputArr); // sorting the array
// array for maintaining the max index
// up to which the condition is maintained
int divisibleCount[] = new int[inputArr.length];

// an element is always divisible
// by itself
Arrays.fill(divisibleCount, 1);

// the last increment index is maintained
int prevArr[] = new int[inputArr.length];
Arrays.fill(prevArr, -1);

// index where the last increment occurred
int maxInd = 0;

for (int j = 1; j < inputArr.length; j++) 
{
for (int k = 0; k < j; k++) 
{

// only increment the maximum index if
// this iteration will increase it
if (inputArr[j] % inputArr[k] == 0 &&
divisibleCount[j] < divisibleCount[k] + 1) 
{
prevArr[j] = k;
divisibleCount[j] = divisibleCount[k] + 1;

}

}
// Updating the last index of the longest subset if the
// current subset size is more.
if (divisibleCount[j] > divisibleCount[maxInd])
{
maxInd = j;
}
}

int k = maxInd;

// a variable that stores the required answer
int countSubsetEle = 0;
while (k >= 0) 
{
countSubsetEle = countSubsetEle + 1;

// picking the elements of the longest subset
k = prevArr[k];
}

// returning the final answer
return countSubsetEle;

}

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

// input 1
int inputArr[] = {1, 16, 7, 19, 28, 8, 4, 64, 256};
int s = inputArr.length; // size of the input array



System.out.println("For the input array: ");
for(int i = 0; i < s; i++)
{
System.out.print(inputArr[i] + " ");
}
System.out.println( );

// invoking the method findLargest( )
int ans = obj.findLargest(inputArr);

System.out.println("The maximum size of the longest divisible subset is: " + ans );

System.out.println( "\n" );

// input 2
int inputArr1[] = {2, 2, 2, 2, 2, 2, 2};
s = inputArr1.length; // size of the input array

System.out.println("For the input array: ");
for(int i = 0; i < s; i++)
{
System.out.print(inputArr1[i] + " ");
}
System.out.println( );

// invoking the method findLargest( )
ans = obj.findLargest(inputArr1);

System.out.println("The maximum size of the longest divisible subset is: " + ans );

}
}

Output:

For the input array: 
1 16 7 19 28 8 4 64 256 
The maximum size of the longest divisible subset is: 6


For the input array: 
2 2 2 2 2 2 2 
The maximum size of the longest divisible subset is: 7

Complexity Analysis: The program is using two nested-for loops, which makes the time complexity of the program O(n²). The program is also using auxiliary arrays for finding the result, which makes the space complexity of the program O(n), where n is the total number of elements present in the input array.

Next TopicThree-way operator | Ternary operator in Java

← prev next →