Length of the longest increasing subsequence which does not contain a given sequence as Subarray

// Java program for the above approach

import java.io.*;
import java.util.*;

class GFG {

    // Initialize dp and KMP array
    static int[][][] dp;
    static int[] KMPArray;

    // Length of the given sequence[]
    static int m;

    // Function to find the max-length
    // subsequence that does not have
    // subarray sequence[]
    private static int findSubsequence(
        int[] a, int[] sequence,
        int i, int prev, int k)
    {
        // Stores the subsequence
        // explored so far
        if (k == m)
            return Integer.MIN_VALUE;

        // Base Case
        if (i == a.length)
            return 0;

        // Using memoization to
        // avoid re-computation
        if (prev != -1
            && dp[i][prev][k] != -1) {
            return dp[i][prev][k];
        }

        int include = 0;

        if (prev == -1 || a[i] >= a[prev]) {
            int k2 = k;

            // Using KMP array to find
            // corresponding index in arr1[]
            while (k2 > 0
                   && a[i] != sequence[k2])
                k2 = KMPArray[k2 - 1];

            // Incrementing k2 as we are
            // including this element in
            // the subsequence
            if (a[i] == sequence[k2])
                k2++;

            // Possible answer for
            // current state
            include = 1
                      + findSubsequence(
                            a, sequence,
                            i + 1, i, k2);
        }

        // Maximum answer for
        // current state
        int ans = Math.max(
            include, findSubsequence(
                         a, sequence,
                         i + 1, prev, k));

        // Memoizing the answer for
        // the corresponding state
        if (prev != -1) {
            dp[i][prev][k] = ans;
        }

        // Return the answer for
        // current state
        return ans;
    }

    // Function that generate KMP Array
    private static void
    fillKMPArray(int[] pattern)
    {
        // Previous longest prefix suffix
        int j = 0;

        int i = 1;

        // KMPArray[0] is a always 0
        KMPArray[0] = 0;

        // The loop calculates KMPArray[i]
        // for i = 1 to M - 1
        while (i < m) {

            // If current character is
            // same
            if (pattern[i] == pattern[j]) {
                j++;

                // Update the KMP array
                KMPArray[i] = j;
                i++;
            }

            // Otherwise
            else {

                // Update the KMP array
                if (j != 0)
                    j = KMPArray[j - 1];
                else {
                    KMPArray[i] = j;
                    i++;
                }
            }
        }
    }

    // Function to print the maximum
    // possible length
    static void printAnswer(
        int a[], int sequence[])
    {

        // Length of the given sequence
        m = sequence.length;

        // Initialize kmp array
        KMPArray = new int[m];

        // Generate KMP array
        fillKMPArray(sequence);

        // Initialize dp
        dp = new int[a.length][a.length][a.length];

        // Initialize the states to -1
        for (int i = 0; i < a.length; i++)
            for (int j = 0; j < a.length; j++)
                Arrays.fill(dp[i][j], -1);

        // Get answer
        int ans = findSubsequence(
            a, sequence, 0, -1, 0);

        // Print answer
        System.out.println((ans < 0) ? 0 : ans);
    }

    // Driver code
    public static void
        main(String[] args) throws Exception
    {
        // Given array
        int[] arr = { 5, 3, 9, 3, 4, 7 };

        // Give arr1
        int[] arr1 = { 3, 4 };

        // Function Call
        printAnswer(arr, arr1);
    }
}