Longest Common Increasing Subsequence (LCS + LIS) - GeeksforGeeks

22 Dec, 2021
Prerequisites : LCS, LISGiven 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++
Java
Python 3
C#
PHP
Javascript
// A C++ Program to find length of the Longest Common// Increasing Subsequence (LCIS)#include<bits/stdc++.h>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<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 */int main(){    int arr1[] = {3, 4, 9, 1};    int arr2[] = {5, 3, 8, 9, 10, 2, 1};      int n = sizeof(arr1)/sizeof(arr1[0]);    int m = sizeof(arr2)/sizeof(arr2[0]);      cout << "Length of LCIS is "         << LCIS(arr1, n, arr2, m);    return (0);}
// 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<m; i++)            if (table[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 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 Codeif __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
// 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// PHP 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]function LCIS($arr1, $n, $arr2, $m){    // table[j] is going to store     // length of LCIS ending with     // arr2[j]. We initialize it as 0,          $table = Array();          //int table[m];    for ($j = 0; $j < $m; $j++)        $table[$j] = 0;      // Traverse all elements of arr1[]    for ($i = 0; $i < $n; $i++)    {        // Initialize current        // length of LCIS        $current = 0;          // For each element of         // arr1[], traverse all        // elements of arr2[].        for ($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    $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 ?>
<script>  // Javascript 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]    function LCIS(arr1, n, arr2, m)    {        // table[j] is going to store length of         // LCIS ending with arr2[j]. We initialize        // it as 0,        let table = [];        for (let j = 0; j < m; j++)            table[j] = 0;            // Traverse all elements of arr1[]        for (let i = 0; i < n; i++)        {            // Initialize current length of LCIS            let current = 0;                // For each element of arr1[], traverse             // all elements of arr2[].            for (let 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        let result = 0;        for (let i=0; i<m; i++)            if (table[i] > result)            result = table[i];            return result;    }      // Driver Code          let arr1 = [3, 4, 9, 1];        let arr2 = [5, 3, 8, 9, 10, 2, 1];            let n = arr1.length;        let m = arr2.length;        document.write("Length of LCIS is " +                       LCIS(arr1, n, arr2, m));                        </script>
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.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
nitin mittal
jit_t
AyanBanerjee
ukasp
mohit kumar 29
souravghosh0416
simranarora5sos
LCS
LIS
subsequence
Arrays
Dynamic Programming
Arrays
Dynamic Programming
LCS
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Window Sliding Technique
Program to find sum of elements in a given array
Reversal algorithm for array rotation
Trapping Rain Water
Move all negative numbers to beginning and positive to end with constant extra space
0-1 Knapsack Problem | DP-10
Program for Fibonacci numbers
Bellman–Ford Algorithm | DP-23
Longest Common Subsequence | DP-4
Floyd Warshall Algorithm | DP-16