Related Articles
Longest sub-sequence that satisfies the given conditions
• Difficulty Level : Hard
• Last Updated : 12 Jun, 2019

Given an array arr[] of N integers, the task is to find the longest sub-sequence in the given array such that for all pairs from the sub-sequence (arr[i], arr[j]) where i != j either arr[i] divides arr[j] or vice versa. If no such sub-sequence exists then print -1.

Examples:

Input: arr[] = {2, 4, 6, 1, 3, 11}
Output: 3
Longest valid sub-sequences are {1, 2, 6} and {1, 3, 6}.

Input: arr[] = {21, 22, 6, 4, 13, 7, 332}
Output: 2

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: This problem is a simple variation of the longest increasing sub-sequence problem. What changes is the base condition and the trick to reduce the number of computations by sorting the given array.

• First sort the given array so that we only need to check values where arr[i] > arr[j] for i > j.
• Then we move forward using two loops, outer loop runs from 1 to N and the inner loop runs from 0 to i.
• Now in the inner loop we have to find the number of arr[j] where j is from 0 to i – 1 which divides the element arr[i].
• And the recurrence relation will be dp[i] = max(dp[i], 1 + dp[j]).
• We will update the max dp[i] value in a variable named res which will be the final answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of the approach``#include ``using` `namespace` `std;`` ` `// Function to return the length of the``// longest required sub-sequence``int` `find(``int` `n, ``int` `a[])``{``    ``// Sort the array``    ``sort(a, a + n);`` ` `    ``// To store the resultant length``    ``int` `res = 1;``    ``int` `dp[n];`` ` `    ``// If array contains only one element``    ``// then it divides itself``    ``dp = 1;`` ` `    ``for` `(``int` `i = 1; i < n; i++) {`` ` `        ``// Every elemnet divides itself``        ``dp[i] = 1;`` ` `        ``// Count for all numbers which``        ``// are leser than a[i]``        ``for` `(``int` `j = 0; j < i; j++) {`` ` `            ``if` `(a[i] % a[j] == 0) {`` ` `                ``// If a[i] % a[j] then update the maximum``                ``// subsequence length,``                ``// dp[i] = max(dp[i], 1 + dp[j])``                ``// where j is in the range [0, i-1]``                ``dp[i] = std::max(dp[i], 1 + dp[j]);``            ``}``        ``}`` ` `        ``res = std::max(res, dp[i]);``    ``}`` ` `    ``// If array contains only one element``    ``// then i = j which doesn't satisfy the condition``    ``return` `(res == 1) ? -1 : res;``}`` ` `// Driver code``int` `main()``{``    ``int` `a[] = { 2, 4, 6, 1, 3, 11 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(``int``);`` ` `    ``cout << find(n, a);`` ` `    ``return` `0;``}`

## Java

 `// Java implementation of the approach``import` `java.util.Arrays; ``import` `java.io.*;`` ` `class` `GFG ``{``     ` `// Function to return the length of the``// longest required sub-sequence``static` `int` `find(``int` `n, ``int` `a[])``{``    ``// Sort the array``    ``Arrays.sort(a);`` ` `    ``// To store the resultant length``    ``int` `res = ``1``;``    ``int` `dp[] = ``new` `int``[n];`` ` `    ``// If array contains only one element``    ``// then it divides itself``    ``dp[``0``] = ``1``;`` ` `    ``for` `(``int` `i = ``1``; i < n; i++) ``    ``{`` ` `        ``// Every elemnet divides itself``        ``dp[i] = ``1``;`` ` `        ``// Count for all numbers which``        ``// are leser than a[i]``        ``for` `(``int` `j = ``0``; j < i; j++) ``        ``{`` ` `            ``if` `(a[i] % a[j] == ``0``)``            ``{`` ` `                ``// If a[i] % a[j] then update the maximum``                ``// subsequence length,``                ``// dp[i] = Math.max(dp[i], 1 + dp[j])``                ``// where j is in the range [0, i-1]``                ``dp[i] = Math.max(dp[i], ``1` `+ dp[j]);``            ``}``        ``}`` ` `        ``res = Math.max(res, dp[i]);``    ``}`` ` `    ``// If array contains only one element``    ``// then i = j which doesn't satisfy the condition``    ``return` `(res == ``1``) ? -``1` `: res;``}`` ` `// Driver code``public` `static` `void` `main (String[] args) ``{``    ``int` `a[] = { ``2``, ``4``, ``6``, ``1``, ``3``, ``11` `};``    ``int` `n = a.length;`` ` `    ``System.out.println (find(n, a));``}``}`` ` `// This code is contributed by jit_t`

## Python3

 `# Python3 implementation of the approach `` ` `# Function to return the length of the ``# longest required sub-sequence ``def` `find(n, a) :`` ` `    ``# Sort the array ``    ``a.sort(); `` ` `    ``# To store the resultant length ``    ``res ``=` `1``; ``    ``dp ``=` `[``0``]``*``n; `` ` `    ``# If array contains only one element ``    ``# then it divides itself ``    ``dp[``0``] ``=` `1``; `` ` `    ``for` `i ``in` `range``(``1``, n) :``         ` `        ``# Every elemnet divides itself ``        ``dp[i] ``=` `1``; `` ` `        ``# Count for all numbers which ``        ``# are leser than a[i] ``        ``for` `j ``in` `range``(i) :`` ` `            ``if` `(a[i] ``%` `a[j] ``=``=` `0``) :`` ` `                ``# If a[i] % a[j] then update the maximum ``                ``# subsequence length, ``                ``# dp[i] = max(dp[i], 1 + dp[j]) ``                ``# where j is in the range [0, i-1] ``                ``dp[i] ``=` `max``(dp[i], ``1` `+` `dp[j]); ``     ` `        ``res ``=` `max``(res, dp[i]); `` ` `    ``# If array contains only one element ``    ``# then i = j which doesn't satisfy the condition ``    ``if` `(res ``=``=` `1``): ``        ``return` `-``1``    ``else` `:``        ``return` `res; `` ` ` ` `# Driver code ``if` `__name__ ``=``=` `"__main__"` `: `` ` `    ``a ``=` `[ ``2``, ``4``, ``6``, ``1``, ``3``, ``11` `];``    ``n ``=` `len``(a); `` ` `    ``print``(find(n, a)); ``     ` `# This code is contributed by AnkitRai01`

## C#

 `// C# implementation of the approach``using` `System;`` ` `class` `GFG ``{``     ` `// Function to return the length of the``// longest required sub-sequence``static` `int` `find(``int` `n, ``int` `[]a)``{``    ``// Sort the array``    ``Array.Sort(a);`` ` `    ``// To store the resultant length``    ``int` `res = 1;``    ``int` `[]dp = ``new` `int``[n];`` ` `    ``// If array contains only one element``    ``// then it divides itself``    ``dp = 1;`` ` `    ``for` `(``int` `i = 1; i < n; i++) ``    ``{`` ` `        ``// Every elemnet divides itself``        ``dp[i] = 1;`` ` `        ``// Count for all numbers which``        ``// are leser than a[i]``        ``for` `(``int` `j = 0; j < i; j++) ``        ``{`` ` `            ``if` `(a[i] % a[j] == 0)``            ``{`` ` `                ``// If a[i] % a[j] then update the maximum``                ``// subsequence length,``                ``// dp[i] = Math.max(dp[i], 1 + dp[j])``                ``// where j is in the range [0, i-1]``                ``dp[i] = Math.Max(dp[i], 1 + dp[j]);``            ``}``        ``}`` ` `        ``res = Math.Max(res, dp[i]);``    ``}`` ` `    ``// If array contains only one element``    ``// then i = j which doesn't satisfy the condition``    ``return` `(res == 1) ? -1 : res;``}`` ` `// Driver code``public` `static` `void` `Main () ``{``    ``int` `[]a = { 2, 4, 6, 1, 3, 11 };``    ``int` `n = a.Length;`` ` `    ``Console.WriteLine(find(n, a));``}``}`` ` `// This code is contributed by anuj_67..`
Output:
```3
```

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.

My Personal Notes arrow_drop_up