Related Articles

# Find the Largest divisor Subset in the Array

• Difficulty Level : Medium
• Last Updated : 05 Jun, 2021

Given an array arr[] of N integers, the task is to find the largest subset of arr[] such that in every pair of numbers from that subset, one number is a divisor of the other.
Examples:

Input: arr[] = {1, 2, 3, 4, 5}
Output: 4 2 1
All possible pairs of the subsequence are:
(4, 2) -> 4 % 2 = 0
(4, 1) -> 4 % 1 = 0
and (2, 1) -> 2 % 1 = 0
Input: arr[] = {1, 3, 4, 9}
Output: 1 3 9

Approach: Here the task is to find the largest subset where in every pair of numbers, one is divisible by the other i.e. for the sequence a1, a2, a3 … ak where a1 ≤ a2 ≤ … ≤ ak and ai+1 % ai = 0 for every i. This sequence can be found using dynamic programming (similar to longest increasing subsequence).
Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;` `// Function to find the required subsequence``void` `findSubSeq(``int` `arr[], ``int` `n)``{` `    ``// Sort the array``    ``sort(arr, arr + n);` `    ``// Keep a count of the length of the``    ``// subsequence and the previous element``    ``int` `count[n] = { 1 };``    ``int` `prev[n] = { -1 };` `    ``// Set the initial values``    ``memset``(count, 1, ``sizeof``(count));``    ``memset``(prev, -1, ``sizeof``(prev));` `    ``// Maximum length of the subsequence and``    ``// the last element``    ``int` `max = 0;``    ``int` `maxprev = -1;` `    ``// Run a loop for every element``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// Check for all the divisors``        ``for` `(``int` `j = i - 1; j >= 0; j--) {` `            ``// If the element is a divisor and the length``            ``// of subsequence will increase by adding``            ``// j as previous element of i``            ``if` `(arr[i] % arr[j] == 0``                ``&& count[j] + 1 > count[i]) {` `                ``// Increase the count``                ``count[i] = count[j] + 1;``                ``prev[i] = j;``            ``}``        ``}` `        ``// Update the max count``        ``if` `(max < count[i]) {``            ``max = count[i];``            ``maxprev = i;``        ``}``    ``}` `    ``// Get the last index of the subsequence``    ``int` `i = maxprev;``    ``while` `(i >= 0) {` `        ``// Print the element``        ``if` `(arr[i] != -1)``            ``cout << arr[i] << ``" "``;` `        ``// Move the index to the previous element``        ``i = prev[i];``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 1, 2, 3, 4, 5 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(``int``);` `    ``findSubSeq(arr, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.*;``class` `GFG``{``    ` `    ``// Function to find the required subsequence``    ``static` `void` `findSubSeq(``int` `arr[], ``int` `n)``    ``{``    ` `        ``// Sort the array``        ``Arrays.sort(arr);``    ` `        ``// Keep a count of the length of the``        ``// subsequence and the previous element``        ``int` `count[] = ``new` `int``[n];``        ``int` `prev[] = ``new` `int``[n];``    ` `        ``int` `i, j;``        ` `        ``// Set the initial values``        ``for``(i = ``0` `; i < n; i++)``        ``count[i] = ``1``;``        ` `        ``for``(j = ``0``; j < n; j++)``            ``prev[j] = -``1``;``    ` `        ``// Maximum length of the subsequence and``        ``// the last element``        ``int` `max = ``0``;``        ``int` `maxprev = -``1``;``    ` `        ``// Run a loop for every element``        ``for` `( i = ``0``; i < n; i++)``        ``{``    ` `            ``// Check for all the divisors``            ``for` `( j = i - ``1``; j >= ``0``; j--)``            ``{``    ` `                ``// If the element is a divisor and``                ``// the length of subsequence will``                ``// increase by adding j as``                ``// previous element of i``                ``if` `(arr[i] % arr[j] == ``0` `&&``                    ``count[j] + ``1` `> count[i])``                ``{``    ` `                    ``// Increase the count``                    ``count[i] = count[j] + ``1``;``                    ``prev[i] = j;``                ``}``            ``}``    ` `            ``// Update the max count``            ``if` `(max < count[i])``            ``{``                ``max = count[i];``                ``maxprev = i;``            ``}``        ``}``    ` `        ``// Get the last index of the subsequence``        ``i = maxprev;``        ``while` `(i >= ``0``)``        ``{``    ` `            ``// Print the element``            ``if` `(arr[i] != -``1``)``                ``System.out.print(arr[i] + ``" "``);``    ` `            ``// Move the index to the previous element``            ``i = prev[i];``        ``}``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `arr[] = { ``1``, ``2``, ``3``, ``4``, ``5` `};``        ``int` `n = arr.length;``    ` `        ``findSubSeq(arr, n);``    ``}``}` `// This code is contributed by AnkitRai01`

## Python3

 `# Python3 implementation of the approach` `# Function to find the required subsequence``def` `findSubSeq(arr, n) :` `    ``# Sort the array``    ``arr.sort();` `    ``# Keep a count of the length of the``    ``# subsequence and the previous element``    ``# Set the initial values``    ``count ``=` `[``1``] ``*` `n;``    ``prev ``=` `[``-``1``] ``*` `n;` `    ``# Maximum length of the subsequence and``    ``# the last element``    ``max` `=` `0``;``    ``maxprev ``=` `-``1``;` `    ``# Run a loop for every element``    ``for` `i ``in` `range``(n) :` `        ``# Check for all the divisors``        ``for` `j ``in` `range``(i ``-` `1``, ``-``1``, ``-``1``) :` `            ``# If the element is a divisor and the length``            ``# of subsequence will increase by adding``            ``# j as previous element of i``            ``if` `(arr[i] ``%` `arr[j] ``=``=` `0` `and``                ``count[j] ``+` `1` `> count[i]) :` `                ``# Increase the count``                ``count[i] ``=` `count[j] ``+` `1``;``                ``prev[i] ``=` `j;` `        ``# Update the max count``        ``if` `(``max` `< count[i]) :``            ``max` `=` `count[i];``            ``maxprev ``=` `i;``            ` `    ``# Get the last index of the subsequence``    ``i ``=` `maxprev;``    ``while` `(i >``=` `0``) :` `        ``# Print the element``        ``if` `(arr[i] !``=` `-``1``) :``            ``print``(arr[i], end ``=` `" "``);` `        ``# Move the index to the previous element``        ``i ``=` `prev[i];` `# Driver code``if` `__name__ ``=``=` `"__main__"` `:` `    ``arr ``=` `[ ``1``, ``2``, ``3``, ``4``, ``5` `];``    ``n ``=` `len``(arr);` `    ``findSubSeq(arr, n);``    ` `# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the approach``using` `System;``using` `System.Collections;` `class` `GFG``{``    ` `    ``// Function to find the required subsequence``    ``static` `void` `findSubSeq(``int` `[]arr, ``int` `n)``    ``{``    ` `        ``// Sort the array``        ``Array.Sort(arr);``    ` `        ``// Keep a count of the length of the``        ``// subsequence and the previous element``        ``int` `[]count = ``new` `int``[n];``        ``int` `[]prev = ``new` `int``[n];``    ` `        ``int` `i, j;``        ` `        ``// Set the initial values``        ``for``(i = 0; i < n; i++)``        ``count[i] = 1;``        ` `        ``for``(j = 0; j < n; j++)``            ``prev[j] = -1;``    ` `        ``// Maximum length of the subsequence ``        ``// and the last element``        ``int` `max = 0;``        ``int` `maxprev = -1;``    ` `        ``// Run a loop for every element``        ``for` `( i = 0; i < n; i++)``        ``{``    ` `            ``// Check for all the divisors``            ``for` `( j = i - 1; j >= 0; j--)``            ``{``    ` `                ``// If the element is a divisor and``                ``// the length of subsequence will``                ``// increase by adding j as``                ``// previous element of i``                ``if` `(arr[i] % arr[j] == 0 &&``                    ``count[j] + 1 > count[i])``                ``{``    ` `                    ``// Increase the count``                    ``count[i] = count[j] + 1;``                    ``prev[i] = j;``                ``}``            ``}``    ` `            ``// Update the max count``            ``if` `(max < count[i])``            ``{``                ``max = count[i];``                ``maxprev = i;``            ``}``        ``}``    ` `        ``// Get the last index of the subsequence``        ``i = maxprev;``        ``while` `(i >= 0)``        ``{``    ` `            ``// Print the element``            ``if` `(arr[i] != -1)``                ``Console.Write(arr[i] + ``" "``);``    ` `            ``// Move the index to the previous element``            ``i = prev[i];``        ``}``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main ()``    ``{``        ``int` `[]arr = { 1, 2, 3, 4, 5 };``        ``int` `n = arr.Length;``    ` `        ``findSubSeq(arr, n);``    ``}``}` `// This code is contributed by AnkitRai01`

## Javascript

 ``
Output:
`4 2 1`

Time Complexity: O(N2)

Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up