Related Articles

# C++ Program for Longest Increasing Subsequence

• Difficulty Level : Medium
• Last Updated : 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++

 `/* Dynamic Programming C/C++ implementation of LIS problem */``#include ``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);``    ``cout <<``"Length of lis is "``<< lis(arr, n);``    ``return` `0;``}`  `// this code is contributed by shivanisinghss2110`

## C

 `/* Dynamic Programming C/C++ implementation of LIS problem */``#include ``#include ` `/* 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);``    ``printf``(``"Length of lis is %d\n"``, lis(arr, n));``    ``return` `0;``}`

## Java

 `/* 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`

## Python3

 `# 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`

## C#

 `/* Dynamic Programming Java 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`

## Javascript

 ``
Output:
`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 ``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;``}`
Output
`5`
Want to learn from the best curated videos and practice problems, check out the C++ Foundation Course for Basic to Advanced C++ and C++ STL Course for the language and STL. To complete your preparation from learning a language to DS Algo and many more, please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up