leetcode 718. 最长重复子数组（DP/二分+哈希）

题目描述
给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。
示例：
输入： A: [1,2,3,2,1] B: [3,2,1,4,7]
输出：3

动态规划，使用 dp[i][j] 表示以 A[i - 1]和 B[j - 1] 结尾的 最长 相同公共子串长度，属性是最大值。 在计算过程中会使用到 dp[i-1][j-1]，因此下标从1开始。如果A[i - 1]和 B[j - 1]相等，那么就在dp[i-1][j-1]的基础上加1，也就是以 A[i - 2]和 B[j - 2] 为结尾的最长公共子串，否则dp[i][j]=0,最后的结果取所有dp值的最大值即可。

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int n=nums1.size(),m=nums2.size();
        int ans=0;
        vector<vector<int>> dp(n+1,vector<int>(m+1,0));
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=m;j++)
            {
                if(nums1[i-1]==nums2[j-1]) dp[i][j]=dp[i-1][j-1]+1;
                else dp[i][j]=0;
                ans=max(ans,dp[i][j]);
            }
        }
        return ans;
    }
};

优化：上述是二维的，现在可以优化为一维， dp[i][j]=dp[i-1][j-1]+1,去掉 i 维后变成 dp[j]=dp[j-1]+1;但是此时是等价于 dp[i][j]=dp[i][j-1]+1;与原始状态转移方程不等价，因此需要从大到小循环，原因在于dp[i][j-1]先被计算出来。

class Solution {
public:
    int findLength(vector<int>& nums1, vector<int>& nums2) {
        int n=nums1.size(),m=nums2.size();
        int ans=0;
        vector<int> dp(m+1,0);
        for(int i=1;i<=n;i++)
        {
            for(int j=m;j>=1;j--)
            {
                if(nums1[i-1]==nums2[j-1]) dp[j]=dp[j-1]+1;
                else dp[j]=0;
                ans=max(ans,dp[j]);
            }
        }
        return ans;
    }
};

二分+哈希：

字符串哈希也叫Rabin-Karp算法，目的是使用O(n)的预处理得到O(1)的查找效率。主要用于判断两区间内的字符串是否相同，可以将字符串看成是P进制的数，P一般取131，13331，使用unsigned 是产生溢出时相当于对2⁶⁴自动取模。模板如下：

typedef unsigned long long ULL;
const int N=1e5+5,P=131;
ULL h[N],p[N];
char str[N];
//计算子串的[l,r]的哈希值
ULL get(int l,int r)
{
    return h[r]-h[l-1]*p[r-l+1];
}

p[0]=1;
for(int i=1;i<=n;i++)
{
    p[i]=p[i-1]*P;
    h[i]=h[i-1]*P+str[i];
}

使用二分是便于寻找长度为mid的子串看是否满足要求，如果满足要求那么左边下标为l，否则右边下标为 mid-1。注意这里对应的下标指的是子串长度，不是字符串里的下标。

详细注解：

bool check(int len) 
{ // check(len) 的作用是看 A,B 里是否有 mid 长度的子字符串 相同
        unordered_set<ULL> hash; // 哈希表 插入, 删除, 查询 的时间复杂度为 O(1)
        // 注意 A 字符串的下标范围: [0, n - 1], ha 的 [l, r] 范围是 [1, n], 下标存在 1 的差值
        // 长度 len 的子串下标范围: [i, i + len - 1]
        for (int i = 0; i + len - 1 < n; i ++ ) hash.insert(getHash(ha, i, i + len - 1));
        for (int i = 0; i + len - 1 < m; i ++ )
            if (hash.count(getHash(hb, i, i + len - 1))) return true;
        return false;
}
作者：youngersky
链接：https://leetcode-cn.com/problems/maximum-length-of-repeated-subarray/solution/lc-718-zui-chang-zhong-fu-zi-shu-zu-san-m0mru/

typedef unsigned long long ULL;
const int P=131;
class Solution {
public:
    int n,m;
    vector<ULL> ha,hb,p;
    bool check(int mid)
    {
        unordered_set<ULL> hash;
        for(int i=mid;i<=n;i++) hash.insert(get(ha,i-mid+1,i));
        for(int i=mid;i<=m;i++)
        {
            if(hash.count(get(hb,i-mid+1,i))) return true;
        }
        return false;
    }
    ULL get(vector<ULL> &h,int l,int r)
    {
        return h[r]-h[l-1]*p[r-l+1];
    }
    int findLength(vector<int>& A, vector<int>& B) {
        n=A.size(),m=B.size();
        ha.resize(n+1),hb.resize(m+1),p.resize(n+1);
        for(int i=1;i<=n;i++) ha[i]=ha[i-1]*P+A[i-1];
        for(int i=1;i<=m;i++) hb[i]=hb[i-1]*P+B[i-1];
        p[0]=1;
        for(int i=1;i<=n;i++) p[i]=p[i-1]*P;
        int l=0,r = min(n, m);
        while(l<r)
        {
            int mid=l+r+1>>1;
            if(check(mid)) l=mid;
            else r=mid-1;
        }
        return l;
    }
};

题型变种：LeetCode 1044. 最长重复子串
给出一个字符串 S，考虑其所有重复子串（S 的连续子串，出现两次或多次，可能会有重叠）。返回任何具有最长可能长度的重复子串。（如果 S 不含重复子串，那么答案为 “”。）

示例 1：
输入：“banana”
输出：“ana”
示例 2：
输入：“abcd”
输出：""

与上一题中使用的二分+哈希，只需要在遍历过程中将最长子串获取即可。在使用字符串哈希时下标是从1开始的（i-mid+1）。因此获取字符串长度时需要从i-mid 开始截取mid长度的字符串。

typedef unsigned long long ULL;
const int P=131;
class Solution {
public:
    int n,m;
    string res,A;
    vector<ULL> ha,p;
    bool check(int mid)
    {
        unordered_set<ULL> hash;
        for(int i=mid;i<=n;i++)
        {
            if(hash.count(get(ha,i-mid+1,i))) 
            {
                res=A.substr(i-mid,mid);
                return true;
            }
            hash.insert(get(ha,i-mid+1,i));
        }
        return false;
    }
    ULL get(vector<ULL> &h,int l,int r)
    {
        return h[r]-h[l-1]*p[r-l+1];
    }
    string longestDupSubstring(string s) {
        A=s;  n=s.size();
        ha.resize(n+1),p.resize(n+1);
        for(int i=1;i<=n;i++) ha[i]=ha[i-1]*P+A[i-1];
        p[0]=1;
        for(int i=1;i<=n;i++) p[i]=p[i-1]*P;
        int l=0,r = n;
        while(l<r)
        {
            int mid=l+r+1>>1;
            if(check(mid)) l=mid;
            else r=mid-1;
        }
        return res;
    }
};