Related Articles

# 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.```

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 ``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 v = ``new` `ArrayList();``        ``v.add(``10``);``      ` `        ``// Insert repeated elements``        ``// only once in the vector``        ``for` `(``int` `i = ``1``; i < n; i++)``        ``{``            ``if` `(arr[i] != arr[i - ``1``])``                ``v.add(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.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[``0``])` `    ``# 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``>();``    ``v.Add(10);``   ` `    ``// Insert repeated elements``    ``// only once in the vector``    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ``if` `(arr[i] != arr[i - 1])``            ``v.Add(arr[i]);``    ``}``    ` `    ``// 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

 ``
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 ``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 S = ``new` `HashSet();``        ``int` `ans = ``0``;` `        ``// Hash all the array elements``        ``for` `(``int` `i = ``0``; i < n; ++i)``            ``S.add(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.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:``        ``s.add(ele)` `    ``# 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) {``            ``S.Add(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.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

 ``
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 ``using` `namespace` `std;` `int` `findLongestConseqSubseq(``int` `arr[], ``int` `N)``{``    ``priority_queue<``int``, vector<``int``>, greater<``int``> > pq;``    ``for` `(``int` `i = 0; i < N; i++) {``      ` `        ``// adding element from``        ``// 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 pq``            ``= ``new` `PriorityQueue();``        ``for` `(``int` `i = ``0``; i < N; i++)``        ``{``            ``// adding element from``            ``// array to PriorityQueue``            ``pq.add(arr[i]);``        ``}``        ` `        ``// 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`