# Longest Common Increasing Subsequence (LCS + LIS)

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.

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

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

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.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

My Personal Notes arrow_drop_up