[Leetcode学习-java]Longest Duplicate Substring(最长重复子串)

问题：

难度：Hard

说明：

输入一个字符串，将里面最长而且出现一次以上的子串（连续的子序列）返回。

问题链接：https://leetcode.com/problems/longest-duplicate-substring/

输入范围：

2 <= S.length <= 10^5，只输入小写字母

输入案例：

Example 1:

Input: "banana"
Output: "ana"
Example 2:

Input: "abcd"
Output: ""

我的代码：

一看题目用dp可能跟适合，就马上撸一个滚动数组，结果超时了

毕竟时间复杂度O（n2）字符串长度达到10w就不容乐观了。看了提示说用二分法，我想去用二分dp，结果想不出来。然后再看提示用rabin-karp就只好去看这个算法了。先贴出dp的做法，如果能想到如何二分应该可以ac吧。

class Solution {
    public String longestDupSubstring(String S) {
        // 弄成数组更省时间
        char[] chars = S.toCharArray();
        int len = chars.length;

        // 0 -from - 开始指针
        // 1 - to - 结束指针
        int[] ft = new int[]{-1, -1};
        // dp内存放的是长度值
        int[][] dp = new int[2][len + 1];

        // 使用滚动数组，pre前指针，cur当前指针
        int pre = 1;
        int cur = 0;
        for(int i = 1;i <= len; i ++) {
            // 交换指针指向
            pre ^= 1;
            cur = pre ^ 1;
            for(int j = i + 1;j <= len; j ++) {
                if(chars[i - 1] == chars[j - 1]) {
                    // 匹配到了就将上一个对角线 长度 + 1
                    dp[cur][j] = dp[pre][j - 1] + 1;

                    // from - to得到的长度 < 当前存放长度，移动from to指针
                    if(ft[1] - ft[0] < dp[cur][j]) {
                        if(ft[0] == -1) {
                            // 未赋值处理
                            ft[0] = j;
                            ft[1] = j;
                        } else {
                            // j - dp距离值 = 开始值
                            ft[0] = j - dp[cur][j];
                            // j 作为结束值
                            ft[1] = j;
                        }
                    }
                } else {
                    // 如果没有匹配到要变为0
                    dp[cur][j] = 0;
                }
            }
        }

        // from == -1就没有重复，不然就剪切 from to的字符串
        return ft[0] == -1 ? "" : S.substring(ft[0], ft[1]);
    }
}

Rabin-Karp算法：

比较难的就是hash算法的理解了，Rabin-Karp算法把一串字符串转为hash，那么就子串而言，窗口移动时候，删除一个然后新增一个hash进行计算即可。

而且题目还应该参入二分法，就可能存在的子串长度上要进行判断。

import java.util.HashSet;
class Solution {
    
    // 阶
    private static int BIN = 26;
    // 取容量，2的32位为无符号Integer最大值，java的int有符号
    private static long MOD = (long) Math.pow(2, 32);  
    
    public String longestDupSubstring(String S) {
        int len = S.length();
        if(len <= 1) return "";

        // 方便取值
        char[] Scs = S.toCharArray();

        // 将char改为int
        int[] nums = new int[len];
        for(int i = 0; i < len; i++) nums[i] = Scs[i] - 'a';

        int left = 1;
        int right = len;
        while(left != right)
        {
            int L = (right - left >> 1) + left;
            // 发现该长度的子串存在,移动left
            if(search(L, nums) != -1)
                left = L + 1;
            else
                right = L;
        }

        int start = search(left - 1, nums);
        return start == -1 ? "" : S.substring(start, start + left - 1);
    }

    // 返回重复字符串的起始位置
    public int search(int L, int[] nums) {
        int len = nums.length;
        HashSet<Long> hashSet = new HashSet<Long>();
        long tmp = 0;
        long aL = 1;
        for(int j = 0; j < L; j++){
            // 求模是为了延长hash有效范围，但是不排除hash重复
            tmp = (tmp * BIN + nums[j]) % MOD;
            aL = (aL * BIN) % MOD;
        }
        hashSet.add(tmp);

        // 进行len - L长度的窗口移动
        for(int j = 1; j <= len - L; j++){
            // 剪掉前一位hash
            tmp = (tmp * BIN - nums[j - 1] * aL % MOD + MOD) % MOD;
            // 拼起后一位hash
            tmp = (tmp + nums[j + L - 1]) % MOD;

            // 发现hash一致就返回j，就是开始位置
            if(hashSet.contains(tmp)) return j;
            hashSet.add(tmp);
        }
        return -1;
    }
}