Largest divisible pairs subset

Given an array of n distinct elements, find length of the largest subset such that every pair in the subset is such that the larger element of the pair is divisible by smaller element. 

Examples:

Input : arr[] = {10, 5, 3, 15, 20} 
Output : 3 
Explanation: The largest subset is 10, 5, 20.
10 is divisible by 5, and 20 is divisible by 10.

Input : arr[] = {18, 1, 3, 6, 13, 17} 
Output : 4
Explanation: The largest subset is 18, 1, 3, 6,
In the subsequence, 3 is divisible by 1, 
6 by 3 and 18 by 6.

This can be solved using Dynamic Programming. We traverse the sorted array from the end. For every element a[i], we compute dp[i] where dp[i] indicates size of largest divisible subset where a[i] is the smallest element. We can compute dp[i] in array using values from dp[i+1] to dp[n-1]. Finally, we return the maximum value from dp[].

Below is the implementation of the above approach:  

C++

// CPP program to find the largest subset which
// where each pair is divisible.
#include <bits/stdc++.h>
using namespace std;

// function to find the longest Subsequence
int largestSubset(int a[], int n)
{
    // dp[i] is going to store size of largest
    // divisible subset beginning with a[i].
    int dp[n];

    // Since last element is largest, d[n-1] is 1
    dp[n - 1] = 1;

    // Fill values for smaller elements.
    for (int i = n - 2; i >= 0; i--) {

        // Find all multiples of a[i] and consider
        // the multiple that has largest subset
        // beginning with it.
        int mxm = 0;
        for (int j = i + 1; j < n; j++)
            if (a[j] % a[i] == 0 || a[i] % a[j] == 0)
                mxm = max(mxm, dp[j]);

        dp[i] = 1 + mxm;
    }

    // Return maximum value from dp[]
    return *max_element(dp, dp + n);
}

// driver code to check the above function
int main()
{
    int a[] = { 1, 3, 6, 13, 17, 18 };
    int n = sizeof(a) / sizeof(a[0]);
    cout << largestSubset(a, n) << endl;
    return 0;
}

Java

import java.util.Arrays;

// Java program to find the largest
// subset which was each pair
// is divisible.
class GFG {

    // function to find the longest Subsequence
    static int largestSubset(int[] a, int n)
    {
        // dp[i] is going to store size of largest
        // divisible subset beginning with a[i].
        int[] dp = new int[n];

        // Since last element is largest, d[n-1] is 1
        dp[n - 1] = 1;

        // Fill values for smaller elements.
        for (int i = n - 2; i >= 0; i--) {

            // Find all multiples of a[i] and consider
            // the multiple that has largest subset
            // beginning with it.
            int mxm = 0;
            for (int j = i + 1; j < n; j++) {
                if (a[j] % a[i] == 0 || a[i] % a[j] == 0) {
                    mxm = Math.max(mxm, dp[j]);
                }
            }

            dp[i] = 1 + mxm;
        }

        // Return maximum value from dp[]
        return Arrays.stream(dp).max().getAsInt();
    }

    // driver code to check the above function
    public static void main(String[] args)
    {
        int[] a = { 1, 3, 6, 13, 17, 18 };
        int n = a.length;
        System.out.println(largestSubset(a, n));
    }
}

/* This JAVA code is contributed by Rajput-Ji*/

Python3

# Python program to find the largest
# subset where each pair is divisible.

# function to find the longest Subsequence
def largestSubset(a, n):

    # dp[i] is going to store size
    # of largest divisible subset
    # beginning with a[i].
    dp = [0 for i in range(n)]

    # Since last element is largest,
    # d[n-1] is 1
    dp[n - 1] = 1;

    # Fill values for smaller elements
    for i in range(n - 2, -1, -1):

        # Find all multiples of a[i]
        # and consider the multiple
        # that has largest subset
        # beginning with it.
        mxm = 0;
        for j in range(i + 1, n):
            if a[j] % a[i] == 0 or a[i] % a[j] == 0:
                mxm = max(mxm, dp[j])
        dp[i] = 1 + mxm

    # Return maximum value from dp[]
    return max(dp)

# Driver Code
a = [ 1, 3, 6, 13, 17, 18 ]
n = len(a)
print(largestSubset(a, n))

# This code is contributed by
# sahil shelangia

C#

// C# program to find the largest
// subset which where each pair
// is divisible.
using System;
using System.Linq;

public class GFG {

    // function to find the longest Subsequence
    static int largestSubset(int[] a, int n)
    {
        // dp[i] is going to store size of largest
        // divisible subset beginning with a[i].
        int[] dp = new int[n];

        // Since last element is largest, d[n-1] is 1
        dp[n - 1] = 1;

        // Fill values for smaller elements.
        for (int i = n - 2; i >= 0; i--) {

            // Find all multiples of a[i] and consider
            // the multiple that has largest subset
            // beginning with it.
            int mxm = 0;
            for (int j = i + 1; j < n; j++)
                if (a[j] % a[i] == 0 | a[i] % a[j] == 0)
                    mxm = Math.Max(mxm, dp[j]);

            dp[i] = 1 + mxm;
        }

        // Return maximum value from dp[]
        return dp.Max();
    }

    // driver code to check the above function
    static public void Main()
    {
        int[] a = { 1, 3, 6, 13, 17, 18 };
        int n = a.Length;
        Console.WriteLine(largestSubset(a, n));
    }
}

// This code is contributed by vt_m.

PHP

<?php
// PHP program to find the
// largest subset which
// where each pair is
// divisible.

// function to find the
// longest Subsequence
function largestSubset($a, $n)
{
    // dp[i] is going to
    // store size of largest
    // divisible subset
    // beginning with a[i].
    $dp = array();

    // Since last element is
    // largest, d[n-1] is 1
    $dp[$n - 1] = 1;

    // Fill values for
    // smaller elements.
    for ($i = $n - 2; $i >= 0; $i--)
    {

        // Find all multiples of
        // a[i] and consider
        // the multiple that
        // has largest subset
        // beginning with it.
        $mxm = 0;
        for ($j = $i + 1; $j < $n; $j++)
            if ($a[$j] % $a[$i] == 0 or $a[$i] % $a[$j] == 0)
                $mxm = max($mxm, $dp[$j]);

        $dp[$i] = 1 + $mxm;
    }

    // Return maximum value
    // from dp[]
    return max($dp);
}

    // Driver Code
    $a = array(1, 3, 6, 13, 17, 18);
    $n = count($a);
    echo largestSubset($a, $n);

// This code is contributed by anuj_67.
?>

Javascript

<script>

// Javascript program to find the largest
// subset which was each pair
// is divisible.

// Function to find the longest Subsequence
function largestSubset(a, n)
{

    // dp[i] is going to store size of largest
    // divisible subset beginning with a[i].
    let dp = [];

    // Since last element is largest, d[n-1] is 1
    dp[n - 1] = 1;

    // Fill values for smaller elements.
    for(let i = n - 2; i >= 0; i--)
    {

        // Find all multiples of a[i] and consider
        // the multiple that has largest subset
        // beginning with it.
        let mxm = 0;
        for(let j = i + 1; j < n; j++)
        {
            if (a[j] % a[i] == 0 ||
                a[i] % a[j] == 0)
            {
                mxm = Math.max(mxm, dp[j]);
            }
        }
        dp[i] = 1 + mxm;
    }

    // Return maximum value from dp[]
    return Math.max(...dp);
}

// Driver code
let a = [ 1, 3, 6, 13, 17, 18 ];
let n = a.length;

document.write(largestSubset(a, n));

// This code is contributed by sanjoy_62

</script>

Output

4

Time Complexity: O(n²)
Space Complexity: O(n)