1044. 最长重复子串

题目要求：

给你一个字符串 s ，考虑其所有 重复子串 ：即，s 的连续子串，在 s 中出现 2 次或更多次。这些出现之间可能存在重叠。

返回 任意一个 可能具有最长长度的重复子串。如果 s 不含重复子串，那么答案为 “” 。

示例 1：
输入：s = “banana”
输出：“ana”

示例 2：
输入：s = “abcd”
输出：""

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-duplicate-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

问题分析：

1.后缀数组法

思路分析：

后缀数组法是将原字符串所有的后缀字符子串全放在一个数组里面，进行排序后，遍历数组，寻找相邻两个字符串的公共最长前缀子串。

缺点是当字符串很长的时候，需要存放字符串后缀子串的数组容量需要很大，而且遍历数组也需要很长的时间。

2.字符串编码法

思路分析：

字符串编码法是将所有小写字母，也只考虑小写字母，转化成1-26个数，从最后一位进行查找，进行简单递减。

缺点是当字符串很长的时候，所需要的简单递减的时间复杂度也很高。

3.二分查找 + Rabin-Karp 字符串编码

思路分析：

这种方法是在第二种编码的方法之上，使用二分查找进行对子串的查找，从而减少了时间损耗。

解题代码：

1.后缀数组法

class Solution {
    public String longestDupSubstring(String s) {
        int len = s.length();
        String res = "";
        int maxLen = 0;
        if (len <= 1) {
            return "";
        }
        //存放后缀的字符串数组
        String[] strs = new String[len];
        for (int i = 0; i < len; i++){
            strs[i] = s.substring(i,len);
        }
        //对所有后缀字符串进行排序
        Arrays.sort(strs);
        for (int i = 0; i < len-1; i++){
            int temp = lenTwoStr(strs[i],strs[i+1]);
            if(temp>maxLen){
                maxLen = temp;
                res = strs[i].substring(0,maxLen);
            }
        }
        return res;
    }
    //两个后缀子串的前缀最长公共子串
    public int lenTwoStr(String str1,String str2){
        if(str1.length() == 0 || str2.length() == 0){
            return 0;
        }
        int i = 0;
        while (i < str1.length() && i < str2.length() && str1.charAt(i) == str2.charAt(i)){
            i++;
        }
        return i;
    }
}

结果是超出内存限制。

2.字符串编码法

class Solution {
    public String longestDupSubstring(String s) {
        int len = s.length();
        //26进制
        int a = 26;
        long module = (long)Math.pow(2,32);
        if (len <= 1) {
            return "";
        }
        int[] nums = new int[len];
        for (int i = 0; i < len; i++) {
            nums[i] = (int) s.charAt(i) - (int)'a';
        }
        for (int i = len - 1; i >= 1;i--){
            HashSet<Long> hashset = new HashSet<Long>();
            long temp = 0;
            long aL = 1;
            for(int j = 0;j<i;i++){
                temp = (temp*a+nums[j])%module;
                aL = (aL*a)%module;
            }
            hashset.add(temp);
            for(int j = 1;j<=len-1;j++){
                temp = (temp*a-nums[j-1]*aL%module+module)%module;
                temp = (temp+nums[j+i-1])%module;
                if(hashset.contains(temp)){
                    return s.substring(j,j+1);
                }
                hashset.add(temp);
            }
        }
        return "";
    }
    
}

输出结果是超出时间限制。

3.二分查找 + Rabin-Karp 字符串编码

class Solution {
    public String longestDupSubstring(String s) {
        Random random = new Random();
        // 生成两个进制
        int a1 = random.nextInt(75) + 26;
        int a2 = random.nextInt(75) + 26;
        // 生成两个模
        int mod1 = random.nextInt(Integer.MAX_VALUE - 1000000007 + 1) + 1000000007;
        int mod2 = random.nextInt(Integer.MAX_VALUE - 1000000007 + 1) + 1000000007;
        int n = s.length();
        // 先对所有字符进行编码
        int[] arr = new int[n];
        for (int i = 0; i < n; ++i) {
            arr[i] = s.charAt(i) - 'a';
        }
        // 二分查找的范围是[1, n-1]
        int l = 1, r = n - 1;
        int length = 0, start = -1;
        while (l <= r) {
            int m = l + (r - l + 1) / 2;
            int idx = check(arr, m, a1, a2, mod1, mod2);
            if (idx != -1) {
                // 有重复子串，移动左边界
                l = m + 1;
                length = m;
                start = idx;
            } else {
                // 无重复子串，移动右边界
                r = m - 1;
            }
        }
        return start != -1 ? s.substring(start, start + length) : "";
    }

    public int check(int[] arr, int m, int a1, int a2, int mod1, int mod2) {
        int n = arr.length;
        long aL1 = pow(a1, m, mod1);
        long aL2 = pow(a2, m, mod2);
        long h1 = 0, h2 = 0;
        for (int i = 0; i < m; ++i) {
            h1 = (h1 * a1 % mod1 + arr[i]) % mod1;
            h2 = (h2 * a2 % mod2 + arr[i]) % mod2;
            if (h1 < 0) {
                h1 += mod1;
            }
            if (h2 < 0) {
                h2 += mod2;
            }
        }
        // 存储一个编码组合是否出现过
        Set<Long> seen = new HashSet<Long>();
        seen.add(h1 * mod2 + h2);
        for (int start = 1; start <= n - m; ++start) {
            h1 = (h1 * a1 % mod1 - arr[start - 1] * aL1 % mod1 + arr[start + m - 1]) % mod1;
            h2 = (h2 * a2 % mod2 - arr[start - 1] * aL2 % mod2 + arr[start + m - 1]) % mod2;
            if (h1 < 0) {
                h1 += mod1;
            }
            if (h2 < 0) {
                h2 += mod2;
            }

            long num = h1 * mod2 + h2;
            // 如果重复，则返回重复串的起点
            if (!seen.add(num)) {
                return start;
            }
        }
        // 没有重复，则返回-1
        return -1;
    }

    public long pow(int a, int m, int mod) {
        long ans = 1;
        long contribute = a;
        while (m > 0) {
            if (m % 2 == 1) {
                ans = ans * contribute % mod;
                if (ans < 0) {
                    ans += mod;
                }
            }
            contribute = contribute * contribute % mod;
            if (contribute < 0) {
                contribute += mod;
            }
            m /= 2;
        }
        return ans;
    }
}