给定两个数组中最长的公共子数组

在编程中，经常会遇到需要找到两个数组中最长的公共子数组的情况。下面我们将介绍几种解决该问题的方法。

一、暴力解法

暴力解法可以直接使用两重循环遍历所有可能的子数组并比较他们是否相等，找出最长公共子数组。时间复杂度为 $O(n^3)$。以下为 Java 代码实现：

public int findLength(int[] A, int[] B) {
    int m = A.length, n = B.length, ans = 0;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j) {
            int k = 0;
            while (i + k < m && j + k < n && A[i + k] == B[j + k])
                k++;
            ans = Math.max(ans, k);
        }
    }
    return ans;
}

二、动态规划解法

动态规划解法是将问题拆分成子问题进行求解，使用一个二维数组记录状态，时间复杂度为 $O(n^2)$。以下为 Java 代码实现：

public int findLength(int[] A, int[] B) {
    int m = A.length, n = B.length, ans = 0;
    int[][] dp = new int[m + 1][n + 1];
    for (int i = 1; i <= m; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (A[i - 1] == B[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1] + 1;
                ans = Math.max(ans, dp[i][j]);
            }
        }
    }
    return ans;
}

三、滑动窗口解法

滑动窗口解法可以将两个数组看成一个二维矩阵，然后找到相同元素的对角线，从对角线开始向上、向右滑动窗口，用窗口中的元素匹配。当窗口中的元素匹配时，就可以更新最长公共子数组的长度。时间复杂度为 $O((m+n) \times \min(m,n))$。以下为 Java 代码实现：

public int findLength(int[] A, int[] B) {
    int m = A.length, n = B.length, ans = 0;
    for (int len = 1; len <= m + n - 1; ++len) {
        int startA = Math.max(0, len - n), endA = Math.min(len, m);
        int startB = Math.max(0, n - len), endB = Math.min(n, n + m - len);
        int maxLen = findMaxLen(A, B, startA, endA, startB, endB);
        ans = Math.max(ans, maxLen);
    }
    return ans;
}

private int findMaxLen(int[] A, int[] B, int startA, int endA, int startB, int endB) {
    int ans = 0, len = 0;
    for (int i = startA, j = startB; i < endA && j < endB; ++i, ++j) {
        if (A[i] == B[j]) {
            len++;
        } else {
            len = 0;
        }
        ans = Math.max(ans, len);
    }
    return ans;
}

四、总结

通过以上三种方法，我们可以求出给定两个数组中最长的公共子数组。暴力解法虽然简单易懂，但时间复杂度高，不太适用于大型数据集。动态规划解法是时间复杂度最低的方法，但需要较多的空间。滑动窗口解法则将空间复杂度优化到了最低，但时间复杂度相对较高。在实际开发中，可以根据数据规模和计算资源的是否满足要求来选择不同的解法。