Longest Consecutive Subsequence

• Difficulty Level : Medium
• Last Updated : 13 Jul, 2021

Given an array of integers, find the length of the longest sub-sequence such that elements in the subsequence are consecutive integers, the consecutive numbers can be in any order.

Examples:

Input: arr[] = {1, 9, 3, 10, 4, 20, 2}
Output: 4
Explanation:
The subsequence 1, 3, 4, 2 is the longest
subsequence of consecutive elements

Input: arr[] = {36, 41, 56, 35, 44, 33, 34, 92, 43, 32, 42}
Output: 5
Explanation:
The subsequence 36, 35, 33, 34, 32 is the longest
subsequence of consecutive elements.

Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Naive Approach: The idea is to first sort the array and find the longest subarray with consecutive elements.
After sorting the array and removing the multiple occurrences of elements, run a loop and keep a count and max (both initially zero). Run a loop from start to end and if the current element is not equal to the previous (element+1) then set the count to 1 else increase the count. Update max with a maximum of count and max.

C++

// C++ program to find longest
// contiguous subsequence
#include <bits/stdc++.h>
using namespace std;

// Returns length of the longest
// contiguous subsequence
int findLongestConseqSubseq(int arr[], int n)
{
int ans = 0, count = 0;

// sort the array
sort(arr, arr + n);

vector<int> v;
v.push_back(arr);

//insert repeated elements only once in the vector
for (int i = 1; i < n; i++)
{
if (arr[i] != arr[i - 1])
v.push_back(arr[i]);
}
// find the maximum length
// by traversing the array
for (int i = 0; i < v.size(); i++)
{

// Check if the current element is equal
// to previous element +1
if (i > 0 && v[i] == v[i - 1] + 1)
count++;
// reset the count
else
count = 1;

// update the maximum
ans = max(ans, count);
}
return ans;
}

// Driver code
int main()
{
int arr[] = { 1, 2, 2, 3 };
int n = sizeof arr / sizeof arr;
cout << "Length of the Longest contiguous subsequence "
"is "
<< findLongestConseqSubseq(arr, n);
return 0;
}

Java

// Java program to find longest
// contiguous subsequence
import java.io.*;
import java.util.*;

class GFG
{

static int findLongestConseqSubseq(int arr[],
int n)
{

// Sort the array
Arrays.sort(arr);

int ans = 0, count = 0;

ArrayList<Integer> v = new ArrayList<Integer>();

// Insert repeated elements
// only once in the vector
for (int i = 1; i < n; i++)
{
if (arr[i] != arr[i - 1])
}

// Find the maximum length
// by traversing the array
for (int i = 0; i < v.size(); i++)
{

// Check if the current element is
// equal to previous element +1
if (i > 0 &&v.get(i) == v.get(i - 1) + 1)
count++;
else
count = 1;

// Update the maximum
ans = Math.max(ans, count);
}
return ans;
}

// Driver code
public static void main(String[] args)
{
int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
int n = arr.length;

System.out.println(
"Length of the Longest "
+ "contiguous subsequence is "
+ findLongestConseqSubseq(arr, n));
}
}

// This code is contributed by parascoding

Python3

# Python3 program to find longest
# contiguous subsequence

# Returns length of the longest
# contiguous subsequence
def findLongestConseqSubseq(arr, n):

ans = 0
count = 0

# Sort the array
arr.sort()

v = []

v.append(arr)

# Insert repeated elements only
# once in the vector
for i in range(1, n):
if (arr[i] != arr[i - 1]):
v.append(arr[i])

# Find the maximum length
# by traversing the array
for i in range(len(v)):

# Check if the current element is
# equal to previous element +1
if (i > 0 and v[i] == v[i - 1] + 1):
count += 1

# Reset the count
else:
count = 1

# Update the maximum
ans = max(ans, count)

return ans

# Driver code
arr = [ 1, 2, 2, 3 ]
n = len(arr)

print("Length of the Longest contiguous subsequence is",
findLongestConseqSubseq(arr, n))

# This code is contributed by avanitrachhadiya2155

C#

// C# program to find longest
// contiguous subsequence
using System;
using System.Collections.Generic;

class GFG{

static int findLongestConseqSubseq(int[] arr,
int n)
{

// Sort the array
Array.Sort(arr);

int ans = 0, count = 0;

List<int> v = new List<int>();

// Insert repeated elements
// only once in the vector
for(int i = 1; i < n; i++)
{
if (arr[i] != arr[i - 1])
}

// Find the maximum length
// by traversing the array
for(int i = 0; i < v.Count; i++)
{

// Check if the current element is
// equal to previous element +1
if (i > 0 && v[i] == v[i - 1] + 1)
count++;
else
count = 1;

// Update the maximum
ans = Math.Max(ans, count);
}
return ans;
}

// Driver code
static void Main()
{
int[] arr = { 1, 9, 3, 10, 4, 20, 2 };
int n = arr.Length;

Console.WriteLine("Length of the Longest " +
"contiguous subsequence is " +
findLongestConseqSubseq(arr, n));
}
}

// This code is contributed by divyeshrabadiya07

Javascript

<script>

// JavaScript program to find longest
// contiguous subsequence

// Returns length of the longest
// contiguous subsequence
function findLongestConseqSubseq(arr, n) {
let ans = 0, count = 0;

// sort the array
arr.sort(function (a, b) { return a - b; })

var v = [];
v.push(arr);

//insert repeated elements only once in the vector
for (let i = 1; i < n; i++) {
if (arr[i] != arr[i - 1])
v.push(arr[i]);
}
// find the maximum length
// by traversing the array
for (let i = 0; i < v.length; i++) {

// Check if the current element is equal
// to previous element +1
if (i > 0 && v[i] == v[i - 1] + 1)
count++;
// reset the count
else
count = 1;

// update the maximum
ans = Math.max(ans, count);
}
return ans;
}

// Driver code

let arr = [1, 2, 2, 3];
let n = arr.length;
document.write(
"Length of the Longest contiguous subsequence is "
+findLongestConseqSubseq(arr, n)
);

// This code is contributed by Potta Lokesh

</script>
Output
Length of the Longest contiguous subsequence is 3

Complexity Analysis:

• Time complexity: O(nLogn).
Time to sort the array is O(nlogn).
• Auxiliary space : O(1).
As no extra space is needed.

Thanks to Hao.W for suggesting the above solution.

Efficient solution:
This problem can be solved in O(n) time using an Efficient Solution. The idea is to use Hashing. We first insert all elements in a Set. Then check all the possible starts of consecutive subsequences.

Algorithm:

1. Create an empty hash.
2. Insert all array elements to hash.
3. Do following for every element arr[i]
4. Check if this element is the starting point of a subsequence. To check this, simply look for arr[i] – 1 in the hash, if not found, then this is the first element a subsequence.
5. If this element is the first element, then count the number of elements in the consecutive starting with this element. Iterate from arr[i] + 1 till the last element that can be found.
6. If the count is more than the previous longest subsequence found, then update this.

Below image is a dry run of the above approach: Below is the implementation of the above approach:

C++

// C++ program to find longest
// contiguous subsequence
#include <bits/stdc++.h>
using namespace std;

// Returns length of the longest
// contiguous subsequence
int findLongestConseqSubseq(int arr[], int n)
{
unordered_set<int> S;
int ans = 0;

// Hash all the array elements
for (int i = 0; i < n; i++)
S.insert(arr[i]);

// check each possible sequence from
// the start then update optimal length
for (int i = 0; i < n; i++)
{
// if current element is the starting
// element of a sequence
if (S.find(arr[i] - 1) == S.end())
{
// Then check for next elements
// in the sequence
int j = arr[i];
while (S.find(j) != S.end())
j++;

// update  optimal length if
// this length is more
ans = max(ans, j - arr[i]);
}
}
return ans;
}

// Driver code
int main()
{
int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
int n = sizeof arr / sizeof arr;
cout << "Length of the Longest contiguous subsequence "
"is "
<< findLongestConseqSubseq(arr, n);
return 0;
}

Java

// Java program to find longest
// consecutive subsequence
import java.io.*;
import java.util.*;

class ArrayElements {
// Returns length of the longest
// consecutive subsequence
static int findLongestConseqSubseq(int arr[], int n)
{
HashSet<Integer> S = new HashSet<Integer>();
int ans = 0;

// Hash all the array elements
for (int i = 0; i < n; ++i)

// check each possible sequence from the start
// then update optimal length
for (int i = 0; i < n; ++i)
{
// if current element is the starting
// element of a sequence
if (!S.contains(arr[i] - 1))
{
// Then check for next elements
// in the sequence
int j = arr[i];
while (S.contains(j))
j++;

// update  optimal length if this
// length is more
if (ans < j - arr[i])
ans = j - arr[i];
}
}
return ans;
}

// Driver Code
public static void main(String args[])
{
int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
int n = arr.length;
System.out.println(
"Length of the Longest consecutive subsequence is "
+ findLongestConseqSubseq(arr, n));
}
}
// This code is contributed by Aakash Hasija

Python

# Python program to find longest contiguous subsequence

from sets import Set

def findLongestConseqSubseq(arr, n):

s = Set()
ans = 0

# Hash all the array elements
for ele in arr:

# check each possible sequence from the start
# then update optimal length
for i in range(n):

# if current element is the starting
# element of a sequence
if (arr[i]-1) not in s:

# Then check for next elements in the
# sequence
j = arr[i]
while(j in s):
j += 1

# update  optimal length if this length
# is more
ans = max(ans, j-arr[i])
return ans

# Driver code
if __name__ == '__main__':
n = 7
arr = [1, 9, 3, 10, 4, 20, 2]
print "Length of the Longest contiguous subsequence is ",
print findLongestConseqSubseq(arr, n)

# Contributed by: Harshit Sidhwa

C#

using System;
using System.Collections.Generic;

// C# program to find longest consecutive subsequence

public class ArrayElements {
// Returns length of the
// longest consecutive subsequence
public static int findLongestConseqSubseq(int[] arr,
int n)
{
HashSet<int> S = new HashSet<int>();
int ans = 0;

// Hash all the array elements
for (int i = 0; i < n; ++i) {
}

// check each possible sequence from the start
// then update optimal length
for (int i = 0; i < n; ++i)
{
// if current element is the starting
// element of a sequence
if (!S.Contains(arr[i] - 1))
{
// Then check for next elements in the
// sequence
int j = arr[i];
while (S.Contains(j))
{
j++;
}

// update  optimal length if this length
// is more
if (ans < j - arr[i])
{
ans = j - arr[i];
}
}
}
return ans;
}

// Driver code
public static void Main(string[] args)
{
int[] arr = new int[] { 1, 9, 3, 10, 4, 20, 2 };
int n = arr.Length;
Console.WriteLine(
"Length of the Longest consecutive subsequence is "
+ findLongestConseqSubseq(arr, n));
}
}

// This code is contributed by Shrikant13

Javascript

<script>
// Javascript program to find longest
// contiguous subsequence

// Returns length of the longest
// contiguous subsequence
function findLongestConseqSubseq(arr, n) {
let S = new Set();
let ans = 0;

// Hash all the array elements
for (let i = 0; i < n; i++)

// check each possible sequence from
// the start then update optimal length
for (let i = 0; i < n; i++)
{

// if current element is the starting
// element of a sequence
if (!S.has(arr[i] - 1))
{

// Then check for next elements
// in the sequence
let j = arr[i];
while (S.has(j))
j++;

// update optimal length if
// this length is more
ans = Math.max(ans, j - arr[i]);
}
}
return ans;
}

// Driver code
let arr = [1, 9, 3, 10, 4, 20, 2];
let n = arr.length;
document.write("Length of the Longest contiguous subsequence is "
+ findLongestConseqSubseq(arr, n));

// This code is contributed by gfgking.
</script>
Output
Length of the Longest contiguous subsequence is 4

Complexity Analysis:

• Time complexity: O(n).
Only one traversal is needed and the time complexity is O(n) under the assumption that hash insert and search take O(1) time.
• Auxiliary space: O(n).
To store every element in hashmap O(n) space is needed
Thanks to Gaurav Ahirwar for the above solution.

Another Solution:

This problem can be solved in O(N log N) time with another Method, this time the Idea is to use Priority Queue.

Algorithm:

1. Create a Priority Queue to store the element
2. Store the first element in a variable
3. Remove it from the Priority Queue
4. Check the difference between this removed first element and the new peek element
5. If the difference is equal to 1 increase count by 1 and repeats step 2 and step 3
6. If the difference is greater than 1 set counter to 1 and repeat step 2 and step 3
7. if the difference is equal to 0 repeat step 2 and 3
8. if counter greater than the previous maximum then store counter to maximum
9. Continue step 4 to 7 until we reach the end of the Priority Queue
10. Return the maximum value

C++

// CPP program for the above approach
#include <bits/stdc++.h>
using namespace std;

int findLongestConseqSubseq(int arr[], int N)
{
priority_queue<int, vector<int>, greater<int> > pq;
for (int i = 0; i < N; i++) {

// array to PriorityQueue
pq.push(arr[i]);
}

// Storing the first element
// of the Priority Queue
// This first element is also
// the smallest element
int prev = pq.top();
pq.pop();

// Taking a counter variable with value 1
int c = 1;

// Storing value of max as 1
// as there will always be
// one element
int max = 1;
while (!pq.empty()) {

// check if current peek
// element minus previous
// element is greater then
// 1 This is done because
// if it's greater than 1
// then the sequence
// doesn't start or is broken here
if (pq.top() - prev > 1) {

// Store the value of counter to 1
// As new sequence may begin
c = 1;

// Update the previous position with the
// current peek And remove it
prev = pq.top();
pq.pop();
}

// Check if the previous
//  element and peek are same
else if (pq.top() - prev == 0) {

// Update the previous position with the
// current peek And remove it
prev = pq.top();
pq.pop();
}

// If the difference
// between previous element and peek is 1
else {

// Update the counter
// These are consecutive elements
c++;

// Update the previous position
//  with the current peek And remove it
prev = pq.top();
pq.pop();
}

// Check if current longest
// subsequence is the greatest
if (max < c) {

// Store the current subsequence count as
// max
max = c;
}
}
return max;
}

// Driver Code
int main()
{
int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
int n = 7;

cout << "Length of the Longest consecutive subsequence "
"is "
<< findLongestConseqSubseq(arr, n);
return 0;
}
// this code is contributed by Manu Pathria

Java

// Java Program to find longest consecutive
// subsequence This Program uses Priority Queue
import java.io.*;
import java.util.PriorityQueue;
public class Longset_Sub
{
// return the length of the longest
// subsequence of consecutive integers
static int findLongestConseqSubseq(int arr[], int N)
{

PriorityQueue<Integer> pq
= new PriorityQueue<Integer>();
for (int i = 0; i < N; i++)
{
// array to PriorityQueue
}

// Storing the first element
// of the Priority Queue
// This first element is also
// the smallest element
int prev = pq.poll();

// Taking a counter variable with value 1
int c = 1;

// Storing value of max as 1
// as there will always be
// one element
int max = 1;

for (int i = 1; i < N; i++)
{
// check if current peek
// element minus previous
// element is greater then
// 1 This is done because
// if it's greater than 1
// then the sequence
// doesn't start or is broken here
if (pq.peek() - prev > 1)
{
// Store the value of counter to 1
// As new sequence may begin
c = 1;

// Update the previous position with the
// current peek And remove it
prev = pq.poll();
}

// Check if the previous
//  element and peek are same
else if (pq.peek() - prev == 0)
{
// Update the previous position with the
// current peek And remove it
prev = pq.poll();
}
// if the difference
// between previous element and peek is 1
else
{
// Update the counter
// These are consecutive elements
c++;

// Update the previous position
//  with the current peek And remove it
prev = pq.poll();
}

// Check if current longest
// subsequence is the greatest
if (max < c)
{
// Store the current subsequence count as
// max
max = c;
}
}

return max;
}

// Driver Code
public static void main(String args[])
throws IOException
{
int arr[] = { 1, 9, 3, 10, 4, 20, 2 };
int n = arr.length;
System.out.println(
"Length of the Longest consecutive subsequence is "
+ findLongestConseqSubseq(arr, n));
}
}
// This code is contributed by Sudipa Sarkar
Output
Length of the Longest consecutive subsequence is 4