Related Articles
Length of longest non-decreasing subsequence such that difference between adjacent elements is at most one
• Last Updated : 22 Apr, 2021

Given an array arr[] consisting of N integers, the task is to find the length of the longest non-decreasing subsequence such that the difference between adjacent elements is at most 1.

Examples:

Input: arr[] = {8, 5, 4, 8, 4}
Output: 3
Explanation: {4, 4, 5}, {8, 8} are the two such non-decreasing subsequences of length 2 and 3 respectively. Therefore, the length of the longest of the two subsequences is 3.

Input: arr[] = {4, 13, 2, 3}
Output: 3
Explanation: {2, 3, 4}, {13} are the two such non-decreasing subsequences of length 3 and 1 respectively. Therefore, the length of the longest of the two subsequences is 3.

Approach: Follow the steps below to solve the problem:

• Sort the array arr[] in increasing order.
• Initialize a variable, say maxLen = 1, to store the maximum possible length of a subsequence. Initialize another variable, say len = 1 to store the current length for each subsequence.
• Traverse the array arr[] with a pointer i and for each element:
• Check if abs(arr[i] – arr[i – 1]) ≤ 1. If found to be true, then increment len by 1. Update maxLen = max(maxLen, len).
• Otherwise, set len = 1 i.e. start a new subsequence.
• Print the value of maxLen as the final answer.

Below is the implementation of the above approach:

## C++

 `// C++ program to implement``// the above approach` `#include ``using` `namespace` `std;` `// Function to find the longest non-decreasing``// subsequence with difference between``// adjacent elements exactly equal to 1``void` `longestSequence(``int` `arr[], ``int` `N)``{``  ``// Base case``  ``if` `(N == 0) {``    ``cout << 0;``    ``return``;``  ``}` `  ``// Sort the array in ascending order``  ``sort(arr, arr+N);` `  ``// Stores the maximum length``  ``int` `maxLen = 1;` `  ``int` `len = 1;` `  ``// Traverse the array``  ``for` `(``int` `i = 1; i < N; i++) {` `    ``// If difference between current``    ``// pair of adjacent elements is 1 or 0``    ``if` `(arr[i] == arr[i - 1]``        ``|| arr[i] == arr[i - 1] + 1) {``      ``len++;` `      ``// Extend the current sequence``      ``// Update len and max_len``      ``maxLen = max(maxLen, len);``    ``}``    ``else` `{` `      ``// Otherwise, start a new subsequence``      ``len = 1;``    ``}``  ``}` `  ``// Print the maximum length``  ``cout << maxLen;``}`  `// Driver Code``int` `main()``{` `  ``// Given array``  ``int` `arr[] = { 8, 5, 4, 8, 4 };` `  ``// Size of the array``  ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `  ``// Function call to find the longest``  ``// subsequence``  ``longestSequence(arr, N);` `  ``return` `0;``}` `// This code is contributed by code_hunt.`

## Java

 `// Java program for the above approach` `import` `java.io.*;``import` `java.util.*;``class` `GFG {` `    ``// Function to find the longest non-decreasing``    ``// subsequence with difference between``    ``// adjacent elements exactly equal to 1``    ``static` `void` `longestSequence(``int` `arr[], ``int` `N)``    ``{``        ``// Base case``        ``if` `(N == ``0``) {``            ``System.out.println(``0``);``            ``return``;``        ``}` `        ``// Sort the array in ascending order``        ``Arrays.sort(arr);` `        ``// Stores the maximum length``        ``int` `maxLen = ``1``;` `        ``int` `len = ``1``;` `        ``// Traverse the array``        ``for` `(``int` `i = ``1``; i < N; i++) {` `            ``// If difference between current``            ``// pair of adjacent elements is 1 or 0``            ``if` `(arr[i] == arr[i - ``1``]``                ``|| arr[i] == arr[i - ``1``] + ``1``) {``                ``len++;` `                ``// Extend the current sequence``                ``// Update len and max_len``                ``maxLen = Math.max(maxLen, len);``            ``}``            ``else` `{` `                ``// Otherwise, start a new subsequence``                ``len = ``1``;``            ``}``        ``}` `        ``// Print the maximum length``        ``System.out.println(maxLen);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``// Given array``        ``int` `arr[] = { ``8``, ``5``, ``4``, ``8``, ``4` `};` `        ``// Size of the array``        ``int` `N = arr.length;` `        ``// Function call to find the longest``        ``// subsequence``        ``longestSequence(arr, N);``    ``}``}`

## Python3

 `# Python program for the above approach` `# Function to find the longest non-decreasing``# subsequence with difference between``# adjacent elements exactly equal to 1``def` `longestSequence(arr, N):``  ` `    ``# Base case``    ``if` `(N ``=``=` `0``):``        ``print``(``0``);``        ``return``;` `    ``# Sort the array in ascending order``    ``arr.sort();` `    ``# Stores the maximum length``    ``maxLen ``=` `1``;``    ``len` `=` `1``;` `    ``# Traverse the array``    ``for` `i ``in` `range``(``1``,N):` `        ``# If difference between current``        ``# pair of adjacent elements is 1 or 0``        ``if` `(arr[i] ``=``=` `arr[i ``-` `1``] ``or` `arr[i] ``=``=` `arr[i ``-` `1``] ``+` `1``):``            ``len` `+``=` `1``;` `            ``# Extend the current sequence``            ``# Update len and max_len``            ``maxLen ``=` `max``(maxLen, ``len``);``        ``else``:` `            ``# Otherwise, start a new subsequence``            ``len` `=` `1``;` `    ``# Prthe maximum length``    ``print``(maxLen);` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given array``    ``arr ``=` `[``8``, ``5``, ``4``, ``8``, ``4``];` `    ``# Size of the array``    ``N ``=` `len``(arr);` `    ``# Function call to find the longest``    ``# subsequence``    ``longestSequence(arr, N);` `    ``# This code is contributed by 29AjayKumar`

## C#

 `// C# program for the above approach``using` `System;``public` `class` `GFG``{` `  ``// Function to find the longest non-decreasing``  ``// subsequence with difference between``  ``// adjacent elements exactly equal to 1``  ``static` `void` `longestSequence(``int` `[]arr, ``int` `N)``  ``{` `    ``// Base case``    ``if` `(N == 0)``    ``{``      ``Console.WriteLine(0);``      ``return``;``    ``}` `    ``// Sort the array in ascending order``    ``Array.Sort(arr);` `    ``// Stores the maximum length``    ``int` `maxLen = 1;``    ``int` `len = 1;` `    ``// Traverse the array``    ``for` `(``int` `i = 1; i < N; i++) {` `      ``// If difference between current``      ``// pair of adjacent elements is 1 or 0``      ``if` `(arr[i] == arr[i - 1]``          ``|| arr[i] == arr[i - 1] + 1) {``        ``len++;` `        ``// Extend the current sequence``        ``// Update len and max_len``        ``maxLen = Math.Max(maxLen, len);``      ``}``      ``else` `{` `        ``// Otherwise, start a new subsequence``        ``len = 1;``      ``}``    ``}` `    ``// Print the maximum length``    ``Console.WriteLine(maxLen);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(``string``[] args)``  ``{` `    ``// Given array``    ``int` `[]arr = { 8, 5, 4, 8, 4 };` `    ``// Size of the array``    ``int` `N = arr.Length;` `    ``// Function call to find the longest``    ``// subsequence``    ``longestSequence(arr, N);``  ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``

Output:
`3`

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up