Related Articles
Largest increasing subsequence of consecutive integers
• Difficulty Level : Medium
• Last Updated : 11 Jul, 2019

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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

 `// C++ implementation of longest continuous increasing ` `// subsequence ` `#include ` `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; ` `} `

## Java

 `// Java implementation of longest continuous increasing ` `// subsequence ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `// Function for LIS ` `static` `void` `findLIS(``int` `A[], ``int` `n) ` `{ ` `    ``Map hash = ``new` `HashMap(); ` ` `  `    ``// 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 `

## Python3

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

## C#

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

Output:

```LIS_size = 5
LIS : 2 3 4 5 6
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :