二分答案 + 滚动哈希 寻找重复子串

1044. Longest Duplicate Substring

本题的high level的思想是二分搜索这样的substring最多能有多长。对于一个固定的len，如果能在S里找到两处相同的子串滑窗，那么我们就可以对len的搜索往上调整；反之，我们就必须将len的搜索往下调。

于是本题转化为，如果快速在S里找到两处相同的、长度都是len的滑窗。比较直观的想法是对每一处滑窗组成的字符串都放入集合，如果看到集合中已经有一个相同的substring了，就意味着duplicate了。但是当len很大的时候，将字符串放入集合的内置hash化操作很耗时。于是rolling hash是比较常见的解决方案。

Rolling hash的基本思想就是将abcd转化为26进制的0123.将一个数作为key放入集合很轻松。除此之外，对于abcdef这样的字符串，如果已经知道了[abcd]这个子串的hash key是0123，那么再求相邻的[bcde]的hash key 1234就非常高效，只需要将之前的key的最高位数字去掉(a对应的0)、左移一位、加上最低位数字(e对应的4）。用o(1)的时间就能完成。

总结一下，rolling hash的思想，就是将两个字符串的比较，转化为hash化之后的两个26进制数的比较。但是当len很大时，这个数可能很大，我们通常不得不对一个大数取模再作为hash key。这样就会有两个不同的字符串，但是会对应同一个hash key（26进制数取模后的结果）。针对这种hash collision的情况，我们可以调整base和mod来规避。或者使用两套hash规则来生成两个key，那么不同字符串拥有两个相同key的概率就会大大降低。

class Solution {
public:
    typedef long long LL;
    LL mod = 1L << 32;
    unordered_map<int, int> mp;
    
    string longestDupSubstring(string S) {
        int n = S.size();
        int l = 1, r = n, mid;
        // 二分查找最长可能子串长度，相当于在 0 0 0 0 1 1 1 1中找最后一个0的位置
        // i(1-indexed)位置的0代表长度为i的重复子串存在，1代表不存在
        // 因此可以转换为求0的upper_bound的idx，然后再减一的值
        // 初始l = 1, r = n
        // 初始l = 0 会出现check(s, 0)的情况，虽不影响结果，但是l = 1更合理
        // 初始r = n - 1出错，否则0 0 0 0这样的字符串找不到正确upper_bound
        while (l < r) {
            mid = (l + r) >> 1;
            if (check(S, mid)) l = mid + 1;
            else r = mid;
        }
        return S.substr(mp[l - 1], l - 1);
    }
    bool check(string& s, int k) {
        int n = s.size();
        long long hash = 0, base = 1;
        for (int i = 0; i < k; ++i) {
            hash = (hash * 26 + (s[i] - 'a')) % mod;;
            base = base * 26 % mod;
        }
        unordered_set<int> h;
        h.insert(hash);
        for (int i = k; i < n; ++i) {
            hash = (hash * 26 + (s[i] - 'a')) % mod;
            hash = (hash - (s[i - k] - 'a') * base) % mod;
            if (h.count(hash)) {
                mp[k] = i - k + 1;
                return true;
            }
            h.insert(hash);
        }
        return false;
    }
};

718. Maximum Length of Repeated Subarray

class Solution {
public:
    typedef long long LL;
    
    const int mod = 1e9 + 7;
    const int base = 113;
    
    LL qPow(LL x, LL k) {
        LL res = 1;
        while (k) {
            if (k & 1) {
                res = res * x % mod;
            } 
            x = x * x % mod;
            k >>= 1;
        }
        return res;
    }
    
    int findLength(vector<int>& A, vector<int>& B) {
        int l = 1, r = min(A.size(), B.size()) + 1, mid;
        while (l < r) {
            mid = (l + r) >> 1;
            if (check(A, B, mid)) l = mid + 1;
            else r = mid;
        }
        return l - 1;
    }
    
    bool check(vector<int>& A, vector<int>& B, int k) {
        unordered_set<int> hashA;
        LL hash = 0;
        
        for (int i = 0; i < k; ++i) {
            hash = (hash * base + A[i]) % mod;
        }
        hashA.insert(hash);
        for (int i = k; i < A.size(); ++i) {
            hash = ((hash - A[i - k] * qPow(base, k - 1) % mod + mod) % mod * base + A[i]) % mod;
            hashA.insert(hash);
        }
        
        hash = 0;
        for (int i = 0; i < k; ++i) {
            hash = (hash * base + B[i]) % mod;
        }
        if (hashA.count(hash)) return true;
        for (int i = k; i < B.size(); ++i) {
            hash = ((hash - B[i - k] * qPow(base, k - 1) % mod + mod) % mod * base + B[i]) % mod;
            if (hashA.count(hash)) return true;
        }
        
        return false;
    }
};