【Leetcode】718. Maximum Length of Repeated Subarray

题目地址：

https://leetcode.com/problems/maximum-length-of-repeated-subarray/

给定两个数组$A$和$B$，求它们的最长公共子数组的长度。

法1：动态规划。设$f[i][j]$是以$A[i-1]$并且以$B[j-1]$结尾的最长公共子数组的长度，初始条件$f[0][.]=f[.][0]=0$，并且有：$$f[i][j]=\{\begin{array}{l}0,A[i-1]\ne B[j-1]\\ 1+f[i-1][j-1],A[i-1]=B[j-1]\end{array}$$答案就是${\max }_{i,j}f[i][j]$。代码如下：

public class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int res = 0;
        int[][] f = new int[nums1.length + 1][nums2.length + 1];
        for (int i = 0; i < nums1.length; i++) {
            for (int j = 0; j < nums2.length; j++) {
                if (nums1[i] != nums2[j]) {
                    continue;
                }
                
                f[i + 1][j + 1] = 1 + f[i][j];
                res = Math.max(res, f[i + 1][j + 1]);
            }
        }
        
        return res;
    }
}

时空复杂度$O(l_A{l}_B)$。

法2：二分 + 字符串哈希。可以类似字符串哈希的方式，算出两个数组的前缀哈希数组，答案的范围是 [ 0 , min ⁡ { l A , l B } ] [0,\min\{l_A,l_B\}] [0,min{lA​,lB​}]，可以二分答案。判定的时候可以枚举$A$的所有长为$k$的子数组，将这些子数组的哈希值存入哈希表，然后再枚举$B$的所有长为$k$的子数组，看看在哈希表里是否存在，如果存在就说明该子数组在两个数组里都出现过，返回true。代码如下：

import java.util.HashSet;
import java.util.Set;

public class Solution {
    public int findLength(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        long[] h1 = new long[m + 1], h2 = new long[n + 1];
        long P = 131L;
        long[] pow = new long[n + 1];
        pow[0] = 1L;
        
        for (int i = 0; i < m; i++) {
            h1[i + 1] = h1[i] * P + nums1[i];
        }
        for (int i = 0; i < n; i++) {
            h2[i + 1] = h2[i] * P + nums2[i];
            pow[i + 1] = pow[i] * P;
        }
        
        int l = 0, r = Math.min(n, m);
        while (l < r) {
            int mid = l + (r - l + 1 >> 1);
            if (check(mid, nums1, nums2, h1, h2, pow)) {
                l = mid;
            } else {
                r = mid - 1;
            }
        }
        
        return l;
    }
    
    private boolean check(int len, int[] nums1, int[] nums2, long[] h1, long[] h2, long[] pow) {
        Set<Long> set = new HashSet<>();
        for (int i = len - 1; i < nums1.length; i++) {
            set.add(hash(h1, i - len + 1, i, pow));
        }
        
        for (int i = len - 1; i < nums2.length; i++) {
            if (set.contains(hash(h2, i - len + 1, i, pow))) {
                return true;
            }
        }
        
        return false;
    }
    
    private long hash(long[] ha, int l, int r, long[] pow) {
        return ha[r + 1] - ha[l] * pow[r - l + 1];
    }
}

时间复杂度 O ( ( l A + l B ) log ⁡ min ⁡ { l A , l B } ) O((l_A+l_B)\log \min\{l_A,l_B\}) O((lA​+lB​)logmin{lA​,lB​})，空间$O(l_A+l_B)$。