题目描述
「快乐前缀」 是在原字符串中既是 非空 前缀也是后缀（不包括原字符串自身）的字符串。
给你一个字符串 s，请你返回它的 最长快乐前缀。如果不存在满足题意的前缀，则返回一个空字符串 "" 。
示例 1：
输入：s = "level"
输出："l"
解释：不包括 s 自己，一共有 4 个前缀（"l", "le", "lev", "leve"）和 4 个后缀（"l", "el", "vel", "evel"）。最长的既是前缀也是后缀的字符串是 "l" 。
示例 2：
输入：s = "ababab"
输出："abab"
解释："abab" 是最长的既是前缀也是后缀的字符串。题目允许前后缀在原字符串中重叠。
提示：
1 <= s.length <= 105s 只含有小写英文字母
解法
方法一：字符串哈希
字符串哈希是把一个任意长度的字符串映射成一个非负整数，并且其冲突的概率几乎为 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 产生错误的数据。
| class Solution:
def longestPrefix(self, s: str) -> str:
for i in range(1, len(s)):
if s[:-i] == s[i:]:
return s[i:]
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 | class Solution {
private long[] p;
private long[] h;
public String longestPrefix(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);
}
for (int l = n - 1; l > 0; --l) {
if (get(1, l) == get(n - l + 1, n)) {
return s.substring(0, l);
}
}
return "";
}
private long get(int l, int r) {
return h[r] - h[l - 1] * p[r - l + 1];
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 | typedef unsigned long long ULL;
class Solution {
public:
string longestPrefix(string s) {
int base = 131;
int n = s.size();
ULL p[n + 10];
ULL h[n + 10];
p[0] = 1;
h[0] = 0;
for (int i = 0; i < n; ++i) {
p[i + 1] = p[i] * base;
h[i + 1] = h[i] * base + s[i];
}
for (int l = n - 1; l > 0; --l) {
ULL prefix = h[l];
ULL suffix = h[n] - h[n - l] * p[l];
if (prefix == suffix) return s.substr(0, l);
}
return "";
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | func longestPrefix(s string) string {
base := 131
n := len(s)
p := make([]int, n+10)
h := make([]int, n+10)
p[0] = 1
for i, c := range s {
p[i+1] = p[i] * base
h[i+1] = h[i]*base + int(c)
}
for l := n - 1; l > 0; l-- {
prefix, suffix := h[l], h[n]-h[n-l]*p[l]
if prefix == suffix {
return s[:l]
}
}
return ""
}
|
| function longestPrefix(s: string): string {
const n = s.length;
for (let i = n - 1; i >= 0; i--) {
if (s.slice(0, i) === s.slice(n - i, n)) {
return s.slice(0, i);
}
}
return '';
}
|
| impl Solution {
pub fn longest_prefix(s: String) -> String {
let n = s.len();
for i in (0..n).rev() {
if s[0..i] == s[n - i..n] {
return s[0..i].to_string();
}
}
String::new()
}
}
|
方法二：KMP 算法
根据题目描述，我们需要找到一个字符串的最长快乐前缀，即找到一个字符串的最长前缀，使得这个前缀同时也是这个字符串的后缀。我们可以使用 KMP 算法来解决这个问题。
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为字符串的长度。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | class Solution:
def longestPrefix(self, s: str) -> str:
s += "#"
n = len(s)
next = [0] * n
next[0] = -1
i, j = 2, 0
while i < n:
if s[i - 1] == s[j]:
j += 1
next[i] = j
i += 1
elif j:
j = next[j]
else:
next[i] = 0
i += 1
return s[: next[-1]]
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | class Solution {
public String longestPrefix(String s) {
s += "#";
int n = s.length();
int[] next = new int[n];
next[0] = -1;
for (int i = 2, j = 0; i < n;) {
if (s.charAt(i - 1) == s.charAt(j)) {
next[i++] = ++j;
} else if (j > 0) {
j = next[j];
} else {
next[i++] = 0;
}
}
return s.substring(0, next[n - 1]);
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 | class Solution {
public:
string longestPrefix(string s) {
s.push_back('#');
int n = s.size();
int next[n];
next[0] = -1;
next[1] = 0;
for (int i = 2, j = 0; i < n;) {
if (s[i - 1] == s[j]) {
next[i++] = ++j;
} else if (j > 0) {
j = next[j];
} else {
next[i++] = 0;
}
}
return s.substr(0, next[n - 1]);
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19 | func longestPrefix(s string) string {
s += "#"
n := len(s)
next := make([]int, n)
next[0], next[1] = -1, 0
for i, j := 2, 0; i < n; {
if s[i-1] == s[j] {
j++
next[i] = j
i++
} else if j > 0 {
j = next[j]
} else {
next[i] = 0
i++
}
}
return s[:next[n-1]]
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 | function longestPrefix(s: string): string {
s += '#';
const n = s.length;
const next: number[] = Array(n).fill(0);
next[0] = -1;
for (let i = 2, j = 0; i < n; ) {
if (s[i - 1] === s[j]) {
next[i++] = ++j;
} else if (j > 0) {
j = next[j];
} else {
next[i++] = 0;
}
}
return s.slice(0, next[n - 1]);
}
|