Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Skip to content

Commit 8e1dd6b

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.1062 (doocs#4158)
No.1062.Longest Repeating Substring
1 parent f104c69 commit 8e1dd6b

File tree

8 files changed

+232
-98
lines changed

8 files changed

+232
-98
lines changed

‎solution/1000-1099/1062.Longest Repeating Substring/README.md

Lines changed: 78 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -66,20 +66,21 @@ tags:
6666

6767
### 方法一：动态规划
6868

69-
定义 $dp[i][j]$ 表示以 $s[i]$ 和 $s[j]$ 结尾的最长重复子串 🔒 的长度。状态转移方程为：
69+
我们定义 $f[i][j]$ 表示以 $s[i]$ 和 $s[j]$ 结尾的最长重复子串的长度，初始时 $f[i][j]=0$。
70+
71+
我们在 $[1, n)$ 的区间内枚举 $i$，在 $[0, i)$ 的区间内枚举 $j$，如果 $s[i]=s[j]$，那么有：
7072

7173
$$
72-
dp[i][j]=
74+
f[i][j]=
7375
\begin{cases}
74-
dp[i-1][j-1]+1, & i>0 \cap s[i]=s[j] \\
75-
1, & i=0 \cap s[i]=s[j] \\
76-
0, & s[i] \neq s[j]
76+
f[i-1][j-1]+1, & j>0 \\
77+
1, & j=0
7778
\end{cases}
7879
$$
7980

80-
时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。
81+
我们求出所有 $f[i][j]$ 的最大值即为答案。
8182

82-
其中 $n$ 为字符串 $s$ 的长度。
83+
时间复杂度 $O(n^2)$，空间复杂度 $O(n^2)$。其中 $n$ 为字符串 $s$ 的长度。
8384

8485
相似题目：
8586

@@ -93,13 +94,13 @@ $$
9394
class Solution:
9495
def longestRepeatingSubstring(self, s: str) -> int:
9596
n = len(s)
96-
dp = [[0] * n for _ in range(n)]
97+
f = [[0] * n for _ in range(n)]
9798
ans = 0
98-
for i in range(n):
99-
for j in range(i + 1, n):
99+
for i in range(1, n):
100+
for j in range(i):
100101
if s[i] == s[j]:
101-
dp[i][j] = dp[i - 1][j - 1] + 1 if i else 1
102-
ans = max(ans, dp[i][j])
102+
f[i][j] = 1 + (f[i - 1][j - 1] if j else 0)
103+
ans = max(ans, f[i][j])
103104
return ans
104105
```
105106

@@ -109,13 +110,13 @@ class Solution:
109110
class Solution {
110111
public int longestRepeatingSubstring(String s) {
111112
int n = s.length();
113+
int[][] f = new int[n][n];
112114
int ans = 0;
113-
int[][] dp = new int[n][n];
114-
for (int i = 0; i < n; ++i) {
115-
for (int j = i + 1; j < n; ++j) {
115+
for (int i = 1; i < n; ++i) {
116+
for (int j = 0; j < i; ++j) {
116117
if (s.charAt(i) == s.charAt(j)) {
117-
dp[i][j] = i > 0 ? dp[i - 1][j - 1] + 1 : 1;
118-
ans = Math.max(ans, dp[i][j]);
118+
f[i][j] = 1 + (j > 0 ? f[i - 1][j - 1] : 0);
119+
ans = Math.max(ans, f[i][j]);
119120
}
120121
}
121122
}
@@ -130,14 +131,15 @@ class Solution {
130131
class Solution {
131132
public:
132133
int longestRepeatingSubstring(string s) {
133-
int n = s.size();
134-
vector<vector<int>> dp(n, vector<int>(n));
134+
int n = s.length();
135+
int f[n][n];
136+
memset(f, 0, sizeof(f));
135137
int ans = 0;
136-
for (int i = 0; i < n; ++i) {
137-
for (int j = i + 1; j < n; ++j) {
138+
for (int i = 1; i < n; ++i) {
139+
for (int j = 0; j < i; ++j) {
138140
if (s[i] == s[j]) {
139-
dp[i][j] = i ? dp[i - 1][j - 1] + 1 : 1;
140-
ans = max(ans, dp[i][j]);
141+
f[i][j] = 1 + (j > 0 ? f[i - 1][j - 1] : 0);
142+
ans = max(ans, f[i][j]);
141143
}
142144
}
143145
}
@@ -149,26 +151,66 @@ public:
149151
#### Go
150152
151153
```go
152-
func longestRepeatingSubstring(s string) int {
154+
func longestRepeatingSubstring(s string) (ans int) {
153155
n := len(s)
154-
dp := make([][]int, n)
155-
for i := range dp {
156-
dp[i] = make([]int, n)
156+
f := make([][]int, n)
157+
for i := range f {
158+
f[i] = make([]int, n)
157159
}
158-
ans := 0
159-
for i := 0; i < n; i++ {
160-
for j := i + 1; j < n; j++ {
160+
for i := 1; i < n; i++ {
161+
for j := 0; j < i; j++ {
161162
if s[i] == s[j] {
162-
if i == 0 {
163-
dp[i][j] = 1
164-
} else {
165-
dp[i][j] = dp[i-1][j-1] + 1
163+
if j > 0 {
164+
f[i][j] = f[i-1][j-1]
166165
}
167-
ans = max(ans, dp[i][j])
166+
f[i][j]++
167+
ans = max(ans, f[i][j])
168168
}
169169
}
170170
}
171-
return ans
171+
return
172+
}
173+
```
174+
175+
#### TypeScript
176+
177+
```ts
178+
function longestRepeatingSubstring(s: string): number {
179+
const n = s.length;
180+
const f: number[][] = Array.from({ length: n }).map(() => Array(n).fill(0));
181+
let ans = 0;
182+
for (let i = 1; i < n; ++i) {
183+
for (let j = 0; j < i; ++j) {
184+
if (s[i] === s[j]) {
185+
f[i][j] = 1 + (f[i - 1][j - 1] || 0);
186+
ans = Math.max(ans, f[i][j]);
187+
}
188+
}
189+
}
190+
return ans;
191+
}
192+
```
193+
194+
#### Rust
195+
196+
```rust
197+
impl Solution {
198+
pub fn longest_repeating_substring(s: String) -> i32 {
199+
let n = s.len();
200+
let mut f = vec![vec![0; n]; n];
201+
let mut ans = 0;
202+
let s = s.as_bytes();
203+
204+
for i in 1..n {
205+
for j in 0..i {
206+
if s[i] == s[j] {
207+
f[i][j] = if j > 0 { f[i - 1][j - 1] + 1 } else { 1 };
208+
ans = ans.max(f[i][j]);
209+
}
210+
}
211+
}
212+
ans
213+
}
172214
}
173215
```
174216

‎solution/1000-1099/1062.Longest Repeating Substring/README_EN.md

Lines changed: 91 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -62,7 +62,27 @@ tags:
6262

6363
<!-- solution:start -->
6464

65-
### Solution 1
65+
### Solution 1: Dynamic Programming
66+
67+
We define $f[i][j]$ to represent the length of the longest repeating substring ending with $s[i]$ and $s[j]$. Initially, $f[i][j]=0$.
68+
69+
We enumerate $i$ in the range $[1, n)$ and enumerate $j$ in the range $[0, i)$. If $s[i]=s[j]$, then we have:
70+
71+
$$
72+
f[i][j]=
73+
\begin{cases}
74+
f[i-1][j-1]+1, & j>0 \\
75+
1, & j=0
76+
\end{cases}
77+
$$
78+
79+
The answer is the maximum value of all $f[i][j]$.
80+
81+
The time complexity is $O(n^2)$, and the space complexity is $O(n^2)$. Where $n$ is the length of the string $s$.
82+
83+
Similar problems:
84+
85+
- [1044. Longest Duplicate Substring 🔒](https://github.com/doocs/leetcode/blob/main/solution/1000-1099/1044.Longest%20Duplicate%20Substring/README_EN.md)
6686

6787
<!-- tabs:start -->
6888

@@ -72,13 +92,13 @@ tags:
7292
class Solution:
7393
def longestRepeatingSubstring(self, s: str) -> int:
7494
n = len(s)
75-
dp = [[0] * n for _ in range(n)]
95+
f = [[0] * n for _ in range(n)]
7696
ans = 0
77-
for i in range(n):
78-
for j in range(i + 1, n):
97+
for i in range(1, n):
98+
for j in range(i):
7999
if s[i] == s[j]:
80-
dp[i][j] = dp[i - 1][j - 1] + 1 if i else 1
81-
ans = max(ans, dp[i][j])
100+
f[i][j] = 1 + (f[i - 1][j - 1] if j else 0)
101+
ans = max(ans, f[i][j])
82102
return ans
83103
```
84104

@@ -88,13 +108,13 @@ class Solution:
88108
class Solution {
89109
public int longestRepeatingSubstring(String s) {
90110
int n = s.length();
111+
int[][] f = new int[n][n];
91112
int ans = 0;
92-
int[][] dp = new int[n][n];
93-
for (int i = 0; i < n; ++i) {
94-
for (int j = i + 1; j < n; ++j) {
113+
for (int i = 1; i < n; ++i) {
114+
for (int j = 0; j < i; ++j) {
95115
if (s.charAt(i) == s.charAt(j)) {
96-
dp[i][j] = i > 0 ? dp[i - 1][j - 1] + 1 : 1;
97-
ans = Math.max(ans, dp[i][j]);
116+
f[i][j] = 1 + (j > 0 ? f[i - 1][j - 1] : 0);
117+
ans = Math.max(ans, f[i][j]);
98118
}
99119
}
100120
}
@@ -109,14 +129,15 @@ class Solution {
109129
class Solution {
110130
public:
111131
int longestRepeatingSubstring(string s) {
112-
int n = s.size();
113-
vector<vector<int>> dp(n, vector<int>(n));
132+
int n = s.length();
133+
int f[n][n];
134+
memset(f, 0, sizeof(f));
114135
int ans = 0;
115-
for (int i = 0; i < n; ++i) {
116-
for (int j = i + 1; j < n; ++j) {
136+
for (int i = 1; i < n; ++i) {
137+
for (int j = 0; j < i; ++j) {
117138
if (s[i] == s[j]) {
118-
dp[i][j] = i ? dp[i - 1][j - 1] + 1 : 1;
119-
ans = max(ans, dp[i][j]);
139+
f[i][j] = 1 + (j > 0 ? f[i - 1][j - 1] : 0);
140+
ans = max(ans, f[i][j]);
120141
}
121142
}
122143
}
@@ -128,26 +149,66 @@ public:
128149
#### Go
129150
130151
```go
131-
func longestRepeatingSubstring(s string) int {
152+
func longestRepeatingSubstring(s string) (ans int) {
132153
n := len(s)
133-
dp := make([][]int, n)
134-
for i := range dp {
135-
dp[i] = make([]int, n)
154+
f := make([][]int, n)
155+
for i := range f {
156+
f[i] = make([]int, n)
136157
}
137-
ans := 0
138-
for i := 0; i < n; i++ {
139-
for j := i + 1; j < n; j++ {
158+
for i := 1; i < n; i++ {
159+
for j := 0; j < i; j++ {
140160
if s[i] == s[j] {
141-
if i == 0 {
142-
dp[i][j] = 1
143-
} else {
144-
dp[i][j] = dp[i-1][j-1] + 1
161+
if j > 0 {
162+
f[i][j] = f[i-1][j-1]
145163
}
146-
ans = max(ans, dp[i][j])
164+
f[i][j]++
165+
ans = max(ans, f[i][j])
147166
}
148167
}
149168
}
150-
return ans
169+
return
170+
}
171+
```
172+
173+
#### TypeScript
174+
175+
```ts
176+
function longestRepeatingSubstring(s: string): number {
177+
const n = s.length;
178+
const f: number[][] = Array.from({ length: n }).map(() => Array(n).fill(0));
179+
let ans = 0;
180+
for (let i = 1; i < n; ++i) {
181+
for (let j = 0; j < i; ++j) {
182+
if (s[i] === s[j]) {
183+
f[i][j] = 1 + (f[i - 1][j - 1] || 0);
184+
ans = Math.max(ans, f[i][j]);
185+
}
186+
}
187+
}
188+
return ans;
189+
}
190+
```
191+
192+
#### Rust
193+
194+
```rust
195+
impl Solution {
196+
pub fn longest_repeating_substring(s: String) -> i32 {
197+
let n = s.len();
198+
let mut f = vec![vec![0; n]; n];
199+
let mut ans = 0;
200+
let s = s.as_bytes();
201+
202+
for i in 1..n {
203+
for j in 0..i {
204+
if s[i] == s[j] {
205+
f[i][j] = if j > 0 { f[i - 1][j - 1] + 1 } else { 1 };
206+
ans = ans.max(f[i][j]);
207+
}
208+
}
209+
}
210+
ans
211+
}
151212
}
152213
```
153214

‎solution/1000-1099/1062.Longest Repeating Substring/Solution.cpp

Lines changed: 8 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,18 @@
11
class Solution {
22
public:
33
int longestRepeatingSubstring(string s) {
4-
int n = s.size();
5-
vector<vector<int>> dp(n, vector<int>(n));
4+
int n = s.length();
5+
int f[n][n];
6+
memset(f, 0, sizeof(f));
67
int ans = 0;
7-
for (int i = 0; i < n; ++i) {
8-
for (int j = i + 1; j < n; ++j) {
8+
for (int i = 1; i < n; ++i) {
9+
for (int j = 0; j < i; ++j) {
910
if (s[i] == s[j]) {
10-
dp[i][j] = i ? dp[i - 1][j - 1] + 1 : 1;
11-
ans = max(ans, dp[i][j]);
11+
f[i][j] = 1 + (j > 0 ? f[i - 1][j - 1] : 0);
12+
ans = max(ans, f[i][j]);
1213
}
1314
}
1415
}
1516
return ans;
1617
}
17-
};
18+
};

‎solution/1000-1099/1062.Longest Repeating Substring/Solution.go

Lines changed: 12 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,21 +1,19 @@
1-
func longestRepeatingSubstring(s string) int {
1+
func longestRepeatingSubstring(s string) (ans int) {
22
n := len(s)
3-
dp := make([][]int, n)
4-
for i := range dp {
5-
dp[i] = make([]int, n)
3+
f := make([][]int, n)
4+
for i := range f {
5+
f[i] = make([]int, n)
66
}
7-
ans := 0
8-
for i := 0; i < n; i++ {
9-
for j := i + 1; j < n; j++ {
7+
for i := 1; i < n; i++ {
8+
for j := 0; j < i; j++ {
109
if s[i] == s[j] {
11-
if i == 0 {
12-
dp[i][j] = 1
13-
} else {
14-
dp[i][j] = dp[i-1][j-1] + 1
10+
if j > 0 {
11+
f[i][j] = f[i-1][j-1]
1512
}
16-
ans = max(ans, dp[i][j])
13+
f[i][j]++
14+
ans = max(ans, f[i][j])
1715
}
1816
}
1917
}
20-
return ans
21-
}
18+
return
19+
}

0 commit comments

Comments
 (0)