C++ Program for Longest Increasing Subsequence - GeeksforGeeks

15 Sep, 2021
The Longest Increasing Subsequence (LIS) problem is to find the length of the longest subsequence of a given sequence such that all elements of the subsequence are sorted in increasing order. For example, the length of LIS for {10, 22, 9, 33, 21, 50, 41, 60, 80} is 6 and LIS is {10, 22, 33, 50, 60, 80}. 
Examples: 
Input  : arr[] = {3, 10, 2, 1, 20}
Output : Length of LIS = 3
The longest increasing subsequence is 3, 10, 20

Input  : arr[] = {3, 2}
Output : Length of LIS = 1
The longest increasing subsequences are {3} and {2}

Input : arr[] = {50, 3, 10, 7, 40, 80}
Output : Length of LIS = 4
The longest increasing subsequence is {3, 7, 40, 80}
Overlapping Subproblems: Considering the above implementation, the following is a recursion tree for an array of size 4. lis(n) gives us the length of LIS for arr[].  
              lis(4)
        /        |     
      lis(3)    lis(2)   lis(1)
     /           /
   lis(2) lis(1) lis(1)
   /
lis(1)
We can see that there are many subproblems that are solved again and again. So this problem has Overlapping Substructure property and recomputation of same subproblems can be avoided by either using Memoization or Tabulation. Following is a tabulated implementation for the LIS problem. 
C++
C
Java
Python3
C#
Javascript
/* Dynamic Programming C/C++ implementation of LIS problem */#include <iostream>using namespace std; /* lis() returns the length of the longest increasing  subsequence in arr[] of size n */int lis(int arr[], int n){    int *lis, i, j, max = 0;    lis = (int*)malloc(sizeof(int) * n);     /* Initialize LIS values for all indexes */    for (i = 0; i < n; i++)        lis[i] = 1;     /* Compute optimized LIS values in bottom up manner */    for (i = 1; i < n; i++)        for (j = 0; j < i; j++)            if (arr[i] > arr[j] && lis[i] < lis[j] + 1)                lis[i] = lis[j] + 1;     /* Pick maximum of all LIS values */    for (i = 0; i < n; i++)        if (max < lis[i])            max = lis[i];     /* Free memory to avoid memory leak */    free(lis);     return max;} /* Driver program to test above function */int main(){    int arr[] = { 10, 22, 9, 33, 21, 50, 41, 60 };    int n = sizeof(arr) / sizeof(arr[0]);    cout <<"Length of lis is "<< lis(arr, n);    return 0;}  // this code is contributed by shivanisinghss2110
/* Dynamic Programming C/C++ implementation of LIS problem */#include <stdio.h>#include <stdlib.h> /* lis() returns the length of the longest increasing  subsequence in arr[] of size n */int lis(int arr[], int n){    int *lis, i, j, max = 0;    lis = (int*)malloc(sizeof(int) * n);     /* Initialize LIS values for all indexes */    for (i = 0; i < n; i++)        lis[i] = 1;     /* Compute optimized LIS values in bottom up manner */    for (i = 1; i < n; i++)        for (j = 0; j < i; j++)            if (arr[i] > arr[j] && lis[i] < lis[j] + 1)                lis[i] = lis[j] + 1;     /* Pick maximum of all LIS values */    for (i = 0; i < n; i++)        if (max < lis[i])            max = lis[i];     /* Free memory to avoid memory leak */    free(lis);     return max;} /* Driver program to test above function */int main(){    int arr[] = { 10, 22, 9, 33, 21, 50, 41, 60 };    int n = sizeof(arr) / sizeof(arr[0]);    printf("Length of lis is %d\n", lis(arr, n));    return 0;}
/* Dynamic Programming Java implementationof LIS problem */import java.util.*; class GFG{     /*    * lis() returns the length of the longest    * increasing subsequence in arr[] of size n    */    static int lis(int[] arr, int n)    {        int max = 0;        int[] lst = new int[n];         // initialize LIS values for all indexes        Arrays.fill(lst, 1);         /* Compute optimized LIS values        in bottom up manner */        for (int i = 1; i < n; i++)        {            for (int j = 0; j < i; j++)            {                if (arr[i] > arr[j] &&                    lst[i] < lst[j] + 1)                    lst[i] = lst[j] + 1;            }        }         /* Pick maximum of all LIS values */        for (int i = 0; i < n; i++)            if (max < lst[i])                max = lst[i];         return max;    }     // Driver Code    public static void main(String[] args)    {        int[] arr = { 10, 22, 9, 33, 21, 50, 41, 60 };        int n = arr.length;        System.out.println("Length of lis is " +                                   lis(arr, n));    }} // This code is contributed by// sanjeev2552
# Dynamic Programming python3# implementation of LIS problem # lis() returns the length of the# longest increasing subsequence# in arr[] of size ndef lis(arr, n):    i, j, maxm = 0, 0, 0         # initialize LIS values for all indexes    lst = [1 for s in range(n)]         for i in range(1, n):        for j in range(0, i):            if (arr[i] > arr[j] and                lst[i] < lst[j] + 1):                lst[i] = lst[j] + 1         # Pick maximum of all LIS values    for i in range(0, n):        if maxm < lst[i]:            maxm = lst[i]         return maxm # Driver Codearr = [10, 22, 9, 33, 21, 50, 41, 60]n = len(arr)print("Length of lst is", lis(arr, n)) # This code is contributed# by Mohit kumar 29
/* Dynamic Programming Java implementationof LIS problem */using System;public class GFG{   /*    * lis() returns the length of the longest     * increasing subsequence in arr[] of size n    */  static int lis(int[] arr, int n)   {    int max = 0;    int[] lst = new int[n];     // initialize LIS values for all indexes    Array.Fill(lst, 1);     /* Compute optimized LIS values         in bottom up manner */    for (int i = 1; i < n; i++)     {      for (int j = 0; j < i; j++)       {        if (arr[i] > arr[j] && lst[i] < lst[j] + 1)        {           lst[i] = lst[j] + 1;        }      }    }     /* Pick maximum of all LIS values */    for (int i = 0; i < n; i++)      if (max < lst[i])        max = lst[i];    return max;  }   // Driver code  static public void Main ()  {    int[] arr = { 10, 22, 9, 33, 21, 50, 41, 60 };    int n = arr.Length;    Console.WriteLine("Length of lis is " +  lis(arr, n));  }} // This code is contributed by avanitrachhadiya2155
<script>/* Dynamic Programming Javascript implementationof LIS problem */         /*    * lis() returns the length of the longest    * increasing subsequence in arr[] of size n    */    function lis(arr,n)    {        let max = 0;        let lst = new Array(n);          // initialize LIS values for all indexes        for(let i=0;i<lst.length;i++)        {            lst[i]=1;        }                   /* Compute optimized LIS values        in bottom up manner */        for (let i = 1; i < n; i++)        {            for (let j = 0; j < i; j++)            {                if (arr[i] > arr[j] &&                    lst[i] < lst[j] + 1)                    lst[i] = lst[j] + 1;            }        }          /* Pick maximum of all LIS values */        for (let i = 0; i < n; i++)            if (max < lst[i])                max = lst[i];          return max;    }         // Driver Code    let arr=[10, 22, 9, 33, 21, 50, 41, 60 ];    let n = arr.length;    document.write("Length of lis is " +                                   lis(arr, n));  // This code is contributed by patel2127</script>
Length of lis is 5
 
Please refer complete article on Dynamic Programming | Set 3 (Longest Increasing Subsequence) for more details! 
Method 2 : Lower Bound based approach
Algorithm :
1. Iterate the array.
2. Declare a new array ans to add the newly constructed increasing subsequence.
2. For every index, if lower_bound is points to the ending of the array ans, push it into a vector ans.
3. Return the ans array size.
C++
#include <bits/stdc++.h>using namespace std;int longest_increasing_subsequence(vector<int>& arr){    vector<int> ans;    int n = arr.size();    for (int i = 0; i < n; i++) {        auto it            = lower_bound(ans.begin(), ans.end(), arr[i]);        if (it == ans.end()) {            ans.push_back(arr[i]);        }        else {            *it = arr[i];        }    }    return ans.size();}int main(){    vector<int> a = { 10, 22, 9, 33, 21, 50, 41, 60 };    int ans = longest_increasing_subsequence(a);    cout << ans;    return 0;}
5
mohit kumar 29
sanjeev2552
avanitrachhadiya2155
patel2127
adityamutharia
sweetyty
shivanisinghss2110
LIS
C++ Programs
Dynamic Programming
Dynamic Programming
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Passing a function as a parameter in C++
Const keyword in C++
Program to implement Singly Linked List in C++ using class
cout in C++
Dynamic _Cast in C++
0-1 Knapsack Problem | DP-10
Program for Fibonacci numbers
Largest Sum Contiguous Subarray
Longest Common Subsequence | DP-4
Bellman–Ford Algorithm | DP-23