题目要求:
给你一个字符串 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;
}
}