Longest Common Increasing Subsequence (LCS + LIS)

// A C# Program to find length of the Longest
// Common Increasing Subsequence (LCIS)
using System;

class GfG {

    // Recursive function to find the LCIS
    static int FindLCIS(int i, int j, int prevIndex,
                        int[] a, int[] b) {
      
        // Base case: If either array is fully traversed
        if (i < 0 || j < 0) {
            return 0;
        }

        int include = 0;
        int exclude = 0;

        // If current elements are equal and satisfy the
        // increasing condition
        if (a[i] == b[j] && (prevIndex == -1 || a[i] < a[prevIndex])) {
          
           // Include the current element
            include
                = 1
                  + FindLCIS(i - 1, j - 1, i, a, b);
        }

        // Explore skipping an element from either array
        exclude = Math.Max(
            FindLCIS(i - 1, j, prevIndex, a, b),
            FindLCIS(i, j - 1, prevIndex, a, b));

        // Return the maximum of including or excluding the
        // current element
        return Math.Max(include, exclude);
    }

    static int LCIS(int[] a, int[] b) {
      
        // Start recursion from the last indices with no
        // previous element
        return FindLCIS(a.Length - 1, b.Length - 1,
                        -1, a, b);
    }

    static void Main() {
      
        int[] a = { 3, 4, 9, 1 };
        int[] b = { 5, 3, 8, 9, 10, 2, 1 };

        Console.Write(LCIS(a, b));
    }
}

// A C# program to find length of the Longest Common
// Increasing Subsequence (LCIS) using memoization
using System;

class GfG {
  
    // Recursive function with memoization to find LCIS
    static int FindLCIS(int i, int j, int prevIndex,
                                int[] a, int[] b,
                                int[, , ] memo){
      
        // Base case: If either array is fully traversed
        if (i < 0 || j < 0)
            return 0;

        // If the result has already been computed, return
        // it
        if (memo[i, j, prevIndex + 1] != -1)
            return memo[i, j, prevIndex + 1];

        int include = 0;
        int exclude = 0;

        // If the current elements match and satisfy the
        // increasing condition
        if (a[i] == b[j]
            && (prevIndex == -1
                || a[i] < a[prevIndex])) {
          
          // Include the current element
            include
                = 1
                  + FindLCIS(
                      i - 1, j - 1, i, a, b,
                      memo); 
        }

        // Explore excluding the current element from either
        // array
        exclude = Math.Max(
            FindLCIS(i - 1, j, prevIndex, a, b, memo),
            FindLCIS(i, j - 1, prevIndex, a, b,
                     memo));

        // Store the result in the memo table and return it
        memo[i, j, prevIndex + 1]
            = Math.Max(include, exclude);
        return memo[i, j, prevIndex + 1];
    }

    // Function to initialize the memo table and start the
    // recursion
    static int LCIS(int[] a, int[] b){
        int m = a.Length;
        int n = b.Length;

        // Initialize the memoization table with -1
        // (indicating uncomputed states)
        int[, , ] memo = new int[m, n, m + 1];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                for (int k = 0; k < m + 1; k++) {
                    memo[i, j, k] = -1;
                }
            }
        }

        // Start recursion from the last indices with no
        // previous element
        return FindLCIS(m - 1, n - 1, -1, a, b, memo);
    }

    static void Main(string[] args){
        int[] a = {3, 4, 9, 1 };
        int[] b = { 5, 3, 8, 9, 10, 2, 1 };
        Console.WriteLine(LCIS(a, b));
    }
}

// C# Program to find length of the Longest Common
// Increasing Subsequence (LCIS) using tabulation
using System;

class GfG {
    static int LCIS(int[] a, int[] b) {
        int m = a.Length;
        int n = b.Length;

        // Initialize a DP array to store lengths
      	// of LCIS ending at each index of b
        int[] dp = new int[n];

        // Iterate through each element in a
        for (int i = 0; i < m; i++) {
            int currentLength = 0;

            // Iterate through each element in b
            for (int j = 0; j < n; j++) {
              
                // If a[i] == b[j], we may have found
              	// a new LCIS ending at j in b
                if (a[i] == b[j]) {
                    dp[j] = Math.Max(dp[j], currentLength + 1);
                }
              
                // If a[i] > b[j], it means b[j] could be
              	// part of an increasing subsequence
                else if (a[i] > b[j]) {
                    currentLength = Math.Max(currentLength, dp[j]);
                }
            }
        }

        // The maximum value in dp[] is the length of the
      	// longest common increasing subsequence
        int result = 0;
        foreach (int value in dp) {
            result = Math.Max(result, value);
        }

        return result;
    }

    static void Main() {
        int[] a = { 3, 4, 9, 1 };
        int[] b = {5, 3, 8, 9, 10, 2, 1 };
        Console.WriteLine(LCIS(a, b));
    }
}