Skip to content

Commit dd5b551

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0310
No.0310.Minimum Height Trees
1 parent 5a7484e commit dd5b551

File tree

6 files changed

+433
-2
lines changed

6 files changed

+433
-2
lines changed

Diff for: ‎solution/0300-0399/0310.Minimum Height Trees/README.md

+150-1
Original file line numberDiff line numberDiff line change
@@ -65,22 +65,171 @@
6565

6666
<!-- 这里可写通用的实现逻辑 -->
6767

68+
拓扑排序，BFS 实现。
69+
70+
每一轮删除入度为 1 的节点，同时减小与之连接的节点的入度。循环此操作，最后一轮删除的节点，即为要找的最小高度树的根节点。
71+
6872
<!-- tabs:start -->
6973

7074
### **Python3**
7175

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

7478
```python
75-
79+
class Solution:
80+
def findMinHeightTrees(self, n: int, edges: List[List[int]]) -> List[int]:
81+
if n == 1:
82+
return [0]
83+
g = defaultdict(list)
84+
degree = [0] * n
85+
for a, b in edges:
86+
g[a].append(b)
87+
g[b].append(a)
88+
degree[a] += 1
89+
degree[b] += 1
90+
q = deque()
91+
for i in range(n):
92+
if degree[i] == 1:
93+
q.append(i)
94+
ans = []
95+
while q:
96+
n = len(q)
97+
ans.clear()
98+
for _ in range(n):
99+
a = q.popleft()
100+
ans.append(a)
101+
for b in g[a]:
102+
degree[b] -= 1
103+
if degree[b] == 1:
104+
q.append(b)
105+
return ans
76106
```
77107

78108
### **Java**
79109

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

82112
```java
113+
class Solution {
114+
public List<Integer> findMinHeightTrees(int n, int[][] edges) {
115+
if (n == 1) {
116+
return Collections.singletonList(0);
117+
}
118+
List<Integer>[] g = new List[n];
119+
int[] degree = new int[n];
120+
for (int i = 0; i < n; ++i) {
121+
g[i] = new ArrayList<>();
122+
}
123+
for (int[] e : edges) {
124+
int a = e[0], b = e[1];
125+
g[a].add(b);
126+
g[b].add(a);
127+
++degree[a];
128+
++degree[b];
129+
}
130+
Queue<Integer> q = new LinkedList<>();
131+
for (int i = 0; i < n; ++i) {
132+
if (degree[i] == 1) {
133+
q.offer(i);
134+
}
135+
}
136+
List<Integer> ans = new ArrayList<>();
137+
while (!q.isEmpty()) {
138+
ans.clear();
139+
for (int i = q.size(); i > 0; --i) {
140+
int a = q.poll();
141+
ans.add(a);
142+
for (int b : g[a]) {
143+
if (--degree[b] == 1) {
144+
q.offer(b);
145+
}
146+
}
147+
}
148+
}
149+
return ans;
150+
}
151+
}
152+
```
153+
154+
### **C++**
155+
156+
```cpp
157+
class Solution {
158+
public:
159+
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
160+
if (n == 1) return {0};
161+
vector<vector<int>> g(n);
162+
vector<int> degree(n);
163+
for (auto& e : edges)
164+
{
165+
int a = e[0], b = e[1];
166+
g[a].push_back(b);
167+
g[b].push_back(a);
168+
++degree[a];
169+
++degree[b];
170+
}
171+
queue<int> q;
172+
for (int i = 0; i < n; ++i)
173+
if (degree[i] == 1)
174+
q.push(i);
175+
vector<int> ans;
176+
while (!q.empty())
177+
{
178+
ans.clear();
179+
for (int i = q.size(); i > 0; --i)
180+
{
181+
int a = q.front();
182+
q.pop();
183+
ans.push_back(a);
184+
for (int b : g[a])
185+
if (--degree[b] == 1)
186+
q.push(b);
187+
}
188+
}
189+
return ans;
190+
}
191+
};
192+
```
83193
194+
### **Go**
195+
196+
```go
197+
func findMinHeightTrees(n int, edges [][]int) []int {
198+
if n == 1 {
199+
return []int{0}
200+
}
201+
g := make([][]int, n)
202+
degree := make([]int, n)
203+
for _, e := range edges {
204+
a, b := e[0], e[1]
205+
g[a] = append(g[a], b)
206+
g[b] = append(g[b], a)
207+
degree[a]++
208+
degree[b]++
209+
}
210+
var q []int
211+
for i := 0; i < n; i++ {
212+
if degree[i] == 1 {
213+
q = append(q, i)
214+
}
215+
}
216+
var ans []int
217+
for len(q) > 0 {
218+
ans = []int{}
219+
for i := len(q); i > 0; i-- {
220+
a := q[0]
221+
q = q[1:]
222+
ans = append(ans, a)
223+
for _, b := range g[a] {
224+
degree[b]--
225+
if degree[b] == 1 {
226+
q = append(q, b)
227+
}
228+
}
229+
}
230+
}
231+
return ans
232+
}
84233
```
85234

86235
### **...**

Diff for: ‎solution/0300-0399/0310.Minimum Height Trees/README_EN.md

+146-1
Original file line numberDiff line numberDiff line change
@@ -61,13 +61,158 @@
6161
### **Python3**
6262

6363
```python
64-
64+
class Solution:
65+
def findMinHeightTrees(self, n: int, edges: List[List[int]]) -> List[int]:
66+
if n == 1:
67+
return [0]
68+
g = defaultdict(list)
69+
degree = [0] * n
70+
for a, b in edges:
71+
g[a].append(b)
72+
g[b].append(a)
73+
degree[a] += 1
74+
degree[b] += 1
75+
q = deque()
76+
for i in range(n):
77+
if degree[i] == 1:
78+
q.append(i)
79+
ans = []
80+
while q:
81+
n = len(q)
82+
ans.clear()
83+
for _ in range(n):
84+
a = q.popleft()
85+
ans.append(a)
86+
for b in g[a]:
87+
degree[b] -= 1
88+
if degree[b] == 1:
89+
q.append(b)
90+
return ans
6591
```
6692

6793
### **Java**
6894

6995
```java
96+
class Solution {
97+
public List<Integer> findMinHeightTrees(int n, int[][] edges) {
98+
if (n == 1) {
99+
return Collections.singletonList(0);
100+
}
101+
List<Integer>[] g = new List[n];
102+
int[] degree = new int[n];
103+
for (int i = 0; i < n; ++i) {
104+
g[i] = new ArrayList<>();
105+
}
106+
for (int[] e : edges) {
107+
int a = e[0], b = e[1];
108+
g[a].add(b);
109+
g[b].add(a);
110+
++degree[a];
111+
++degree[b];
112+
}
113+
Queue<Integer> q = new LinkedList<>();
114+
for (int i = 0; i < n; ++i) {
115+
if (degree[i] == 1) {
116+
q.offer(i);
117+
}
118+
}
119+
List<Integer> ans = new ArrayList<>();
120+
while (!q.isEmpty()) {
121+
ans.clear();
122+
for (int i = q.size(); i > 0; --i) {
123+
int a = q.poll();
124+
ans.add(a);
125+
for (int b : g[a]) {
126+
if (--degree[b] == 1) {
127+
q.offer(b);
128+
}
129+
}
130+
}
131+
}
132+
return ans;
133+
}
134+
}
135+
```
136+
137+
### **C++**
138+
139+
```cpp
140+
class Solution {
141+
public:
142+
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
143+
if (n == 1) return {0};
144+
vector<vector<int>> g(n);
145+
vector<int> degree(n);
146+
for (auto& e : edges)
147+
{
148+
int a = e[0], b = e[1];
149+
g[a].push_back(b);
150+
g[b].push_back(a);
151+
++degree[a];
152+
++degree[b];
153+
}
154+
queue<int> q;
155+
for (int i = 0; i < n; ++i)
156+
if (degree[i] == 1)
157+
q.push(i);
158+
vector<int> ans;
159+
while (!q.empty())
160+
{
161+
ans.clear();
162+
for (int i = q.size(); i > 0; --i)
163+
{
164+
int a = q.front();
165+
q.pop();
166+
ans.push_back(a);
167+
for (int b : g[a])
168+
if (--degree[b] == 1)
169+
q.push(b);
170+
}
171+
}
172+
return ans;
173+
}
174+
};
175+
```
70176
177+
### **Go**
178+
179+
```go
180+
func findMinHeightTrees(n int, edges [][]int) []int {
181+
if n == 1 {
182+
return []int{0}
183+
}
184+
g := make([][]int, n)
185+
degree := make([]int, n)
186+
for _, e := range edges {
187+
a, b := e[0], e[1]
188+
g[a] = append(g[a], b)
189+
g[b] = append(g[b], a)
190+
degree[a]++
191+
degree[b]++
192+
}
193+
var q []int
194+
for i := 0; i < n; i++ {
195+
if degree[i] == 1 {
196+
q = append(q, i)
197+
}
198+
}
199+
var ans []int
200+
for len(q) > 0 {
201+
ans = []int{}
202+
for i := len(q); i > 0; i-- {
203+
a := q[0]
204+
q = q[1:]
205+
ans = append(ans, a)
206+
for _, b := range g[a] {
207+
degree[b]--
208+
if degree[b] == 1 {
209+
q = append(q, b)
210+
}
211+
}
212+
}
213+
}
214+
return ans
215+
}
71216
```
72217

73218
### **...**

Diff for: ‎solution/0300-0399/0310.Minimum Height Trees/Solution.cpp

+35
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
class Solution {
2+
public:
3+
vector<int> findMinHeightTrees(int n, vector<vector<int>>& edges) {
4+
if (n == 1) return {0};
5+
vector<vector<int>> g(n);
6+
vector<int> degree(n);
7+
for (auto& e : edges)
8+
{
9+
int a = e[0], b = e[1];
10+
g[a].push_back(b);
11+
g[b].push_back(a);
12+
++degree[a];
13+
++degree[b];
14+
}
15+
queue<int> q;
16+
for (int i = 0; i < n; ++i)
17+
if (degree[i] == 1)
18+
q.push(i);
19+
vector<int> ans;
20+
while (!q.empty())
21+
{
22+
ans.clear();
23+
for (int i = q.size(); i > 0; --i)
24+
{
25+
int a = q.front();
26+
q.pop();
27+
ans.push_back(a);
28+
for (int b : g[a])
29+
if (--degree[b] == 1)
30+
q.push(b);
31+
}
32+
}
33+
return ans;
34+
}
35+
};

0 commit comments

Comments
 (0)