Related Articles

# Longest Common Increasing Subsequence (LCS + LIS)

• Difficulty Level : Hard
• Last Updated : 31 Mar, 2021

Prerequisites : LCS, LIS
Given two arrays, find length of the longest common increasing subsequence [LCIS] and print one of such sequences (multiple sequences may exist)
Suppose we consider two arrays –
arr1[] = {3, 4, 9, 1} and
arr2[] = {5, 3, 8, 9, 10, 2, 1}
Our answer would be {3, 9} as this is the longest common subsequence which is increasing also.

The idea is to use dynamic programming here as well. We store the longest common increasing sub-sequence ending at each index of arr2[]. We create an auxiliary array table[] such that table[j] stores length of LCIS ending with arr2[j]. At the end, we return maximum value from this table. For filling values in this table, we traverse all elements of arr1[] and for every element arr1[i], we traverse all elements of arr2[]. If we find a match, we update table[j] with length of current LCIS. To maintain current LCIS, we keep checking valid table[j] values.
Below is the program to find length of LCIS.

## C++

 `// A C++ Program to find length of the Longest Common``// Increasing Subsequence (LCIS)``#include``using` `namespace` `std;` `// Returns the length and the LCIS of two``// arrays arr1[0..n-1] and arr2[0..m-1]``int` `LCIS(``int` `arr1[], ``int` `n, ``int` `arr2[], ``int` `m)``{``    ``// table[j] is going to store length of LCIS``    ``// ending with arr2[j]. We initialize it as 0,``    ``int` `table[m];``    ``for` `(``int` `j=0; j table[j])``                    ``table[j] = current + 1;` `            ``/* Now seek for previous smaller common``               ``element for current element of arr1 */``            ``if` `(arr1[i] > arr2[j])``                ``if` `(table[j] > current)``                    ``current = table[j];``        ``}``    ``}` `    ``// The maximum value in table[] is out result``    ``int` `result = 0;``    ``for` `(``int` `i=0; i result)``           ``result = table[i];` `    ``return` `result;``}` `/* Driver program to test above function */``int` `main()``{``    ``int` `arr1[] = {3, 4, 9, 1};``    ``int` `arr2[] = {5, 3, 8, 9, 10, 2, 1};` `    ``int` `n = ``sizeof``(arr1)/``sizeof``(arr1);``    ``int` `m = ``sizeof``(arr2)/``sizeof``(arr2);` `    ``cout << ``"Length of LCIS is "``         ``<< LCIS(arr1, n, arr2, m);``    ``return` `(0);``}`

## Java

 `// A Java Program to find length of the Longest``// Common Increasing Subsequence (LCIS)``import` `java.io.*;` `class` `GFG {` `    ``// Returns the length and the LCIS of two``    ``// arrays arr1[0..n-1] and arr2[0..m-1]``    ``static` `int` `LCIS(``int` `arr1[], ``int` `n, ``int` `arr2[],``                                         ``int` `m)``    ``{``        ``// table[j] is going to store length of``        ``// LCIS ending with arr2[j]. We initialize``        ``// it as 0,``        ``int` `table[] = ``new` `int``[m];``        ``for` `(``int` `j = ``0``; j < m; j++)``            ``table[j] = ``0``;` `        ``// Traverse all elements of arr1[]``        ``for` `(``int` `i = ``0``; i < n; i++)``        ``{``            ``// Initialize current length of LCIS``            ``int` `current = ``0``;` `            ``// For each element of arr1[], trvarse``            ``// all elements of arr2[].``            ``for` `(``int` `j = ``0``; j < m; j++)``            ``{``                ``// If both the array have same``                ``// elements. Note that we don't``                ``// break the loop here.``                ``if` `(arr1[i] == arr2[j])``                    ``if` `(current + ``1` `> table[j])``                        ``table[j] = current + ``1``;` `                ``/* Now seek for previous smaller``                ``common element for current``                ``element of arr1 */``                ``if` `(arr1[i] > arr2[j])``                    ``if` `(table[j] > current)``                        ``current = table[j];``            ``}``        ``}` `        ``// The maximum value in table[] is out``        ``// result``        ``int` `result = ``0``;``        ``for` `(``int` `i=``0``; i result)``            ``result = table[i];` `        ``return` `result;``    ``}` `    ``/* Driver program to test above function */``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr1[] = {``3``, ``4``, ``9``, ``1``};``        ``int` `arr2[] = {``5``, ``3``, ``8``, ``9``, ``10``, ``2``, ``1``};` `        ``int` `n = arr1.length;``        ``int` `m = arr2.length;` `    ``System.out.println(``"Length of LCIS is "` `+``                       ``LCIS(arr1, n, arr2, m));``    ``}``}``// This code is contributed by Prerna Saini`

## Python 3

 `# Python 3 Program to find length of the``# Longest Common Increasing Subsequence (LCIS)` `# Returns the length and the LCIS of two``# arrays arr1[0..n-1] and arr2[0..m-1]``def` `LCIS(arr1, n, arr2, m):` `    ``# table[j] is going to store length of LCIS``    ``# ending with arr2[j]. We initialize it as 0,``    ``table ``=` `[``0``] ``*` `m``    ``for` `j ``in` `range``(m):``        ``table[j] ``=` `0` `    ``# Traverse all elements of arr1[]``    ``for` `i ``in` `range``(n):``    ` `        ``# Initialize current length of LCIS``        ``current ``=` `0` `        ``# For each element of arr1[],``        ``# traverse all elements of arr2[].``        ``for` `j ``in` `range``(m):``            ` `            ``# If both the array have same elements.``            ``# Note that we don't break the loop here.``            ``if` `(arr1[i] ``=``=` `arr2[j]):``                ``if` `(current ``+` `1` `> table[j]):``                    ``table[j] ``=` `current ``+` `1` `            ``# Now seek for previous smaller common``            ``# element for current element of arr1``            ``if` `(arr1[i] > arr2[j]):``                ``if` `(table[j] > current):``                    ``current ``=` `table[j]` `    ``# The maximum value in table[]``    ``# is out result``    ``result ``=` `0``    ``for` `i ``in` `range``(m):``        ``if` `(table[i] > result):``            ``result ``=` `table[i]` `    ``return` `result` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``arr1 ``=` `[``3``, ``4``, ``9``, ``1``]``    ``arr2 ``=` `[``5``, ``3``, ``8``, ``9``, ``10``, ``2``, ``1``]` `    ``n ``=` `len``(arr1)``    ``m ``=` `len``(arr2)` `    ``print``(``"Length of LCIS is"``,``           ``LCIS(arr1, n, arr2, m))` `# This code is contributed by ita_c`

## C#

 `// A C# Program to find length of the Longest``// Common Increasing Subsequence (LCIS)``using` `System;` `class` `GFG {` `    ``// Returns the length and the LCIS of two``    ``// arrays arr1[0..n-1] and arr2[0..m-1]``    ``static` `int` `LCIS(``int` `[]arr1, ``int` `n,``                    ``int` `[]arr2, ``int` `m)``    ``{``        ``// table[j] is going to store length of``        ``// LCIS ending with arr2[j]. We initialize``        ``// it as 0,``        ``int` `[]table = ``new` `int``[m];``        ``for` `(``int` `j = 0; j < m; j++)``            ``table[j] = 0;` `        ``// Traverse all elements of arr1[]``        ``for` `(``int` `i = 0; i < n; i++)``        ``{``            ``// Initialize current length of LCIS``            ``int` `current = 0;` `            ``// For each element of arr1[], trvarse``            ``// all elements of arr2[].``            ``for` `(``int` `j = 0; j < m; j++)``            ``{``                ``// If both the array have same``                ``// elements. Note that we don't``                ``// break the loop here.``                ``if` `(arr1[i] == arr2[j])``                    ``if` `(current + 1 > table[j])``                        ``table[j] = current + 1;` `                ``/* Now seek for previous smaller``                   ``common element for current``                   ``element of arr1 */``                ``if` `(arr1[i] > arr2[j])``                    ``if` `(table[j] > current)``                        ``current = table[j];``            ``}``        ``}` `        ``// The maximum value in``        ``// table[] is out result``        ``int` `result = 0;``        ``for` `(``int` `i = 0; i < m; i++)``            ``if` `(table[i] > result)``            ``result = table[i];` `        ``return` `result;``    ``}` `    ``/* Driver program to test above function */``    ``public` `static` `void` `Main()``    ``{``        ``int` `[]arr1 = {3, 4, 9, 1};``        ``int` `[]arr2 = {5, 3, 8, 9, 10, 2, 1};` `        ``int` `n = arr1.Length;``        ``int` `m = arr2.Length;` `    ``Console.Write(``"Length of LCIS is "` `+``                   ``LCIS(arr1, n, arr2, m));``    ``}``}` `// This code is contributed by nitin mittal.`

## PHP

 ` ``\$table``[``\$j``])``                    ``\$table``[``\$j``] = ``\$current` `+ 1;` `            ``/* Now seek for previous smaller``            ``common element for current``            ``element of arr1 */``            ``if` `(``\$arr1``[``\$i``] > ``\$arr2``[``\$j``])``                ``if` `(``\$table``[``\$j``] > ``\$current``)``                    ``\$current` `= ``\$table``[``\$j``];``        ``}``    ``}` `    ``// The maximum value in``    ``// table[] is out result``    ``\$result` `= 0;``    ``for` `(``\$i` `= 0; ``\$i` `< ``\$m``; ``\$i``++)``        ``if` `(``\$table``[``\$i``] > ``\$result``)``        ``\$result` `= ``\$table``[``\$i``];` `    ``return` `\$result``;``}` `// Driver Code``\$arr1` `= ``array` `(3, 4, 9, 1);``\$arr2` `= ``array` `(5, 3, 8, 9, 10, 2, 1);` `\$n` `= sizeof(``\$arr1``);``\$m` `= sizeof(``\$arr2``);` `echo` `"Length of LCIS is "``,``       ``LCIS(``\$arr1``, ``\$n``, ``\$arr2``, ``\$m``);` `// This code is contributed by ajit``?>`

## Javascript

 ``

Output :

`Length of LCIS is 2`

This article is contributed Rachit Belwariar. If you like GeeksforGeeks and would like to contribute, you can also write an article and mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.