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++
// 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; } |
Java
// 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 |
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 |
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.