# Longest sub-sequence that satisfies the given conditions

• Difficulty Level : Hard
• Last Updated : 08 Dec, 2021

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:
Longest valid sub-sequences are {1, 2, 6} and {1, 3, 6}.
Input: arr[] = {21, 22, 6, 4, 13, 7, 332}
Output:

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:

## CPP

 `// 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 element divides itself``        ``dp[i] = 1;` `        ``// Count for all numbers which``        ``// are lesser 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 element divides itself``        ``dp[i] = ``1``;` `        ``// Count for all numbers which``        ``// are lesser 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 element divides itself``        ``dp[i] ``=` `1``;` `        ``# Count for all numbers which``        ``# are lesser 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 element divides itself``        ``dp[i] = 1;` `        ``// Count for all numbers which``        ``// are lesser 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..`

## javascript

 ``

Output:

`3`

My Personal Notes arrow_drop_up