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
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
The subsequence 36, 35, 33, 34, 32 is the longest subsequence
of consecutive elements.

One Solution is to first sort the array and find the longest subarray with consecutive elements. Time complexity of this solution is O(nLogn). Thanks to Hao.W for suggesting this solution.

We can solve this problem 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. Below is the complete algorithm.

  • Create an empty hash.
  • Insert all array elements to hash.
  • Do following for every element arr[i]
  • Check if this element is the starting point of a subsequence. To check this, we simply look for arr[i] – 1 in the hash, if not found, then this is the first element a subsequence.
  • If this element is the first element, then count number of elements in the consecutive starting with this element. Iterate from arr[i] + 1 till the last element that can be found.
  • 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 program
int main()
{
    int arr[] =  {1, 9, 3, 10, 4, 20, 2};
    int n = sizeof arr/ sizeof arr[0];
    cout << "Length of the Longest contiguous subsequence is "
         << findLongestConseqSubseq(arr, n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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)
            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

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right



Output:

Length of the Longest contiguous subsequence is 4

Time Complexity: At first look, time complexity looks more than O(n). If we take a closer look, we can notice that it is O(n) under the assumption that hash insert and search take O(1) time. The function S.find() inside the while loop is called at most twice for every element. For example, consider the case when all array elements are consecutive. In this case, the outer find is called for every element, but we go inside the if condition only for the smallest element. Once we are inside the if condition, we call find() one more time for every other element.

Thanks to Gaurav Ahirwar for above solution.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up

Improved By : shrikanth13