# Size of the largest divisible subset in an Array

• Last Updated : 26 Dec, 2022

Given an array arr[] of size N. The task is to find the size of the set of numbers from the given array such that each number divides another or is divisible by another.
Examples:

Input : arr[] = {3, 4, 6, 8, 10, 18, 21, 24}
Output :
One of the possible sets with a maximum size is {3, 6, 18}

Input : arr[] = {2, 3, 4, 8, 16}
Output : 4

Approach:

1. Let’s take all the numbers in increasing order.
2. Note that set X = xi, …, ?xk} is acceptable iff xi divides xi+1 for (1 â‰¤ i â‰¤ k – 1).
3. Therefore, dp[x] is equal to the length of the longest suitable increasing subsequence starting at the number x.
4. DP Relation: dp[x] = max(dp[x], 1 + dp[y]) if x divides y.

Below is the implementation of the above approach:

## CPP

 `// C++ implementation of the above approach``#include ``using` `namespace` `std;` `#define N 1000005` `// Function to find the size of the``//largest divisible subarray``int` `maximum_set(``int` `a[], ``int` `n)``{``    ``int` `dp[N] = { 0 };` `    ``// Mark all elements of the array``    ``for` `(``int` `i = 0; i < n; i++)``        ``dp[a[i]] = 1;` `    ``int` `ans = 1;` `    ``// Traverse reverse``    ``for` `(``int` `i = N - 1; i >= 1; i--) {` `        ``if` `(dp[i] != 0) {``            ``// For all multiples of i``            ``for` `(``int` `j = 2 * i; j < N; j += i) {``                ``dp[i] = max(dp[i], 1 + dp[j]);``                ``ans = max(ans, dp[i]);``            ``}``        ``}``    ``}` `    ``// Return the required answer``    ``return` `ans;``}` `// Driver code``int` `main()``{``    ``int` `arr[] = { 3, 4, 6, 8, 10, 18, 21, 24 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``cout << maximum_set(arr, n);` `    ``return` `0;``}`

## Java

 `// Java implementation of the above approach``class` `GFG``{``    ` `    ``final` `static` `int` `N = ``1000005` `;``    ` `    ``// Function to find the size of the``    ``//largest divisible subarray``    ``static` `int` `maximum_set(``int` `a[], ``int` `n)``    ``{``        ``int` `dp[] = ``new` `int``[N] ;``    ` `        ``// Mark all elements of the array``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``dp[a[i]] = ``1``;``    ` `        ``int` `ans = ``1``;``    ` `        ``// Traverse reverse``        ``for` `(``int` `i = N - ``1``; i >= ``1``; i--)``        ``{``    ` `            ``if` `(dp[i] != ``0``)``            ``{``                ``// For all multiples of i``                ``for` `(``int` `j = ``2` `* i; j < N; j += i)``                ``{``                    ``dp[i] = Math.max(dp[i], ``1` `+ dp[j]);``                    ``ans = Math.max(ans, dp[i]);``                ``}``            ``}``        ``}``    ` `        ``// Return the required answer``        ``return` `ans;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `arr[] = { ``3``, ``4``, ``6``, ``8``, ``10``, ``18``, ``21``, ``24` `};``    ` `        ``int` `n = arr.length;``    ` `        ``// Function call``        ``System.out.println(maximum_set(arr, n));``    ``}``}` `// This code is contributed by AnkitRai01`

## Python

 `# Python3 implementation of the above approach` `N ``=` `1000005` `# Function to find the size of the``# largest divisible subarray``def` `maximum_set(a, n):``    ``dp ``=` `[``0` `for` `i ``in` `range``(N)]` `    ``# Mark all elements of the array``    ``for` `i ``in` `a:``        ``dp[i] ``=` `1` `    ``ans ``=` `1` `    ``# Traverse reverse``    ``for` `i ``in` `range``(N ``-` `1``, ``0``, ``-``1``):` `        ``if` `(dp[i] !``=` `0``):``            ` `            ``# For all multiples of i``            ``for` `j ``in` `range``(``2` `*` `i, N, i):``                ``dp[i] ``=` `max``(dp[i], ``1` `+` `dp[j])``                ``ans ``=` `max``(ans, dp[i])` `    ``# Return the required answer``    ``return` `ans` `# Driver code` `arr ``=` `[``3``, ``4``, ``6``, ``8``, ``10``, ``18``, ``21``, ``24``]` `n ``=` `len``(arr)` `# Function call``print``(maximum_set(arr, n))` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of the above approach``using` `System;` `class` `GFG``{``    ``static` `int` `N = 1000005 ;``    ` `    ``// Function to find the size of the``    ``//largest divisible subarray``    ``static` `int` `maximum_set(``int` `[]a, ``int` `n)``    ``{``        ``int` `[]dp = ``new` `int``[N] ;``    ` `        ``// Mark all elements of the array``        ``for` `(``int` `i = 0; i < n; i++)``            ``dp[a[i]] = 1;``    ` `        ``int` `ans = 1;``    ` `        ``// Traverse reverse``        ``for` `(``int` `i = N - 1; i >= 1; i--)``        ``{``    ` `            ``if` `(dp[i] != 0)``            ``{``                ``// For all multiples of i``                ``for` `(``int` `j = 2 * i; j < N; j += i)``                ``{``                    ``dp[i] = Math.Max(dp[i], 1 + dp[j]);``                    ``ans = Math.Max(ans, dp[i]);``                ``}``            ``}``        ``}``    ` `        ``// Return the required answer``        ``return` `ans;``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int` `[]arr = { 3, 4, 6, 8, 10, 18, 21, 24 };``        ``int` `n = arr.Length;``    ` `        ``// Function call``        ``Console.WriteLine(maximum_set(arr, n));``    ``}``}` `// This code is contributed by AnkitRai01`

## Javascript

 ``

Output:

`3`

Time Complexity: O(n*sqrt(n))
Auxiliary Space: O(n), where n is the size of the given array.

My Personal Notes arrow_drop_up