# Longest Subsequence with absolute difference of pairs as at least Subsequence’s maximum

• Last Updated : 08 Mar, 2022

Given an array arr[] of length N. The task is to find the length of the longest subsequence of the array such that the absolute difference between any pair of elements is greater than or equal to the maximum element in that subsequence.

Examples:

Input: N = 6, arr[] = {1, 1, 0, 0, 0, 0}
Output: 4
Explanation: Considering 0 as max element of subsequence, longest array can be made
by choosing elements from arr3 to arr6 => {0, 0, 0, 0}.
Thus, Length of above subsequence = 4.

Input: N = 4, arr[] = {-3, 0, 2, 0}
Output: 3

Approach: The solution to the problem is based on the following observation.

•  Try to include as many negative and 0 value elements as possible because in an array of all negative and zero value elements the absolute difference of any two pairs would always be greater than or equal to zero and the maximum element in that subsequence would be less than or equal to zero.
• Now, the focus should be to add only one positive element if possible, in the subsequence because on considering a number of positive elements greater than or equal to 2, a scenario might come when both positive elements would be in consideration as a pair then their absolute difference would be less than the maximum element(which would be one of the taken positive element).

The above observation can be implemented by sorting the array and finding the longest sequence that satisfies the given condition of the problem statement. Follow the below steps:

• Sort Array in Descending order.
• Initialize the answer variable with a value equal to given N.
• Start Iterating the array, and take the count of how many elements cannot be taken into consideration for a subsequence by checking if the difference between any pair is greater than or equal to the maximum element of that subsequence.
• Return (answer – element count).

Below is the implementation of the above approach

## C++

 `// C++ code for the above approach``#include ``using` `namespace` `std;` `// Function to get longest subsequence``int` `solve(``int` `arr[], ``int` `n)``{` `    ``// Sort the array in descending order``    ``sort(arr, arr + n, greater<``int``>());` `    ``// Initialize answer variable equal``    ``// to value of N``    ``int` `answer = n;` `    ``// Count of elements``    ``// that wont be included in``    ``// the longest subsequence``    ``int` `j = 0;` `    ``// Traversing the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(i + 1 < n) {` `            ``// Checking using the given condition``            ``// and taking count of elements``            ``// not to be included in the answer``            ``if` `(``abs``(arr[i] - arr[i + 1])``                ``< arr[j]) {``                ``j++;``            ``}``        ``}``    ``}` `    ``// Printing the final answer``    ``return` `answer - j;``}` `// Driver Code``int` `main()``{``    ``int` `N = 4;``    ``int` `arr[] = { -3, 0, 2, 0 };` `    ``// Function call``    ``int` `ans = solve(arr, N);``    ``cout << ans;``    ``return` `0;``}`

## Java

 `// Java code for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG {` `  ``// Function to reverse the array``  ``static` `void` `reverse(``int` `a[], ``int` `n){``    ``int` `i, k, t;``    ``for` `(i = ``0``; i < n / ``2``; i++) {``      ``t = a[i];``      ``a[i] = a[n - i - ``1``];``      ``a[n - i - ``1``] = t;``    ``}``  ``}` `  ``// Function to get longest subsequence``  ``static` `int` `solve(``int` `arr[], ``int` `n)``  ``{` `    ``// Sort the array in descending order``    ``Arrays.sort(arr);``    ``//Now reverse the array``    ``reverse(arr, n);` `    ``// Initialize answer variable equal``    ``// to value of N``    ``int` `answer = n;` `    ``// Count of elements``    ``// that wont be included in``    ``// the longest subsequence``    ``int` `j = ``0``;` `    ``// Traversing the array``    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``if` `(i + ``1` `< n) {` `        ``// Checking using the given condition``        ``// and taking count of elements``        ``// not to be included in the answer``        ``if` `(Math.abs(arr[i] - arr[i + ``1``])``            ``< arr[j]) {``          ``j++;``        ``}``      ``}``    ``}` `    ``// Printing the final answer``    ``return` `answer - j;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main (String[] args) {``    ``int` `N = ``4``;``    ``int` `arr[] = { -``3``, ``0``, ``2``, ``0` `};` `    ``// Function call``    ``int` `ans = solve(arr, N);``    ``System.out.println(ans);` `  ``}``}` `// This code is contributed by hrithikgarg03188.`

## Python3

 `# Python 3 code for the above approach` `# Function to get longest subsequence``def` `solve(arr, n):` `    ``# Sort the array in descending order``    ``arr.sort()``    ``arr.reverse()` `    ``# Initialize answer variable equal``    ``# to value of N``    ``answer ``=` `n` `    ``# Count of elements``    ``# that wont be included in``    ``# the longest subsequence``    ``j ``=` `0` `    ``# Traversing the array``    ``for` `i ``in` `range``(n):` `        ``if` `(i ``+` `1` `< n):` `            ``# Checking using the given condition``            ``# and taking count of elements``            ``# not to be included in the answer``            ``if` `(``abs``(arr[i] ``-` `arr[i ``+` `1``])``                    ``< arr[j]):``                ``j ``+``=` `1` `    ``# Printing the final answer``    ``return` `answer ``-` `j` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `4``    ``arr ``=` `[``-``3``, ``0``, ``2``, ``0``]` `    ``# Function call``    ``ans ``=` `solve(arr, N)``    ``print``(ans)` `    ``# This code is contributed by ukasp.`

## C#

 `// C# code for the above approach``using` `System;``class` `GFG {` `  ``// Function to reverse the array``  ``static` `void` `reverse(``int``[] a, ``int` `n)``  ``{``    ``int` `i, k, t;``    ``for` `(i = 0; i < n / 2; i++) {``      ``t = a[i];``      ``a[i] = a[n - i - 1];``      ``a[n - i - 1] = t;``    ``}``  ``}` `  ``// Function to get longest subsequence``  ``static` `int` `solve(``int``[] arr, ``int` `n)``  ``{` `    ``// Sort the array in descending order``    ``Array.Sort(arr);` `    ``// Now reverse the array``    ``reverse(arr, n);` `    ``// Initialize answer variable equal``    ``// to value of N``    ``int` `answer = n;` `    ``// Count of elements``    ``// that wont be included in``    ``// the longest subsequence``    ``int` `j = 0;` `    ``// Traversing the array``    ``for` `(``int` `i = 0; i < n; i++) {` `      ``if` `(i + 1 < n) {` `        ``// Checking using the given condition``        ``// and taking count of elements``        ``// not to be included in the answer``        ``if` `(Math.Abs(arr[i] - arr[i + 1])``            ``< arr[j]) {``          ``j++;``        ``}``      ``}``    ``}` `    ``// Printing the final answer``    ``return` `answer - j;``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{``    ``int` `N = 4;``    ``int``[] arr = { -3, 0, 2, 0 };` `    ``// Function call``    ``int` `ans = solve(arr, N);``    ``Console.WriteLine(ans);``  ``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`3`

Time Complexity: O(N*logN)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up