Skip to content

Commit d783956

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.2872 (#1738)
No.2872.Maximum Number of K-Divisible Components
1 parent 1e462ee commit d783956

File tree

7 files changed

+390
-35
lines changed

7 files changed

+390
-35
lines changed

‎solution/2800-2899/2872.Maximum Number of K-Divisible Components/README.md

+136-4
Original file line numberDiff line numberDiff line change
@@ -62,20 +62,81 @@
6262

6363
<!-- 这里可写通用的实现逻辑 -->
6464

65+
**方法一：DFS**
66+
67+
我们注意到，题目保证了整棵树的节点值之和可以被 $k$ 整除，因此，如果我们删除一棵元素和能被 $k$ 整除的边，那么剩下的每个连通块的节点值之和也一定可以被 $k$ 整除。
68+
69+
因此，我们可以使用深度优先搜索的方法，从根节点开始遍历整棵树，对于每个节点，我们计算其子树中所有节点值之和，如果该和能被 $k$ 整除，那么我们就将答案加一。
70+
71+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是树中的节点数。
72+
6573
<!-- tabs:start -->
6674

6775
### **Python3**
6876

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

7179
```python
72-
80+
class Solution:
81+
def maxKDivisibleComponents(
82+
self, n: int, edges: List[List[int]], values: List[int], k: int
83+
) -> int:
84+
def dfs(i: int, fa: int) -> int:
85+
s = values[i]
86+
for j in g[i]:
87+
if j != fa:
88+
s += dfs(j, i)
89+
nonlocal ans
90+
ans += s % k == 0
91+
return s
92+
93+
g = [[] for _ in range(n)]
94+
for a, b in edges:
95+
g[a].append(b)
96+
g[b].append(a)
97+
ans = 0
98+
dfs(0, -1)
99+
return ans
73100
```
74101

75102
### **Java**
76103

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

106+
```java
107+
class Solution {
108+
private int ans;
109+
private List<Integer>[] g;
110+
private int[] values;
111+
private int k;
112+
113+
public int maxKDivisibleComponents(int n, int[][] edges, int[] values, int k) {
114+
g = new List[n];
115+
Arrays.setAll(g, i -> new ArrayList<>());
116+
for (int[] e : edges) {
117+
int a = e[0], b = e[1];
118+
g[a].add(b);
119+
g[b].add(a);
120+
}
121+
this.values = values;
122+
this.k = k;
123+
dfs(0, -1);
124+
return ans;
125+
}
126+
127+
private long dfs(int i, int fa) {
128+
long s = values[i];
129+
for (int j : g[i]) {
130+
if (j != fa) {
131+
s += dfs(j, i);
132+
}
133+
}
134+
ans += s % k == 0 ? 1 : 0;
135+
return s;
136+
}
137+
}
138+
```
139+
79140
```java
80141
class Solution {
81142
int n, k;
@@ -116,19 +177,90 @@ class Solution {
116177
### **C++**
117178

118179
```cpp
119-
180+
class Solution {
181+
public:
182+
int maxKDivisibleComponents(int n, vector<vector<int>>& edges, vector<int>& values, int k) {
183+
int ans = 0;
184+
vector<int> g[n];
185+
for (auto& e : edges) {
186+
int a = e[0], b = e[1];
187+
g[a].push_back(b);
188+
g[b].push_back(a);
189+
}
190+
function<long long(int, int)> dfs = [&](int i, int fa) {
191+
long long s = values[i];
192+
for (int j : g[i]) {
193+
if (j != fa) {
194+
s += dfs(j, i);
195+
}
196+
}
197+
ans += s % k == 0;
198+
return s;
199+
};
200+
dfs(0, -1);
201+
return ans;
202+
}
203+
};
120204
```
121205
122206
### **Go**
123207
124208
```go
125-
209+
func maxKDivisibleComponents(n int, edges [][]int, values []int, k int) (ans int) {
210+
g := make([][]int, n)
211+
for _, e := range edges {
212+
a, b := e[0], e[1]
213+
g[a] = append(g[a], b)
214+
g[b] = append(g[b], a)
215+
}
216+
var dfs func(int, int) int
217+
dfs = func(i, fa int) int {
218+
s := values[i]
219+
for _, j := range g[i] {
220+
if j != fa {
221+
s += dfs(j, i)
222+
}
223+
}
224+
if s%k == 0 {
225+
ans++
226+
}
227+
return s
228+
}
229+
dfs(0, -1)
230+
return
231+
}
126232
```
127233

128234
### **TypeScript**
129235

130236
```ts
131-
237+
function maxKDivisibleComponents(
238+
n: number,
239+
edges: number[][],
240+
values: number[],
241+
k: number,
242+
): number {
243+
const g: number[][] = Array.from({ length: n }, () => []);
244+
for (const [a, b] of edges) {
245+
g[a].push(b);
246+
g[b].push(a);
247+
}
248+
let ans = 0;
249+
const dfs = (i: number, fa: number): number => {
250+
let s = values[i];
251+
for (const j of g[i]) {
252+
if (j !== fa) {
253+
s += dfs(j, i);
254+
}
255+
}
256+
if (s % k === 0) {
257+
++ans;
258+
}
259+
return s;
260+
};
261+
dfs(0, -1);
262+
return ans;
263+
}
132264
```
133265

134266
### **...**

‎solution/2800-2899/2872.Maximum Number of K-Divisible Components/README_EN.md

+135-3
Original file line numberDiff line numberDiff line change
@@ -52,16 +52,77 @@ It can be shown that no other valid split has more than 3 connected components.
5252

5353
## Solutions
5454

55+
**Solution 1: DFS**
56+
57+
We notice that the problem guarantees that the sum of the node values in the entire tree can be divided by $k$, so if we remove an edge whose weight is divisible by $k$, then the sum of the node values in each connected component that remains can also be divided by $k$.
58+
59+
Therefore, we can use depth-first search to traverse the entire tree starting from the root node. For each node, we calculate the sum of all node values in its subtree. If this sum can be divided by k, then we increment the answer by one.
60+
61+
The time complexity is $O(n)$, and the space complexity is $O(n)$, where n is the number of nodes in the tree.
62+
5563
<!-- tabs:start -->
5664

5765
### **Python3**
5866

5967
```python
68+
class Solution:
69+
def maxKDivisibleComponents(
70+
self, n: int, edges: List[List[int]], values: List[int], k: int
71+
) -> int:
72+
def dfs(i: int, fa: int) -> int:
73+
s = values[i]
74+
for j in g[i]:
75+
if j != fa:
76+
s += dfs(j, i)
77+
nonlocal ans
78+
ans += s % k == 0
79+
return s
6080

81+
g = [[] for _ in range(n)]
82+
for a, b in edges:
83+
g[a].append(b)
84+
g[b].append(a)
85+
ans = 0
86+
dfs(0, -1)
87+
return ans
6188
```
6289

6390
### **Java**
6491

92+
```java
93+
class Solution {
94+
private int ans;
95+
private List<Integer>[] g;
96+
private int[] values;
97+
private int k;
98+
99+
public int maxKDivisibleComponents(int n, int[][] edges, int[] values, int k) {
100+
g = new List[n];
101+
Arrays.setAll(g, i -> new ArrayList<>());
102+
for (int[] e : edges) {
103+
int a = e[0], b = e[1];
104+
g[a].add(b);
105+
g[b].add(a);
106+
}
107+
this.values = values;
108+
this.k = k;
109+
dfs(0, -1);
110+
return ans;
111+
}
112+
113+
private long dfs(int i, int fa) {
114+
long s = values[i];
115+
for (int j : g[i]) {
116+
if (j != fa) {
117+
s += dfs(j, i);
118+
}
119+
}
120+
ans += s % k == 0 ? 1 : 0;
121+
return s;
122+
}
123+
}
124+
```
125+
65126
```java
66127
class Solution {
67128
int n, k;
@@ -102,19 +163,90 @@ class Solution {
102163
### **C++**
103164

104165
```cpp
105-
166+
class Solution {
167+
public:
168+
int maxKDivisibleComponents(int n, vector<vector<int>>& edges, vector<int>& values, int k) {
169+
int ans = 0;
170+
vector<int> g[n];
171+
for (auto& e : edges) {
172+
int a = e[0], b = e[1];
173+
g[a].push_back(b);
174+
g[b].push_back(a);
175+
}
176+
function<long long(int, int)> dfs = [&](int i, int fa) {
177+
long long s = values[i];
178+
for (int j : g[i]) {
179+
if (j != fa) {
180+
s += dfs(j, i);
181+
}
182+
}
183+
ans += s % k == 0;
184+
return s;
185+
};
186+
dfs(0, -1);
187+
return ans;
188+
}
189+
};
106190
```
107191
108192
### **Go**
109193
110194
```go
111-
195+
func maxKDivisibleComponents(n int, edges [][]int, values []int, k int) (ans int) {
196+
g := make([][]int, n)
197+
for _, e := range edges {
198+
a, b := e[0], e[1]
199+
g[a] = append(g[a], b)
200+
g[b] = append(g[b], a)
201+
}
202+
var dfs func(int, int) int
203+
dfs = func(i, fa int) int {
204+
s := values[i]
205+
for _, j := range g[i] {
206+
if j != fa {
207+
s += dfs(j, i)
208+
}
209+
}
210+
if s%k == 0 {
211+
ans++
212+
}
213+
return s
214+
}
215+
dfs(0, -1)
216+
return
217+
}
112218
```
113219

114220
### **TypeScript**
115221

116222
```ts
117-
223+
function maxKDivisibleComponents(
224+
n: number,
225+
edges: number[][],
226+
values: number[],
227+
k: number,
228+
): number {
229+
const g: number[][] = Array.from({ length: n }, () => []);
230+
for (const [a, b] of edges) {
231+
g[a].push(b);
232+
g[b].push(a);
233+
}
234+
let ans = 0;
235+
const dfs = (i: number, fa: number): number => {
236+
let s = values[i];
237+
for (const j of g[i]) {
238+
if (j !== fa) {
239+
s += dfs(j, i);
240+
}
241+
}
242+
if (s % k === 0) {
243+
++ans;
244+
}
245+
return s;
246+
};
247+
dfs(0, -1);
248+
return ans;
249+
}
118250
```
119251

120252
### **...**

‎solution/2800-2899/2872.Maximum Number of K-Divisible Components/Solution.cpp

+24
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,24 @@
1+
class Solution {
2+
public:
3+
int maxKDivisibleComponents(int n, vector<vector<int>>& edges, vector<int>& values, int k) {
4+
int ans = 0;
5+
vector<int> g[n];
6+
for (auto& e : edges) {
7+
int a = e[0], b = e[1];
8+
g[a].push_back(b);
9+
g[b].push_back(a);
10+
}
11+
function<long long(int, int)> dfs = [&](int i, int fa) {
12+
long long s = values[i];
13+
for (int j : g[i]) {
14+
if (j != fa) {
15+
s += dfs(j, i);
16+
}
17+
}
18+
ans += s % k == 0;
19+
return s;
20+
};
21+
dfs(0, -1);
22+
return ans;
23+
}
24+
};

‎solution/2800-2899/2872.Maximum Number of K-Divisible Components/Solution.go

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
func maxKDivisibleComponents(n int, edges [][]int, values []int, k int) (ans int) {
2+
g := make([][]int, n)
3+
for _, e := range edges {
4+
a, b := e[0], e[1]
5+
g[a] = append(g[a], b)
6+
g[b] = append(g[b], a)
7+
}
8+
var dfs func(int, int) int
9+
dfs = func(i, fa int) int {
10+
s := values[i]
11+
for _, j := range g[i] {
12+
if j != fa {
13+
s += dfs(j, i)
14+
}
15+
}
16+
if s%k == 0 {
17+
ans++
18+
}
19+
return s
20+
}
21+
dfs(0, -1)
22+
return
23+
}

0 commit comments

Comments
 (0)