Longest subsequence such that absolute difference between every pair is atmost 1
Given an integer array arr[] of size N, the task is to find the longest subsequence S such that for every a[i], a[j] ∈ S and |a[i] – a[j]| ≤ 1.
Examples:
Input: arr[] = {2, 2, 3, 5, 5, 6, 6, 6}
Output: 5
Explanation:
There are 2 such subsequence such that difference between every pair is atmost 1
{2, 2, 3} and {5, 5, 6, 6, 6}
The longest one of these is {5, 5, 6, 6, 6} with length of 5.
Input: arr[] = {5, 7, 6, 4, 4, 2}
Output: 3
Approach:
The idea is to observe that for a subsequence with a difference between every possible pair at most one is possible when the subsequence contains elements between [X , X + 1].
- Initialize the maximum length of the required subsequence to 0.
- Create a HashMap to store the frequency of every element of the array.
- Iterate through the Hash Map and for every element a[i] in hash map –
- Find the count of occurrence of element (a[i] + 1), (a[i]) and (a[i] – 1).
- Find the Maximum count out of occurrence of elements (a[i] + 1) or (a[i] – 1).
- If the Total count of occurrence is greater than the maximum length found then update the maximum length of subsequence.
Below is the implementation of the above approach.
C++
#include <iostream>
#include <unordered_map>
#include <algorithm>
using namespace std;
int longestAr( int n, int arr[]) {
unordered_map< int , int > count;
for ( int i = 0; i < n; i++) {
if (count.find(arr[i]) != count.end())
count[arr[i]]++;
else
count[arr[i]] = 1;
}
unordered_map< int , int >::iterator it;
int max_val = 0;
for (it = count.begin(); it != count.end(); it++) {
int a = it->first;
int cur = 0;
int cur1 = 0;
int cur2 = 0;
if (count.find(a + 1) != count.end())
cur1 = count[a + 1];
if (count.find(a - 1) != count.end())
cur2 = count[a - 1];
cur = count[a] + max(cur1, cur2);
if (cur > max_val)
max_val = cur;
}
return max_val;
}
int main() {
int n = 8;
int arr[] = { 2, 2, 3, 5, 5, 6, 6, 6 };
int maxLen = longestAr(n, arr);
cout << maxLen << endl;
return 0;
}
|
Java
import java.util.*;
public class GeeksForGeeks {
public static int longestAr(
int n, int arr[]){
Hashtable<Integer, Integer> count
= new Hashtable<Integer, Integer>();
for ( int i = 0 ; i < n; i++) {
if (count.containsKey(arr[i]))
count.put(arr[i], count.get(
arr[i]) + 1
);
else
count.put(arr[i], 1 );
}
Set<Integer> kset = count.keySet();
Iterator<Integer> it = kset.iterator();
int max = 0 ;
while (it.hasNext()) {
int a = ( int )it.next();
int cur = 0 ;
int cur1 = 0 ;
int cur2 = 0 ;
if (count.containsKey(a + 1 ))
cur1 = count.get(a + 1 );
if (count.containsKey(a - 1 ))
cur2 = count.get(a - 1 );
cur = count.get(a) +
Math.max(cur1, cur2);
if (cur > max)
max = cur;
}
return (max);
}
public static void main(String[] args)
{
int n = 8 ;
int arr[] = { 2 , 2 , 3 , 5 , 5 , 6 , 6 , 6 };
int maxLen = longestAr(n, arr);
System.out.println(maxLen);
}
}
|
Python3
def longestAr(n, arr):
count = dict ()
for i in arr:
count[i] = count.get(i, 0 ) + 1
kset = count.keys()
maxm = 0
for it in list (kset):
a = it
cur = 0
cur1 = 0
cur2 = 0
if ((a + 1 ) in count):
cur1 = count[a + 1 ]
if ((a - 1 ) in count):
cur2 = count[a - 1 ]
cur = count[a] + max (cur1, cur2)
if (cur > maxm):
maxm = cur
return maxm
if __name__ = = '__main__' :
n = 8
arr = [ 2 , 2 , 3 , 5 , 5 , 6 , 6 , 6 ]
maxLen = longestAr(n, arr)
print (maxLen)
|
Javascript
<script>
function longestAr(n,arr)
{
let count = new Map();
for (let i = 0; i < n; i++) {
if (count.has(arr[i]))
count.set(arr[i], count.get(
arr[i]) + 1
);
else
count.set(arr[i], 1);
}
let max = 0;
for (let it of count.keys()) {
let a = it;
let cur = 0;
let cur1 = 0;
let cur2 = 0;
if (count.has(a + 1))
cur1 = count.get(a + 1);
if (count.has(a - 1))
cur2 = count.get(a - 1);
cur = count.get(a) +
Math.max(cur1, cur2);
if (cur > max)
max = cur;
}
return (max);
}
let n = 8;
let arr=[2, 2, 3, 5, 5, 6, 6, 6];
let maxLen = longestAr(n, arr);
document.write(maxLen);
</script>
|
C#
using System;
using System.Linq;
using System.Collections;
using System.Collections.Generic;
public class GeeksForGeeks
{
public static int longestAr( int n, int [] arr)
{
var count = new Dictionary< int , int >();
for ( int i = 0; i < n; i++)
{
if (count.ContainsKey(arr[i]))
{
count[arr[i]] = count[arr[i]] + 1;
}
else
{
count[arr[i]] = 1;
}
}
var kset = count.Keys;
var it = kset.GetEnumerator();
var max = 0;
while (it.MoveNext())
{
var a = ( int )it.Current;
var cur = 0;
var cur1 = 0;
var cur2 = 0;
if (count.ContainsKey(a + 1))
{
cur1 = count[a + 1];
}
if (count.ContainsKey(a - 1))
{
cur2 = count[a - 1];
}
cur = count[a] + Math.Max(cur1,cur2);
if (cur > max)
{
max = cur;
}
}
return (max);
}
public static void Main(String[] args)
{
var n = 8;
int [] arr = {2, 2, 3, 5, 5, 6, 6, 6};
var maxLen = longestAr(n, arr);
Console.WriteLine(maxLen);
}
}
|
Time Complexity: O(n).
Space Complexity: O(n).
Last Updated :
02 Mar, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...