# Maximum length subsequence with difference between adjacent elements as either 0 or 1 | Set 2 in C++

C++Server Side ProgrammingProgramming

We are given an array of any size and the task is to find the subsequence in the given array with the elements having difference between adjacent elements as 0 or 1.

Input − int arr[] = { 2, 1, 5, 6, 3, 4, 7, 6}

Output − Maximum length subsequence with difference between adjacent elements as either 0 or 1 is: 3

Explanation − The subsequence of adjacent elements in an array with difference as 0 or 1 are {2, 1}. Therefore, the maximum length of subsequence is 2.

Input − int arr[] = { 2, 1, 7, 6, 5}

Output − Maximum length subsequence with difference between adjacent elements as either 0 or 1 is: 3

Explanation − The adjacent elements in an array with difference as 0 or 1 is {7, 6, 5}.. Therefore, the maximum length of subsequence is 3.

## Approach used in the below program is as follows

• Input an array of type integers which can contain positive as well as negative elements.

• Calculate the size of an array and pass an array and size to the function for further functionality.

• Take a temporary variable maximum and set it to 0 and take another temporary variable i and set it to 0 as well

• Create a variable un_map of type unordered_map

• Start loop while till i less than size

• Inside the loop, set len to 0 and check if un_map.find(arr[i]-1) != un_map.end() && len < un_map[arr[i]-1] then set len to len = un_map[arr[i]-1]

• check if un_map.find(arr[i]) != un_map.end() && len < un_map[arr[i]] then set len to len = un_map[arr[i]]

• check if un_map.find(arr[i]+1) != un_map.end() && len < un_map[arr[i]+1] then set len to len = un_map[arr[i]+1]

• Now set un_map[arr[i]] = len + 1

• Check if maximum less than un_map[arr[i]] then set maximum with un_map[arr[i]]

• Increment the value of i

• Return maximum

• Print the result

## Example

Live Demo

#include <bits/stdc++.h>
using namespace std;
//calculate the maximum subsequence
int maximum = 0, i = 0;
unordered_map<int, int> un_map;
while(i < size){
int len = 0;
if (un_map.find(arr[i]-1) != un_map.end() && len < un_map[arr[i]-1]){
len = un_map[arr[i]-1];
}
if (un_map.find(arr[i]) != un_map.end() && len < un_map[arr[i]]){
len = un_map[arr[i]];
}
if (un_map.find(arr[i]+1) != un_map.end() && len < un_map[arr[i]+1]){
len = un_map[arr[i]+1];
}
un_map[arr[i]] = len + 1;
if (maximum < un_map[arr[i]]){
maximum = un_map[arr[i]];
}
i++;
}
return maximum;
}
int main(){
int arr[] = {2, 3, 1, 7, 5, 6, 7, 8};
int size = sizeof(arr) / sizeof(arr);
cout<<"Maximum length subsequence with difference between adjacent elements as either 0
or 1 are: "<< maximum_adj(arr, size);
return 0;
}

## Output

Maximum length subsequence with difference between adjacent elements as either 0 or 1 are: 4