Skip to content

Commit b8d7b5c

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.0331 (doocs#1309)
No.0331.Verify Preorder Serialization of a Binary Tree
1 parent d59fbab commit b8d7b5c

File tree

9 files changed

+315
-50
lines changed

9 files changed

+315
-50
lines changed

Diff for: ‎solution/0300-0399/0331.Verify Preorder Serialization of a Binary Tree/README.md

+91-1
Original file line numberDiff line numberDiff line change
@@ -59,22 +59,112 @@
5959

6060
<!-- 这里可写通用的实现逻辑 -->
6161

62+
**方法一：栈**
63+
64+
我们将字符串 `preorder` 按逗号分割成数组，然后遍历数组，如果遇到了连续两个 `'#'`，并且第三个元素不是 `'#'`，那么就将这三个元素替换成一个 `'#'`，这个过程一直持续到数组遍历结束。
65+
66+
最后，判断数组长度是否为 $1$，且数组唯一的元素是否为 `'#'` 即可。
67+
68+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为字符串 `preorder` 的长度。
69+
6270
<!-- tabs:start -->
6371

6472
### **Python3**
6573

6674
<!-- 这里可写当前语言的特殊实现逻辑 -->
6775

6876
```python
69-
77+
class Solution:
78+
def isValidSerialization(self, preorder: str) -> bool:
79+
stk = []
80+
for c in preorder.split(","):
81+
stk.append(c)
82+
while len(stk) > 2 and stk[-1] == stk[-2] == "#" and stk[-3] != "#":
83+
stk = stk[:-3]
84+
stk.append("#")
85+
return len(stk) == 1 and stk[0] == "#"
7086
```
7187

7288
### **Java**
7389

7490
<!-- 这里可写当前语言的特殊实现逻辑 -->
7591

7692
```java
93+
class Solution {
94+
public boolean isValidSerialization(String preorder) {
95+
String[] strs = preorder.split(",");
96+
int diff = 1;
97+
for (String s : strs) {
98+
if (--diff < 0) {
99+
return false;
100+
}
101+
if (!s.equals("#")) {
102+
diff += 2;
103+
}
104+
}
105+
return diff == 0;
106+
}
107+
}
108+
```
109+
110+
```java
111+
class Solution {
112+
public boolean isValidSerialization(String preorder) {
113+
List<String> stk = new ArrayList<>();
114+
for (String s : preorder.split(",")) {
115+
stk.add(s);
116+
while (stk.size() >= 3
117+
&& stk.get(stk.size() - 1).equals("#")
118+
&& stk.get(stk.size() - 2).equals("#")
119+
&& !stk.get(stk.size() - 3).equals("#")) {
120+
stk.remove(stk.size() - 1);
121+
stk.remove(stk.size() - 1);
122+
stk.remove(stk.size() - 1);
123+
stk.add("#");
124+
}
125+
}
126+
return stk.size() == 1 && stk.get(0).equals("#");
127+
}
128+
}
129+
```
130+
131+
### **C++**
132+
133+
```cpp
134+
class Solution {
135+
public:
136+
bool isValidSerialization(string preorder) {
137+
vector<string> stk;
138+
stringstream ss(preorder);
139+
string s;
140+
while (getline(ss, s, ',')) {
141+
stk.push_back(s);
142+
while (stk.size() >= 3 && stk[stk.size() - 1] == "#" && stk[stk.size() - 2] == "#" && stk[stk.size() - 3] != "#") {
143+
stk.pop_back();
144+
stk.pop_back();
145+
stk.pop_back();
146+
stk.push_back("#");
147+
}
148+
}
149+
return stk.size() == 1 && stk[0] == "#";
150+
}
151+
};
152+
```
77153
154+
### **Go**
155+
156+
```go
157+
func isValidSerialization(preorder string) bool {
158+
stk := []string{}
159+
for _, s := range strings.Split(preorder, ",") {
160+
stk = append(stk, s)
161+
for len(stk) >= 3 && stk[len(stk)-1] == "#" && stk[len(stk)-2] == "#" && stk[len(stk)-3] != "#" {
162+
stk = stk[:len(stk)-3]
163+
stk = append(stk, "#")
164+
}
165+
}
166+
return len(stk) == 1 && stk[0] == "#"
167+
}
78168
```
79169

80170
### **...**

Diff for: ‎solution/0300-0399/0331.Verify Preorder Serialization of a Binary Tree/README_EN.md

+83-1
Original file line numberDiff line numberDiff line change
@@ -46,13 +46,95 @@
4646
### **Python3**
4747

4848
```python
49-
49+
class Solution:
50+
def isValidSerialization(self, preorder: str) -> bool:
51+
stk = []
52+
for c in preorder.split(","):
53+
stk.append(c)
54+
while len(stk) > 2 and stk[-1] == stk[-2] == "#" and stk[-3] != "#":
55+
stk = stk[:-3]
56+
stk.append("#")
57+
return len(stk) == 1 and stk[0] == "#"
5058
```
5159

5260
### **Java**
5361

5462
```java
63+
class Solution {
64+
public boolean isValidSerialization(String preorder) {
65+
String[] strs = preorder.split(",");
66+
int diff = 1;
67+
for (String s : strs) {
68+
if (--diff < 0) {
69+
return false;
70+
}
71+
if (!s.equals("#")) {
72+
diff += 2;
73+
}
74+
}
75+
return diff == 0;
76+
}
77+
}
78+
```
79+
80+
```java
81+
class Solution {
82+
public boolean isValidSerialization(String preorder) {
83+
List<String> stk = new ArrayList<>();
84+
for (String s : preorder.split(",")) {
85+
stk.add(s);
86+
while (stk.size() >= 3
87+
&& stk.get(stk.size() - 1).equals("#")
88+
&& stk.get(stk.size() - 2).equals("#")
89+
&& !stk.get(stk.size() - 3).equals("#")) {
90+
stk.remove(stk.size() - 1);
91+
stk.remove(stk.size() - 1);
92+
stk.remove(stk.size() - 1);
93+
stk.add("#");
94+
}
95+
}
96+
return stk.size() == 1 && stk.get(0).equals("#");
97+
}
98+
}
99+
```
100+
101+
### **C++**
102+
103+
```cpp
104+
class Solution {
105+
public:
106+
bool isValidSerialization(string preorder) {
107+
vector<string> stk;
108+
stringstream ss(preorder);
109+
string s;
110+
while (getline(ss, s, ',')) {
111+
stk.push_back(s);
112+
while (stk.size() >= 3 && stk[stk.size() - 1] == "#" && stk[stk.size() - 2] == "#" && stk[stk.size() - 3] != "#") {
113+
stk.pop_back();
114+
stk.pop_back();
115+
stk.pop_back();
116+
stk.push_back("#");
117+
}
118+
}
119+
return stk.size() == 1 && stk[0] == "#";
120+
}
121+
};
122+
```
55123
124+
### **Go**
125+
126+
```go
127+
func isValidSerialization(preorder string) bool {
128+
stk := []string{}
129+
for _, s := range strings.Split(preorder, ",") {
130+
stk = append(stk, s)
131+
for len(stk) >= 3 && stk[len(stk)-1] == "#" && stk[len(stk)-2] == "#" && stk[len(stk)-3] != "#" {
132+
stk = stk[:len(stk)-3]
133+
stk = append(stk, "#")
134+
}
135+
}
136+
return len(stk) == 1 && stk[0] == "#"
137+
}
56138
```
57139

58140
### **...**

Diff for: ‎solution/0300-0399/0331.Verify Preorder Serialization of a Binary Tree/Solution.cpp

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
class Solution {
2+
public:
3+
bool isValidSerialization(string preorder) {
4+
vector<string> stk;
5+
stringstream ss(preorder);
6+
string s;
7+
while (getline(ss, s, ',')) {
8+
stk.push_back(s);
9+
while (stk.size() >= 3 && stk[stk.size() - 1] == "#" && stk[stk.size() - 2] == "#" && stk[stk.size() - 3] != "#") {
10+
stk.pop_back();
11+
stk.pop_back();
12+
stk.pop_back();
13+
stk.push_back("#");
14+
}
15+
}
16+
return stk.size() == 1 && stk[0] == "#";
17+
}
18+
};

Diff for: ‎solution/0300-0399/0331.Verify Preorder Serialization of a Binary Tree/Solution.go

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
func isValidSerialization(preorder string) bool {
2+
stk := []string{}
3+
for _, s := range strings.Split(preorder, ",") {
4+
stk = append(stk, s)
5+
for len(stk) >= 3 && stk[len(stk)-1] == "#" && stk[len(stk)-2] == "#" && stk[len(stk)-3] != "#" {
6+
stk = stk[:len(stk)-3]
7+
stk = append(stk, "#")
8+
}
9+
}
10+
return len(stk) == 1 && stk[0] == "#"
11+
}

Diff for: ‎solution/0300-0399/0331.Verify Preorder Serialization of a Binary Tree/Solution.java

+18-15
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,18 @@
1-
class Solution {
2-
public boolean isValidSerialization(String preorder) {
3-
String[] strs = preorder.split(",");
4-
int diff = 1;
5-
for (String s : strs) {
6-
if (--diff < 0) {
7-
return false;
8-
}
9-
if (!s.equals("#")) {
10-
diff += 2;
11-
}
12-
}
13-
return diff == 0;
14-
}
15-
}
1+
class Solution {
2+
public boolean isValidSerialization(String preorder) {
3+
List<String> stk = new ArrayList<>();
4+
for (String s : preorder.split(",")) {
5+
stk.add(s);
6+
while (stk.size() >= 3
7+
&& stk.get(stk.size() - 1).equals("#")
8+
&& stk.get(stk.size() - 2).equals("#")
9+
&& !stk.get(stk.size() - 3).equals("#")) {
10+
stk.remove(stk.size() - 1);
11+
stk.remove(stk.size() - 1);
12+
stk.remove(stk.size() - 1);
13+
stk.add("#");
14+
}
15+
}
16+
return stk.size() == 1 && stk.get(0).equals("#");
17+
}
18+
}

Diff for: ‎solution/0300-0399/0331.Verify Preorder Serialization of a Binary Tree/Solution.py

+9
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
class Solution:
2+
def isValidSerialization(self, preorder: str) -> bool:
3+
stk = []
4+
for c in preorder.split(","):
5+
stk.append(c)
6+
while len(stk) > 2 and stk[-1] == stk[-2] == "#" and stk[-3] != "#":
7+
stk = stk[:-3]
8+
stk.append("#")
9+
return len(stk) == 1 and stk[0] == "#"

Diff for: ‎solution/2500-2599/2500.Delete Greatest Value in Each Row/README.md

+2-2
Original file line numberDiff line numberDiff line change
@@ -66,9 +66,9 @@
6666

6767
由于每一次操作都是从每一行中删除最大值，然后取最大值加到答案中，因此我们可以先对每一行进行排序。
6868

69-
然后遍历每一列，取每一列的最大值，然后将其加到答案中即可。
69+
接下来遍历每一列，取每一列的最大值，然后将其加到答案中即可。
7070

71-
时间复杂度 $O(m \times n \times \log n)$，空间复杂度 $O(1)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
71+
时间复杂度 $O(m \times n \times \log n)$，空间复杂度 $O(\log n)$。其中 $m$ 和 $n$ 分别是矩阵的行数和列数。
7272

7373
<!-- tabs:start -->
7474

Diff for: ‎solution/2500-2599/2501.Longest Square Streak in an Array/Solution.cpp

+40-16
Original file line numberDiff line numberDiff line change
@@ -1,17 +1,41 @@
1-
class Solution {
2-
public:
3-
int longestSquareStreak(vector<int>& nums) {
4-
unordered_set<long long> s(nums.begin(), nums.end());
5-
int ans = -1;
6-
for (int& v : nums) {
7-
int t = 0;
8-
long long x = v;
9-
while (s.count(x)) {
10-
x *= x;
11-
++t;
12-
}
13-
if (t > 1) ans = max(ans, t);
14-
}
15-
return ans;
16-
}
1+
/**
2+
* Definition for a binary tree node.
3+
* struct TreeNode {
4+
* int val;
5+
* TreeNode *left;
6+
* TreeNode *right;
7+
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
8+
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
9+
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10+
* };
11+
*/
12+
class Solution {
13+
public:
14+
int countGreatEnoughNodes(TreeNode* root, int k) {
15+
int ans = 0;
16+
function<priority_queue<int>(TreeNode*)> dfs = [&](TreeNode* root) {
17+
if (!root) {
18+
return priority_queue<int>();
19+
}
20+
auto left = dfs(root->left);
21+
auto right = dfs(root->right);
22+
while (right.size()) {
23+
left.push(right.top());
24+
right.pop();
25+
if (left.size() > k) {
26+
left.pop();
27+
}
28+
}
29+
if (left.size() == k && left.top() < root->val) {
30+
++ans;
31+
}
32+
left.push(root->val);
33+
if (left.size() > k) {
34+
left.pop();
35+
}
36+
return left;
37+
};
38+
dfs(root);
39+
return ans;
40+
}
1741
};

0 commit comments

Comments
 (0)