LeetCode 1044. Longest Duplicate Substring

原题链接在这里：https://leetcode.com/problems/longest-duplicate-substring/

题目：

Given a string s, consider all duplicated substrings: (contiguous) substrings of s that occur 2 or more times. The occurrences may overlap.

Return any duplicated substring that has the longest possible length. If s does not have a duplicated substring, the answer is "".

Example 1:

Input: s = "banana"
Output: "ana"

Example 2:

Input: s = "abcd"
Output: ""

Constraints:

• 2 <= s.length <= 3 * 104
• s consists of lowercase English letters.

题解：

We could guess a length, and check if there is duplicate.

If there is, then we could guess a bigger one. Otherwise, a smaller one.

How to check duplicates with given length. Use rolling hash.

"abcd", len = 3. when "abc" we have a hash, when it comes to "d", first decrease "a" then add "d" hash.

Time Complexity: O(nlogn). n = s.length().

Space: O(n).

AC Java:

class Solution {
    int m = 1000000007;
    int base = 26;
    
    public String longestDupSubstring(String s) {
        if(s == null || s.length() == 0){
            return s;
        }    
        
        int [] nums = new int[s.length()];
        for(int i = 0; i < s.length(); i++){
            nums[i] = (int)(s.charAt(i) - 'a');
        }
        int l = 1;
        int r = s.length();
        while(l <= r){
            int mid = l + (r - l) / 2;
            if(isValid(s, mid, nums) != -1){ 
                l = mid + 1;
            }else{
                r = mid - 1;
            }
        }
        
        int start = isValid(s, l - 1, nums);
        return s.substring(start, start + l - 1);
    }
    
    private int isValid(String s, int len, int [] nums){
        int n = s.length();
        Map<Long, List<Integer>> map = new HashMap<>();
        long hash = 0;
        for(int i = 0; i < len; i++){
            hash = (hash * base + (s.charAt(i) - 'a')) % m;
        }
        
        map.put(hash, Arrays.asList(0));
        
        // pre-compute deduction multiplier
        long mul = 1;
        for(int i = 0; i < len; i++){
            mul = (mul * base) % m;
        }
        
        for(int start = 1; start < n - len + 1; start++){
            hash = (hash * base - nums[start - 1] * mul % m + m) % m;
            hash = (hash + nums[start + len - 1]) % m;
            List<Integer> list = map.get(hash);
            if(list != null){
                // There are equal hash before
                String cur = s.substring(start, start + len);
                for(int ind : list){
                    if(s.substring(ind, ind + len).equals(cur)){
                        return ind;
                    }
                }
            }
            
            map.putIfAbsent(hash, new ArrayList<Integer>());
            map.get(hash).add(start);
        }
        
        return -1;
    }
}

类似Longest Repeating Substring.