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