# Longest Consecutive Subsequence

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 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++14

 `// 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);`   `    ``// find the maximum length` `    ``// by traversing the array` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``// if the current element is equal` `        ``// to previous element +1` `        ``if` `(i > 0 && arr[i] == arr[i - 1] + 1)` `            ``count++;` `        ``// reset the count` `        ``else` `            ``count = 1;`   `        ``// update the maximum` `        ``ans = max(ans, count);` `    ``}` `    ``return` `ans;` `}`   `// Driver program` `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 ` `// 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 = ``1``;` `      `  `    ``// find the maximum length ` `    ``// by traversing the array ` `      ``for``(``int` `i = ``1``; i < n; i++)` `    ``{` `        `  `        ``// If the current element is ` `        ``// equal to previous element +1 ` `        ``if` `(arr[i] == arr[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`

Output:

```Length of the Longest contiguous subsequence is 4

```

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 program` `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;` `    ``}`   `    ``// Testing program` `    ``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 function ` `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;` `    ``}`   `    ``// Testing program` `    ``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`

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.