Skip to content

Commit c531be3

Browse files
yanglbmeyanglbme
committedDec 20, 2022
feat: add solutions to lc problem: No.1761
No.1761.Minimum Degree of a Connected Trio in a Graph
1 parent 54f67b7 commit c531be3

File tree

6 files changed

+344
-2
lines changed

6 files changed

+344
-2
lines changed
 

‎solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README.md

+123-1
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,144 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
**方法一：暴力枚举**
56+
57+
我们先将所有边存入邻接矩阵 $g$ 中，再将每个节点的度数存入数组 $deg$ 中。
58+
59+
然后枚举所有的三元组 $(i, j, k)$，其中 $i \lt j \lt k$，如果 $g[i][j] = g[j][k] = g[i][k] = 1$，则说明这三个节点构成了一个连通三元组，此时更新答案为 $deg[i] + deg[j] + deg[k] - 6$。返回最小的符合条件的答案即可。
60+
61+
时间复杂度 $O(n^3)$，空间复杂度 $O(n^2)$。其中 $n$ 为节点数。
62+
5563
<!-- tabs:start -->
5664

5765
### **Python3**
5866

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

6169
```python
62-
70+
class Solution:
71+
def minTrioDegree(self, n: int, edges: List[List[int]]) -> int:
72+
g = [[False] * n for _ in range(n)]
73+
deg = [0] * n
74+
for u, v in edges:
75+
u, v = u - 1, v - 1
76+
g[u][v] = g[v][u] = True
77+
deg[u] += 1
78+
deg[v] += 1
79+
ans = inf
80+
for i in range(n):
81+
for j in range(i + 1, n):
82+
if g[i][j]:
83+
for k in range(j + 1, n):
84+
if g[i][k] and g[j][k]:
85+
ans = min(ans, deg[i] + deg[j] + deg[k] - 6)
86+
return -1 if ans == inf else ans
6387
```
6488

6589
### **Java**
6690

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

6993
```java
94+
class Solution {
95+
public int minTrioDegree(int n, int[][] edges) {
96+
boolean[][] g = new boolean[n][n];
97+
int[] deg = new int[n];
98+
for (var e : edges) {
99+
int u = e[0] - 1, v = e[1] - 1;
100+
g[u][v] = true;
101+
g[v][u] = true;
102+
++deg[u];
103+
++deg[v];
104+
}
105+
int ans = 1 << 30;
106+
for (int i = 0; i < n; ++i) {
107+
for (int j = i + 1; j < n; ++j) {
108+
if (g[i][j]) {
109+
for (int k = j + 1; k < n; ++k) {
110+
if (g[i][k] && g[j][k]) {
111+
ans = Math.min(ans, deg[i] + deg[j] + deg[k] - 6);
112+
}
113+
}
114+
}
115+
}
116+
}
117+
return ans == 1 << 30 ? -1 : ans;
118+
}
119+
}
120+
```
121+
122+
### **C++**
123+
124+
```cpp
125+
class Solution {
126+
public:
127+
int minTrioDegree(int n, vector<vector<int>>& edges) {
128+
bool g[n][n];
129+
memset(g, 0, sizeof g);
130+
int deg[n];
131+
memset(deg, 0, sizeof deg);
132+
for (auto& e : edges) {
133+
int u = e[0] - 1, v = e[1] - 1;
134+
g[u][v] = g[v][u] = true;
135+
deg[u]++, deg[v]++;
136+
}
137+
int ans = INT_MAX;
138+
for (int i = 0; i < n; ++i) {
139+
for (int j = i + 1; j < n; ++j) {
140+
if (g[i][j]) {
141+
for (int k = j + 1; k < n; ++k) {
142+
if (g[j][k] && g[i][k]) {
143+
ans = min(ans, deg[i] + deg[j] + deg[k] - 6);
144+
}
145+
}
146+
}
147+
}
148+
}
149+
return ans == INT_MAX ? -1 : ans;
150+
}
151+
};
152+
```
70153
154+
### **Go**
155+
156+
```go
157+
func minTrioDegree(n int, edges [][]int) int {
158+
g := make([][]bool, n)
159+
deg := make([]int, n)
160+
for i := range g {
161+
g[i] = make([]bool, n)
162+
}
163+
for _, e := range edges {
164+
u, v := e[0]-1, e[1]-1
165+
g[u][v], g[v][u] = true, true
166+
deg[u]++
167+
deg[v]++
168+
}
169+
ans := 1 << 30
170+
for i := 0; i < n; i++ {
171+
for j := i + 1; j < n; j++ {
172+
if g[i][j] {
173+
for k := j + 1; k < n; k++ {
174+
if g[i][k] && g[j][k] {
175+
ans = min(ans, deg[i]+deg[j]+deg[k]-6)
176+
}
177+
}
178+
}
179+
}
180+
}
181+
if ans == 1<<30 {
182+
return -1
183+
}
184+
return ans
185+
}
186+
187+
func min(a, b int) int {
188+
if a < b {
189+
return a
190+
}
191+
return b
192+
}
71193
```
72194

73195
### **...**

‎solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/README_EN.md

+115-1
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,127 @@
5151
### **Python3**
5252

5353
```python
54-
54+
class Solution:
55+
def minTrioDegree(self, n: int, edges: List[List[int]]) -> int:
56+
g = [[False] * n for _ in range(n)]
57+
deg = [0] * n
58+
for u, v in edges:
59+
u, v = u - 1, v - 1
60+
g[u][v] = g[v][u] = True
61+
deg[u] += 1
62+
deg[v] += 1
63+
ans = inf
64+
for i in range(n):
65+
for j in range(i + 1, n):
66+
if g[i][j]:
67+
for k in range(j + 1, n):
68+
if g[i][k] and g[j][k]:
69+
ans = min(ans, deg[i] + deg[j] + deg[k] - 6)
70+
return -1 if ans == inf else ans
5571
```
5672

5773
### **Java**
5874

5975
```java
76+
class Solution {
77+
public int minTrioDegree(int n, int[][] edges) {
78+
boolean[][] g = new boolean[n][n];
79+
int[] deg = new int[n];
80+
for (var e : edges) {
81+
int u = e[0] - 1, v = e[1] - 1;
82+
g[u][v] = true;
83+
g[v][u] = true;
84+
++deg[u];
85+
++deg[v];
86+
}
87+
int ans = 1 << 30;
88+
for (int i = 0; i < n; ++i) {
89+
for (int j = i + 1; j < n; ++j) {
90+
if (g[i][j]) {
91+
for (int k = j + 1; k < n; ++k) {
92+
if (g[i][k] && g[j][k]) {
93+
ans = Math.min(ans, deg[i] + deg[j] + deg[k] - 6);
94+
}
95+
}
96+
}
97+
}
98+
}
99+
return ans == 1 << 30 ? -1 : ans;
100+
}
101+
}
102+
```
103+
104+
### **C++**
105+
106+
```cpp
107+
class Solution {
108+
public:
109+
int minTrioDegree(int n, vector<vector<int>>& edges) {
110+
bool g[n][n];
111+
memset(g, 0, sizeof g);
112+
int deg[n];
113+
memset(deg, 0, sizeof deg);
114+
for (auto& e : edges) {
115+
int u = e[0] - 1, v = e[1] - 1;
116+
g[u][v] = g[v][u] = true;
117+
deg[u]++, deg[v]++;
118+
}
119+
int ans = INT_MAX;
120+
for (int i = 0; i < n; ++i) {
121+
for (int j = i + 1; j < n; ++j) {
122+
if (g[i][j]) {
123+
for (int k = j + 1; k < n; ++k) {
124+
if (g[j][k] && g[i][k]) {
125+
ans = min(ans, deg[i] + deg[j] + deg[k] - 6);
126+
}
127+
}
128+
}
129+
}
130+
}
131+
return ans == INT_MAX ? -1 : ans;
132+
}
133+
};
134+
```
60135
136+
### **Go**
137+
138+
```go
139+
func minTrioDegree(n int, edges [][]int) int {
140+
g := make([][]bool, n)
141+
deg := make([]int, n)
142+
for i := range g {
143+
g[i] = make([]bool, n)
144+
}
145+
for _, e := range edges {
146+
u, v := e[0]-1, e[1]-1
147+
g[u][v], g[v][u] = true, true
148+
deg[u]++
149+
deg[v]++
150+
}
151+
ans := 1 << 30
152+
for i := 0; i < n; i++ {
153+
for j := i + 1; j < n; j++ {
154+
if g[i][j] {
155+
for k := j + 1; k < n; k++ {
156+
if g[i][k] && g[j][k] {
157+
ans = min(ans, deg[i]+deg[j]+deg[k]-6)
158+
}
159+
}
160+
}
161+
}
162+
}
163+
if ans == 1<<30 {
164+
return -1
165+
}
166+
return ans
167+
}
168+
169+
func min(a, b int) int {
170+
if a < b {
171+
return a
172+
}
173+
return b
174+
}
61175
```
62176

63177
### **...**

‎solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/Solution.cpp

+27
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
class Solution {
2+
public:
3+
int minTrioDegree(int n, vector<vector<int>>& edges) {
4+
bool g[n][n];
5+
memset(g, 0, sizeof g);
6+
int deg[n];
7+
memset(deg, 0, sizeof deg);
8+
for (auto& e : edges) {
9+
int u = e[0] - 1, v = e[1] - 1;
10+
g[u][v] = g[v][u] = true;
11+
deg[u]++, deg[v]++;
12+
}
13+
int ans = INT_MAX;
14+
for (int i = 0; i < n; ++i) {
15+
for (int j = i + 1; j < n; ++j) {
16+
if (g[i][j]) {
17+
for (int k = j + 1; k < n; ++k) {
18+
if (g[j][k] && g[i][k]) {
19+
ans = min(ans, deg[i] + deg[j] + deg[k] - 6);
20+
}
21+
}
22+
}
23+
}
24+
}
25+
return ans == INT_MAX ? -1 : ans;
26+
}
27+
};

‎solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/Solution.go

+36
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,36 @@
1+
func minTrioDegree(n int, edges [][]int) int {
2+
g := make([][]bool, n)
3+
deg := make([]int, n)
4+
for i := range g {
5+
g[i] = make([]bool, n)
6+
}
7+
for _, e := range edges {
8+
u, v := e[0]-1, e[1]-1
9+
g[u][v], g[v][u] = true, true
10+
deg[u]++
11+
deg[v]++
12+
}
13+
ans := 1 << 30
14+
for i := 0; i < n; i++ {
15+
for j := i + 1; j < n; j++ {
16+
if g[i][j] {
17+
for k := j + 1; k < n; k++ {
18+
if g[i][k] && g[j][k] {
19+
ans = min(ans, deg[i]+deg[j]+deg[k]-6)
20+
}
21+
}
22+
}
23+
}
24+
}
25+
if ans == 1<<30 {
26+
return -1
27+
}
28+
return ans
29+
}
30+
31+
func min(a, b int) int {
32+
if a < b {
33+
return a
34+
}
35+
return b
36+
}

‎solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/Solution.java

+26
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
class Solution {
2+
public int minTrioDegree(int n, int[][] edges) {
3+
boolean[][] g = new boolean[n][n];
4+
int[] deg = new int[n];
5+
for (var e : edges) {
6+
int u = e[0] - 1, v = e[1] - 1;
7+
g[u][v] = true;
8+
g[v][u] = true;
9+
++deg[u];
10+
++deg[v];
11+
}
12+
int ans = 1 << 30;
13+
for (int i = 0; i < n; ++i) {
14+
for (int j = i + 1; j < n; ++j) {
15+
if (g[i][j]) {
16+
for (int k = j + 1; k < n; ++k) {
17+
if (g[i][k] && g[j][k]) {
18+
ans = Math.min(ans, deg[i] + deg[j] + deg[k] - 6);
19+
}
20+
}
21+
}
22+
}
23+
}
24+
return ans == 1 << 30 ? -1 : ans;
25+
}
26+
}

‎solution/1700-1799/1761.Minimum Degree of a Connected Trio in a Graph/Solution.py

+17
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution:
2+
def minTrioDegree(self, n: int, edges: List[List[int]]) -> int:
3+
g = [[False] * n for _ in range(n)]
4+
deg = [0] * n
5+
for u, v in edges:
6+
u, v = u - 1, v - 1
7+
g[u][v] = g[v][u] = True
8+
deg[u] += 1
9+
deg[v] += 1
10+
ans = inf
11+
for i in range(n):
12+
for j in range(i + 1, n):
13+
if g[i][j]:
14+
for k in range(j + 1, n):
15+
if g[i][k] and g[j][k]:
16+
ans = min(ans, deg[i] + deg[j] + deg[k] - 6)
17+
return -1 if ans == inf else ans

0 commit comments

Comments
 (0)