Longest Monotonically Increasing Subsequence Size (N log N): Simple implementation

Given an array of random numbers, find longest monotonically increasing subsequence (LIS) in the array.

If you want to understand the O(NlogN) approach, it’s explained very clearly here.

In this post, a simple and time saving implementation of O(NlogN) approach using stl is discussed. Below is the code for LIS O(NlogN) :

filter_none

edit
close

play_arrow

link
brightness_4
code

// A simple C++ implementation to find LIS
#include<iostream>
#include<algorithm>
#include<set>
using namespace std;
  
// Return length of LIS in arr[] of size N
int lis(int arr[], int N)
{
    int i;
    set<int> s;
    set<int>::iterator k;
    for (i=0; i<N; i++)
    {
        // Check if the element was actually inserted
        // An element in set is not inserted if it is
        // already present. Please see
        if (s.insert(arr[i]).second)
        {
            // Find the position of inserted element in iterator k
            k = s.find(arr[i]);
  
            k++;  // Find the next greater element in set
  
            // If the new element is not inserted at the end, then
            // remove the greater element next to it (This is tricky)
            if (k!=s.end()) s.erase(k);
        }
    }
  
    // Note that set s may not contain actual LIS, but its size gives
    // us the length of LIS
    return s.size();
}
  
int main()
{
    int arr[] = {8, 9, 12, 10, 11};
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << lis(arr, n)<< endl;
}

chevron_right


Output:

4

This article is contributed by Raj Kumar. 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 : warlockx



Article Tags :
Practice Tags :


Be the First to upvote.


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