Skip to content
Related Articles

Related Articles

Improve Article

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

  • Difficulty Level : Medium
  • Last Updated : 12 Aug, 2021

Given an array of random numbers, find the 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):

C++




// 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;
}

Java




// Java implementation
// to find LIS
import java.util.*;
class GFG{
 
// Return length of LIS
// in arr[] of size N
static int lis(int arr[],
               int N)
{
  int i;
  HashSet<Integer> s = new HashSet<>();
  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
    // org/set-insert-function-in-c-stl/
    int k = 0;
    int size = s.size();
    if (s.add(arr[i]))
    {
      // Find the position of
      // inserted element in iterator k
      if(s.contains(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.
      if (size == s.size())
        s.remove(k + 1);
    }
  }
 
  // Note that set s may not contain
  // actual LIS, but its size gives
  // us the length of LIS
  return s.size();
}
 
public static void main(String[] args)
{
  int arr[] = {8, 9, 12, 10, 11};
  int n = arr.length;
  System.out.print(lis(arr, n) + "\n");
}
}
 
// This code is contributed by gauravrajput1

C#




// C# implementation
// to find LIS
using System;
using System.Collections.Generic;
 
class GFG{
     
// Return length of LIS
// in arr[] of size N
static int lis(int[] arr, int N)
{
    int i;
    HashSet<int> s = new HashSet<int>();
    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
        int k = 0;
        int size = s.Count;
         
        if (s.Add(arr[i]))
        {
             
            // Find the position of inserted
            // element in iterator k
            if (s.Contains(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.
            if (size == s.Count)
                s.Remove(k + 1);
        }
    }
     
    // Note that set s may not contain
    // actual LIS, but its size gives
    // us the length of LIS
    return s.Count;
}
 
// Driver code
static public void Main()
{
    int[]    arr = { 8, 9, 12, 10, 11 };
    int n = arr.Length;
     
    Console.Write(lis(arr, n) + "\n");
}
}
 
// This code is contributed by avanitrachhadiya2155

Javascript




<script>
 
// Javascript implementation
// to find LIS
 
// Return length of LIS
// in arr[] of size N
function lis(arr,N)
{
    let i;
  let s = new Set();
  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
    // org/set-insert-function-in-c-stl/
    let k = 0;
    let size = s.size;
    if (s.add(arr[i]))
    {
      // Find the position of
      // inserted element in iterator k
      if(s.has(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.
      if (size == s.size)
        s.delete(k + 1);
    }
  }
  
  // Note that set s may not contain
  // actual LIS, but its size gives
  // us the length of LIS
  return s.size;
}
 
let arr=[8, 9, 12, 10, 11];
let n = arr.length;
document.write(lis(arr, n) + "<br>");
 
// This code is contributed by unknown2108
 
</script>
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
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :