Skip to content

Commit be68ce1

Browse files
yanglbmeyanglbme
committed
feat: update solutions to lc problem: No.0022
No.0022.Generate Parentheses
1 parent d0cbc07 commit be68ce1

File tree

8 files changed

+180
-169
lines changed

8 files changed

+180
-169
lines changed

‎solution/0000-0099/0022.Generate Parentheses/README.md

Lines changed: 68 additions & 57 deletions
Original file line numberDiff line numberDiff line change
@@ -36,7 +36,18 @@
3636

3737
<!-- 这里可写通用的实现逻辑 -->
3838

39-
深度优先搜索 DFS。
39+
**方法一：DFS + 剪枝**
40+
41+
题目中 $n$ 的范围为 $[1, 8]$，因此我们直接通过“暴力搜索 + 剪枝”的方式快速解决本题。
42+
43+
我们设计函数 `dfs(l, r, t)`，其中 $l$ 和 $r$ 分别表示左括号和右括号的数量，而 $t$ 表示当前的括号序列。那么我们可以得到如下的递归结构：
44+
45+
- 如果 $l \gt n$ 或者 $r \gt n$ 或者 $l \lt r$，那么当前括号组合 $t$ 不合法，直接返回；
46+
- 如果 $l = n$ 且 $r = n$，那么当前括号组合 $t$ 合法，将其加入答案数组 `ans` 中，直接返回；
47+
- 我们可以选择添加一个左括号，递归执行 `dfs(l + 1, r, t + "(")`；
48+
- 我们也可以选择添加一个右括号，递归执行 `dfs(l, r + 1, t + ")")`。
49+
50+
时间复杂度 $O(2^{n\times 2} \times n)$，空间复杂度 $O(n)$。
4051

4152
<!-- tabs:start -->
4253

@@ -47,14 +58,14 @@
4758
```python
4859
class Solution:
4960
def generateParenthesis(self, n: int) -> List[str]:
50-
def dfs(left, right, t):
51-
if left == n and right == n:
61+
def dfs(l, r, t):
62+
if l > n or r > n or l < r:
63+
return
64+
if l == n and r == n:
5265
ans.append(t)
5366
return
54-
if left < n:
55-
dfs(left + 1, right, t + '(')
56-
if right < left:
57-
dfs(left, right + 1, t + ')')
67+
dfs(l + 1, r, t + '(')
68+
dfs(l, r + 1, t + ')')
5869

5970
ans = []
6071
dfs(0, 0, '')
@@ -67,23 +78,25 @@ class Solution:
6778

6879
```java
6980
class Solution {
81+
private List<String> ans = new ArrayList<>();
82+
private int n;
83+
7084
public List<String> generateParenthesis(int n) {
71-
List<String> ans = new ArrayList<>();
72-
dfs(0, 0, n, "", ans);
85+
this.n = n;
86+
dfs(0, 0, "");
7387
return ans;
7488
}
7589

76-
private void dfs(int left, int right, int n, String t, List<String> ans) {
77-
if (left == n && right == n) {
78-
ans.add(t);
90+
private void dfs(int l, int r, String t) {
91+
if (l > n || r > n || l < r) {
7992
return;
8093
}
81-
if (left < n) {
82-
dfs(left + 1, right, n, t + "(", ans);
83-
}
84-
if (right < left) {
85-
dfs(left, right + 1, n, t + ")", ans);
94+
if (l == n && r == n) {
95+
ans.add(t);
96+
return;
8697
}
98+
dfs(l + 1, r, t + "(");
99+
dfs(l, r + 1, t + ")");
87100
}
88101
}
89102
```
@@ -95,38 +108,38 @@ class Solution {
95108
public:
96109
vector<string> generateParenthesis(int n) {
97110
vector<string> ans;
98-
dfs(0, 0, n, "", ans);
111+
function<void(int, int, string)> dfs;
112+
dfs = [&](int l, int r, string t) {
113+
if (l > n || r > n || l < r) return;
114+
if (l == n && r == n) {
115+
ans.push_back(t);
116+
return;
117+
}
118+
dfs(l + 1, r, t + "(");
119+
dfs(l, r + 1, t + ")");
120+
};
121+
dfs(0, 0, "");
99122
return ans;
100123
}
101-
102-
void dfs(int left, int right, int n, string t, vector<string>& ans) {
103-
if (left == n && right == n) {
104-
ans.push_back(t);
105-
return;
106-
}
107-
if (left < n) dfs(left + 1, right, n, t + "(", ans);
108-
if (right < left) dfs(left, right + 1, n, t + ")", ans);
109-
}
110124
};
111125
```
112126
113127
### **Go**
114128
115129
```go
116130
func generateParenthesis(n int) []string {
117-
var ans []string
118-
var dfs func(left, right int, t string)
119-
dfs = func(left, right int, t string) {
120-
if left == n && right == n {
121-
ans = append(ans, t)
131+
ans := []string{}
132+
var dfs func(int, int, string)
133+
dfs = func(l, r int, t string) {
134+
if l > n || r > n || l < r {
122135
return
123136
}
124-
if left < n {
125-
dfs(left+1, right, t+"(")
126-
}
127-
if right < left {
128-
dfs(left, right+1, t+")")
137+
if l == n && r == n {
138+
ans = append(ans, t)
139+
return
129140
}
141+
dfs(l+1, r, t+"(")
142+
dfs(l, r+1, t+")")
130143
}
131144
dfs(0, 0, "")
132145
return ans
@@ -141,19 +154,18 @@ func generateParenthesis(n int) []string {
141154
* @return {string[]}
142155
*/
143156
var generateParenthesis = function (n) {
144-
let ans = [];
145-
let dfs = function (left, right, t) {
146-
if (left == n && right == n) {
147-
ans.push(t);
157+
function dfs(l, r, t) {
158+
if (l > n || r > n || l < r) {
148159
return;
149160
}
150-
if (left < n) {
151-
dfs(left + 1, right, t + '(');
152-
}
153-
if (right < left) {
154-
dfs(left, right + 1, t + ')');
161+
if (l == n && r == n) {
162+
ans.push(t);
163+
return;
155164
}
156-
};
165+
dfs(l + 1, r, t + '(');
166+
dfs(l, r + 1, t + ')');
167+
}
168+
let ans = [];
157169
dfs(0, 0, '');
158170
return ans;
159171
};
@@ -163,19 +175,18 @@ var generateParenthesis = function (n) {
163175

164176
```ts
165177
function generateParenthesis(n: number): string[] {
166-
const ans: string[] = [];
167-
const dfs = (left: number, right: number, t: string) => {
168-
if (left == n && right == n) {
169-
ans.push(t);
178+
function dfs(l, r, t) {
179+
if (l > n || r > n || l < r) {
170180
return;
171181
}
172-
if (left < n) {
173-
dfs(left + 1, right, t + '(');
174-
}
175-
if (right < left) {
176-
dfs(left, right + 1, t + ')');
182+
if (l == n && r == n) {
183+
ans.push(t);
184+
return;
177185
}
178-
};
186+
dfs(l + 1, r, t + '(');
187+
dfs(l, r + 1, t + ')');
188+
}
189+
let ans = [];
179190
dfs(0, 0, '');
180191
return ans;
181192
}

‎solution/0000-0099/0022.Generate Parentheses/README_EN.md

Lines changed: 56 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -32,14 +32,14 @@ DFS.
3232
```python
3333
class Solution:
3434
def generateParenthesis(self, n: int) -> List[str]:
35-
def dfs(left, right, t):
36-
if left == n and right == n:
35+
def dfs(l, r, t):
36+
if l > n or r > n or l < r:
37+
return
38+
if l == n and r == n:
3739
ans.append(t)
3840
return
39-
if left < n:
40-
dfs(left + 1, right, t + '(')
41-
if right < left:
42-
dfs(left, right + 1, t + ')')
41+
dfs(l + 1, r, t + '(')
42+
dfs(l, r + 1, t + ')')
4343

4444
ans = []
4545
dfs(0, 0, '')
@@ -50,23 +50,25 @@ class Solution:
5050

5151
```java
5252
class Solution {
53+
private List<String> ans = new ArrayList<>();
54+
private int n;
55+
5356
public List<String> generateParenthesis(int n) {
54-
List<String> ans = new ArrayList<>();
55-
dfs(0, 0, n, "", ans);
57+
this.n = n;
58+
dfs(0, 0, "");
5659
return ans;
5760
}
5861

59-
private void dfs(int left, int right, int n, String t, List<String> ans) {
60-
if (left == n && right == n) {
61-
ans.add(t);
62+
private void dfs(int l, int r, String t) {
63+
if (l > n || r > n || l < r) {
6264
return;
6365
}
64-
if (left < n) {
65-
dfs(left + 1, right, n, t + "(", ans);
66-
}
67-
if (right < left) {
68-
dfs(left, right + 1, n, t + ")", ans);
66+
if (l == n && r == n) {
67+
ans.add(t);
68+
return;
6969
}
70+
dfs(l + 1, r, t + "(");
71+
dfs(l, r + 1, t + ")");
7072
}
7173
}
7274
```
@@ -78,38 +80,38 @@ class Solution {
7880
public:
7981
vector<string> generateParenthesis(int n) {
8082
vector<string> ans;
81-
dfs(0, 0, n, "", ans);
83+
function<void(int, int, string)> dfs;
84+
dfs = [&](int l, int r, string t) {
85+
if (l > n || r > n || l < r) return;
86+
if (l == n && r == n) {
87+
ans.push_back(t);
88+
return;
89+
}
90+
dfs(l + 1, r, t + "(");
91+
dfs(l, r + 1, t + ")");
92+
};
93+
dfs(0, 0, "");
8294
return ans;
8395
}
84-
85-
void dfs(int left, int right, int n, string t, vector<string>& ans) {
86-
if (left == n && right == n) {
87-
ans.push_back(t);
88-
return;
89-
}
90-
if (left < n) dfs(left + 1, right, n, t + "(", ans);
91-
if (right < left) dfs(left, right + 1, n, t + ")", ans);
92-
}
9396
};
9497
```
9598
9699
### **Go**
97100
98101
```go
99102
func generateParenthesis(n int) []string {
100-
var ans []string
101-
var dfs func(left, right int, t string)
102-
dfs = func(left, right int, t string) {
103-
if left == n && right == n {
104-
ans = append(ans, t)
103+
ans := []string{}
104+
var dfs func(int, int, string)
105+
dfs = func(l, r int, t string) {
106+
if l > n || r > n || l < r {
105107
return
106108
}
107-
if left < n {
108-
dfs(left+1, right, t+"(")
109-
}
110-
if right < left {
111-
dfs(left, right+1, t+")")
109+
if l == n && r == n {
110+
ans = append(ans, t)
111+
return
112112
}
113+
dfs(l+1, r, t+"(")
114+
dfs(l, r+1, t+")")
113115
}
114116
dfs(0, 0, "")
115117
return ans
@@ -124,19 +126,18 @@ func generateParenthesis(n int) []string {
124126
* @return {string[]}
125127
*/
126128
var generateParenthesis = function (n) {
127-
let ans = [];
128-
let dfs = function (left, right, t) {
129-
if (left == n && right == n) {
130-
ans.push(t);
129+
function dfs(l, r, t) {
130+
if (l > n || r > n || l < r) {
131131
return;
132132
}
133-
if (left < n) {
134-
dfs(left + 1, right, t + '(');
135-
}
136-
if (right < left) {
137-
dfs(left, right + 1, t + ')');
133+
if (l == n && r == n) {
134+
ans.push(t);
135+
return;
138136
}
139-
};
137+
dfs(l + 1, r, t + '(');
138+
dfs(l, r + 1, t + ')');
139+
}
140+
let ans = [];
140141
dfs(0, 0, '');
141142
return ans;
142143
};
@@ -146,19 +147,18 @@ var generateParenthesis = function (n) {
146147

147148
```ts
148149
function generateParenthesis(n: number): string[] {
149-
const ans: string[] = [];
150-
const dfs = (left: number, right: number, t: string) => {
151-
if (left == n && right == n) {
152-
ans.push(t);
150+
function dfs(l, r, t) {
151+
if (l > n || r > n || l < r) {
153152
return;
154153
}
155-
if (left < n) {
156-
dfs(left + 1, right, t + '(');
157-
}
158-
if (right < left) {
159-
dfs(left, right + 1, t + ')');
154+
if (l == n && r == n) {
155+
ans.push(t);
156+
return;
160157
}
161-
};
158+
dfs(l + 1, r, t + '(');
159+
dfs(l, r + 1, t + ')');
160+
}
161+
let ans = [];
162162
dfs(0, 0, '');
163163
return ans;
164164
}

‎solution/0000-0099/0022.Generate Parentheses/Solution.cpp

Lines changed: 11 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -2,16 +2,17 @@ class Solution {
22
public:
33
vector<string> generateParenthesis(int n) {
44
vector<string> ans;
5-
dfs(0, 0, n, "", ans);
5+
function<void(int, int, string)> dfs;
6+
dfs = [&](int l, int r, string t) {
7+
if (l > n || r > n || l < r) return;
8+
if (l == n && r == n) {
9+
ans.push_back(t);
10+
return;
11+
}
12+
dfs(l + 1, r, t + "(");
13+
dfs(l, r + 1, t + ")");
14+
};
15+
dfs(0, 0, "");
616
return ans;
717
}
8-
9-
void dfs(int left, int right, int n, string t, vector<string>& ans) {
10-
if (left == n && right == n) {
11-
ans.push_back(t);
12-
return;
13-
}
14-
if (left < n) dfs(left + 1, right, n, t + "(", ans);
15-
if (right < left) dfs(left, right + 1, n, t + ")", ans);
16-
}
1718
};

0 commit comments

Comments
 (0)