# Longest Common Increasing Subsequence (LCS + LIS)

• Difficulty Level : Hard
• Last Updated : 22 Dec, 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[], traverse ``            ``// 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[], traverse ``            ``// 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 review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.