Longest common subarray in the given two arrays

import java.util.Arrays;
import java.util.Vector;

public class Main {
    // Recursive function to find the longest common subarray (LCS)
    static int LCS(int i, int j, Vector<Integer> A, 
                   Vector<Integer> B, int count) {
        // Base case: If either of the indices reaches the end of the array, return the count
        if (i == A.size() || j == B.size())
            return count;

        // If the current elements are equal, recursively check the next elements
        if (A.get(i).equals(B.get(j)))
            count = LCS(i + 1, j + 1, A, B, count + 1);

        // Recursively check for the longest common subarray by considering two possibilities:
        // 1. Exclude the current element from array A and continue with array B
        // 2. Exclude the current element from array B and continue with array A
        count = Math.max(count, Math.max(LCS(i + 1, j, A, B, 0), 
                                         LCS(i, j + 1, A, B, 0)));

        return count;
    }

    public static void main(String[] args) {
        // Example arrays
        Vector<Integer> A = new Vector<>(Arrays.asList(1, 2, 3, 2, 1));
        Vector<Integer> B = new Vector<>(Arrays.asList(3, 2, 1, 4, 7));

        // Call the LCS function to find the maximum length of the common subarray
        int maxLength = LCS(0, 0, A, B, 0);

        // Print the result
        System.out.println("Max length of common subarray: " + maxLength);
    }
}
// This code is contributed by akshitaguprjz3

// Java program to DP approach
// to above solution
class GFG 
{
    // Function to find the maximum
    // length of equal subarray
    static int FindMaxLength(int A[], int B[], int n, int m)
    {

        // Auxiliary dp[][] array
        int[][] dp = new int[n + 1][m + 1];
        for (int i = 0; i <= n; i++)
            for (int j = 0; j <= m; j++)
                dp[i][j] = 0;

        // Updating the dp[][] table
        // in Bottom Up approach
        for (int i = n - 1; i >= 0; i--)
        {
            for (int j = m - 1; j >= 0; j--) 
            {
                // If A[i] is equal to B[i]
                // then dp[j][i] = dp[j + 1][i + 1] + 1
                if (A[i] == B[j])
                    dp[i][j] = dp[i + 1][j + 1] + 1;
            }
        }
        int maxm = 0;

        // Find maximum of all the values
        // in dp[][] array to get the
        // maximum length
        for (int i = 0; i < n; i++) 
        {
            for (int j = 0; j < m; j++) 
            {
                // Update the length
                maxm = Math.max(maxm, dp[i][j]);
            }
        }

        // Return the maximum length
        return maxm;
    }

    // Driver Code
    public static void main(String[] args)
    {
        int A[] = { 1, 2, 8, 2, 1 };
        int B[] = { 8, 2, 1, 4, 7 };

        int n = A.length;
        int m = B.length;

        // Function call to find
        // maximum length of subarray
        System.out.print(FindMaxLength(A, B, n, m));
    }
}

// This code is contributed by PrinciRaj1992

import java.util.Arrays;

public class Main {
    
    // Function to find the maximum length of equal subarray
    static int findMaxLength(int[] A, int[] B, int n, int m) {
        // Auxiliary dp[] array
        int[] dp = new int[m + 1];
        int maxm = 0;

        // Updating the dp[] array in Bottom Up approach
        for (int i = n - 1; i >= 0; i--) {
            int prev = 0;
            for (int j = m - 1; j >= 0; j--) {
                int temp = dp[j];
                if (A[i] == B[j]) {
                    dp[j] = prev + 1;
                    maxm = Math.max(maxm, dp[j]);
                } else {
                    dp[j] = 0;
                }
                prev = temp;
            }
        }

        // Return the maximum length
        return maxm;
    }

    public static void main(String[] args) {
        int[] A = { 1, 2, 8, 2, 1 };
        int[] B = { 8, 2, 1, 4, 7 };

        int n = A.length;
        int m = B.length;

        // Function call to find maximum length of subarray
        System.out.println(findMaxLength(A, B, n, m));
    }
}