题目描述
给你一个字符串 s ，考虑其所有 重复子串 ：即 s 的（连续）子串，在 s 中出现 2 次或更多次。这些出现之间可能存在重叠。
返回 任意一个 可能具有最长长度的重复子串。如果 s 不含重复子串，那么答案为 "" 。
示例 1：
输入：s = "banana"
输出："ana"
示例 2：
输入：s = "abcd"
输出：""
提示：
2 <= s.length <= 3 * 104s 由小写英文字母组成
解法
方法一：字符串哈希 + 二分查找
字符串哈希是把一个任意长度的字符串映射成一个非负整数，并且其冲突的概率几乎为 0。字符串哈希用于计算字符串哈希值，快速判断两个字符串是否相等。
取一固定值 BASE，把字符串看作是 BASE 进制数，并分配一个大于 0 的数值，代表每种字符。一般来说，我们分配的数值都远小于 BASE。例如，对于小写字母构成的字符串，可以令 a=1, b=2, ..., z=26。取一固定值 MOD，求出该 BASE 进制对 M 的余数，作为该字符串的 hash 值。
一般来说，取 BASE=131 或者 BASE=13331，此时 hash 值产生的冲突概率极低。只要两个字符串 hash 值相同，我们就认为两个字符串是相等的。通常 MOD 取 2^64，C++ 里，可以直接使用 unsigned long long 类型存储这个 hash 值，在计算时不处理算术溢出问题，产生溢出时相当于自动对 2^64 取模，这样可以避免低效取模运算。
除了在极特殊构造的数据上，上述 hash 算法很难产生冲突，一般情况下上述 hash 算法完全可以出现在题目的标准答案中。我们还可以多取一些恰当的 BASE 和 MOD 的值（例如大质数），多进行几组 hash 运算，当结果都相同时才认为原字符串相等，就更加难以构造出使这个 hash 产生错误的数据。
对于本题，二分枚举长度，找到满足条件的最大长度即可。
时间复杂度 $O(n\log n)$。其中 $n$ 为字符串长度。
相似题目：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 | class Solution:
def longestDupSubstring(self, s: str) -> str:
def check(l):
vis = set()
for i in range(n - l + 1):
t = s[i : i + l]
if t in vis:
return t
vis.add(t)
return ''
n = len(s)
left, right = 0, n
ans = ''
while left < right:
mid = (left + right + 1) >> 1
t = check(mid)
ans = t or ans
if t:
left = mid
else:
right = mid - 1
return ans
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43 | class Solution {
private long[] p;
private long[] h;
public String longestDupSubstring(String s) {
int base = 131;
int n = s.length();
p = new long[n + 10];
h = new long[n + 10];
p[0] = 1;
for (int i = 0; i < n; ++i) {
p[i + 1] = p[i] * base;
h[i + 1] = h[i] * base + s.charAt(i);
}
String ans = "";
int left = 0, right = n;
while (left < right) {
int mid = (left + right + 1) >> 1;
String t = check(s, mid);
if (t.length() > 0) {
left = mid;
ans = t;
} else {
right = mid - 1;
}
}
return ans;
}
private String check(String s, int len) {
int n = s.length();
Set<Long> vis = new HashSet<>();
for (int i = 1; i + len - 1 <= n; ++i) {
int j = i + len - 1;
long t = h[j] - h[i - 1] * p[j - i + 1];
if (vis.contains(t)) {
return s.substring(i - 1, j);
}
vis.add(t);
}
return "";
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40 | typedef unsigned long long ULL;
class Solution {
public:
ULL p[30010];
ULL h[30010];
string longestDupSubstring(string s) {
int base = 131, n = s.size();
p[0] = 1;
for (int i = 0; i < n; ++i) {
p[i + 1] = p[i] * base;
h[i + 1] = h[i] * base + s[i];
}
int left = 0, right = n;
string ans = "";
while (left < right) {
int mid = (left + right + 1) >> 1;
string t = check(s, mid);
if (t.empty())
right = mid - 1;
else {
left = mid;
ans = t;
}
}
return ans;
}
string check(string& s, int len) {
int n = s.size();
unordered_set<ULL> vis;
for (int i = 1; i + len - 1 <= n; ++i) {
int j = i + len - 1;
ULL t = h[j] - h[i - 1] * p[j - i + 1];
if (vis.count(t)) return s.substr(i - 1, len);
vis.insert(t);
}
return "";
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 | func longestDupSubstring(s string) string {
base, n := 131, len(s)
p := make([]int64, n+10)
h := make([]int64, n+10)
p[0] = 1
for i := 0; i < n; i++ {
p[i+1] = p[i] * int64(base)
h[i+1] = h[i]*int64(base) + int64(s[i])
}
check := func(l int) string {
vis := make(map[int64]bool)
for i := 1; i+l-1 <= n; i++ {
j := i + l - 1
t := h[j] - h[i-1]*p[j-i+1]
if vis[t] {
return s[i-1 : j]
}
vis[t] = true
}
return ""
}
left, right := 0, n
ans := ""
for left < right {
mid := (left + right + 1) >> 1
t := check(mid)
if len(t) > 0 {
left = mid
ans = t
} else {
right = mid - 1
}
}
return ans
}
|