Largest increasing subsequence of consecutive integers

Given an array of n positive integers. We need to find the largest increasing sequence of consecutive positive integers.

Examples:

Input : arr[] = {5, 7, 6, 7, 8} 
Output : Size of LIS = 4
         LIS = 5, 6, 7, 8

Input : arr[] = {5, 7, 8, 7, 5} 
Output : Size of LIS = 2
         LIS = 7, 8

This problem can be solved easily by the concept of LIS where each next greater element differ from earlier one by 1. But this will take O(n^2) time complexity.

With the use of hashing we can finding the size of longest increasing sequence with consecutive integers in time complexity of O(n).

We create a hash table.. Now for each element arr[i], we perform hash[arr[i]] = hash[arr[i] – 1] + 1. So, for every element we know longest consecutive increasing subsequence ending with it. Finally we return maximum value from hash table.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of longest continuous increasing
// subsequence
#include <bits/stdc++.h>
using namespace std;
  
// Function for LIS
int findLIS(int A[], int n)
{
    unordered_map<int, int> hash;
  
    // Initialize result
    int LIS_size = 1;
    int LIS_index = 0;
  
    hash[A[0]] = 1;
  
    // iterate through array and find
    // end index of LIS and its Size
    for (int i = 1; i < n; i++) {
        hash[A[i]] = hash[A[i] - 1] + 1;
        if (LIS_size < hash[A[i]]) {
            LIS_size = hash[A[i]];
            LIS_index = A[i];
        }
    }
  
    // print LIS size
    cout << "LIS_size = " << LIS_size << "\n";
  
    // print LIS after setting start element
    cout << "LIS : ";
    int start = LIS_index - LIS_size + 1;
    while (start <= LIS_index) {
        cout << start << " ";
        start++;
    }
}
  
// driver
int main()
{
    int A[] = { 2, 5, 3, 7, 4, 8, 5, 13, 6 };
    int n = sizeof(A) / sizeof(A[0]);
    findLIS(A, n);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of longest continuous increasing
// subsequence
import java.util.*;
  
class GFG 
{
  
// Function for LIS
static void findLIS(int A[], int n)
{
    Map<Integer, Integer> hash = new HashMap<Integer, Integer>();
  
    // Initialize result
    int LIS_size = 1;
    int LIS_index = 0;
  
    hash.put(A[0], 1);
    // iterate through array and find
    // end index of LIS and its Size
    for (int i = 1; i < n; i++) 
    {
        hash.put(A[i], hash.get(A[i] - 1)==null? 1:hash.get(A[i] - 1)+1);
        if (LIS_size < hash.get(A[i])) 
        {
            LIS_size = hash.get(A[i]);
            LIS_index = A[i];
        }
    }
  
    // print LIS size
    System.out.println("LIS_size = " + LIS_size);
  
    // print LIS after setting start element
    System.out.print("LIS : ");
    int start = LIS_index - LIS_size + 1;
    while (start <= LIS_index)
    {
        System.out.print(start + " ");
        start++;
    }
}
  
// Driver code
public static void main(String[] args)
{
    int A[] = { 2, 5, 3, 7, 4, 8, 5, 13, 6 };
    int n = A.length;
    findLIS(A, n);
}
}
  
// This code is contributed by Princi Singh

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of longest 
# continuous increasing subsequence
  
# Function for LIS
def findLIS(A, n):
    hash = dict()
  
    # Initialize result
    LIS_size, LIS_index = 1, 0
  
    hash[A[0]] = 1
  
    # iterate through array and find
    # end index of LIS and its Size
    for i in range(1, n):
  
        # If the desired key is not present 
        # in dictionary, it will throw key error, 
        # to avoid this error this is necessary
        if A[i] - 1 not in hash:
            hash[A[i] - 1] = 0
  
        hash[A[i]] = hash[A[i] - 1] + 1
        if LIS_size < hash[A[i]]:
            LIS_size = hash[A[i]]
            LIS_index = A[i]
      
    # print LIS size
    print("LIS_size =", LIS_size)
  
    # print LIS after setting start element
    print("LIS : ", end = "")
  
    start = LIS_index - LIS_size + 1
    while start <= LIS_index:
        print(start, end = " ")
        start += 1
  
# Driver Code
if __name__ == "__main__":
    A = [ 2, 5, 3, 7, 4, 8, 5, 13, 6 ]
    n = len(A)
    findLIS(A, n)
  
# This code is contributed by sanjeev2552

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of longest continuous increasing
// subsequence
using System;
using System.Collections.Generic; 
  
class GFG 
{
  
// Function for LIS
static void findLIS(int []A, int n)
{
    Dictionary<int,int> hash = new Dictionary<int,int>();
  
    // Initialize result
    int LIS_size = 1;
    int LIS_index = 0;
  
    hash.Add(A[0], 1);
      
    // iterate through array and find
    // end index of LIS and its Size
    for (int i = 1; i < n; i++) 
    {
        if(hash.ContainsKey(A[i]-1))
        {
            var val = hash[A[i]-1];
            hash.Remove(A[i]);
            hash.Add(A[i], val + 1); 
        }
        else
        {
            hash.Add(A[i], 1);
        }
        if (LIS_size < hash[A[i]]) 
        {
            LIS_size = hash[A[i]];
            LIS_index = A[i];
        }
    }
  
    // print LIS size
    Console.WriteLine("LIS_size = " + LIS_size);
  
    // print LIS after setting start element
    Console.Write("LIS : ");
    int start = LIS_index - LIS_size + 1;
    while (start <= LIS_index)
    {
        Console.Write(start + " ");
        start++;
    }
}
  
// Driver code
public static void Main(String[] args)
{
    int []A = { 2, 5, 3, 7, 4, 8, 5, 13, 6 };
    int n = A.Length;
    findLIS(A, n);
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output:

LIS_size = 5
LIS : 2 3 4 5 6 


My Personal Notes arrow_drop_up

Discovering ways to develop a plane for soaring career goals

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





Article Tags :
Practice Tags :


4


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.