C++ Program for Longest Increasing Subsequence
Last Updated :
04 Apr, 2023
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++
/* 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 implementation
of 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 n
def 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 Code
arr = [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 C# implementation
of 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 implementation
of 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>
Output: Length of lis is 5
Complexity Analysis:
Time Complexity: O(n2). As nested loop is used.
Auxiliary Space: O(n).
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;
}
// Java code for above approach
import java.util.*;
public class Main {
public static int longestIncreasingSubsequence(List<Integer> arr) {
List<Integer> ans = new ArrayList<>();
int n = arr.size();
for (int i = 0; i < n; i++) {
int it = arr.get(i);
int idx = Collections.binarySearch(ans, it);
if (idx < 0) {
idx = -(idx + 1);
if (idx == ans.size()) {
ans.add(it);
} else {
ans.set(idx, it);
}
}
}
return ans.size();
}
public static void main(String[] args) {
List<Integer> a = Arrays.asList(10, 22, 9, 33, 21, 50, 41, 60);
int ans = longestIncreasingSubsequence(a);
System.out.println(ans);
}
}
// This code is contributed by Aman Kumar.
using System;
using System.Collections.Generic;
public class Program {
public static int
LongestIncreasingSubsequence(List<int> arr)
{
List<int> ans = new List<int>();
List<int> prevIdx = new List<int>();
int n = arr.Count;
for (int i = 0; i < n; i++) {
var it = ans.BinarySearch(arr[i]);
if (it < 0) {
it = ~it;
if (it == ans.Count) {
ans.Add(arr[i]);
prevIdx.Add(ans.Count - 2);
}
else {
ans[it] = arr[i];
prevIdx.Add(it == 0 ? -1
: prevIdx[it - 1]);
}
}
else {
prevIdx.Add(it == 0 ? -1 : prevIdx[it - 1]);
}
}
int len = ans.Count;
List<int> subseq = new List<int>();
int idx = len - 1;
while (idx >= 0) {
subseq.Add(ans[idx]);
idx = prevIdx[idx];
}
subseq.Reverse();
return len;
}
public static void Main()
{
List<int> a = new List<int>{ 10, 22, 9, 33,
21, 50, 41, 60 };
int ans = LongestIncreasingSubsequence(a);
Console.WriteLine(ans);
}
}
// This code is contributed by user_dtewbxkn77n
Time Complexity: O(nlogn) , n = size of array.
Space Complexity: O(n)
Similar Reads
C/C++ Program for Longest Increasing Subsequence Given an array arr[] of size N, the task is to find the length of the Longest Increasing Subsequence (LIS) i.e., the longest possible subsequence in which the elements of the subsequence are sorted in increasing order. Examples: Input: arr[] = {3, 10, 2, 1, 20}Output: 3Explanation: The longest incre
8 min read
Maximum contiguous decreasing sequence obtained by removing any one element Given an array arr[] of N integers. The task is to find the length of the contiguous strictly decreasing sequence that can be derived after removing at most one element from the array arr[]. Examples Input: arr[] = {8, 7, 3, 5, 2, 9} Output: 4 Explanation: If we remove 3, The maximum length of decre
10 min read
Maximum length sub-array which satisfies the given conditions Given an array arr[] of N integers, the task is to find the maximum length of any sub-array of arr[] which satisfies one of the given conditions: The subarray is strictly increasing.The subarray is strictly decreasing.The subarray is first strictly increasing then strictly decreasing. Examples: Inpu
9 min read
Length of longest strictly increasing subset with each pair of adjacent elements satisfying the condition 2 * A[i] ≥ A[i + 1] Given an array A[] of size N, the task is to find the length of the longest strictly increasing subset with every pair of adjacent elements satisfying the condition A[i + 1] ? 2 * A[i]. If multiple such subsets are present, then print any one of them. Examples: Input: A[] = {3, 1, 5, 11}Output: 3, 5
9 min read
Java Program for Longest Increasing Subsequence 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,
5 min read