Skip to content

Commit 4a05f6b

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.2378
No.2378.Choose Edges to Maximize Score in a Tree
1 parent 1becffc commit 4a05f6b

File tree

6 files changed

+341
-2
lines changed

6 files changed

+341
-2
lines changed

‎solution/2300-2399/2378.Choose Edges to Maximize Score in a Tree/README.md

+118-1
Original file line numberDiff line numberDiff line change
@@ -63,22 +63,139 @@ Note that we cannot choose more than one edge because all edges are adjacent to
6363

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

66+
**方法一：树形 DP**
67+
6668
<!-- tabs:start -->
6769

6870
### **Python3**
6971

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

7274
```python
73-
75+
class Solution:
76+
def maxScore(self, edges: List[List[int]]) -> int:
77+
def dfs(i):
78+
a = b = 0
79+
t = 0
80+
for j in g[i]:
81+
x, y = dfs(j)
82+
a += y
83+
b += y
84+
t = max(t, x - y + g[i][j])
85+
b += t
86+
return a, b
87+
88+
g = defaultdict(lambda: defaultdict(lambda: -inf))
89+
for i, (p, w) in enumerate(edges[1:], 1):
90+
g[p][i] = w
91+
return max(dfs(0))
7492
```
7593

7694
### **Java**
7795

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

8098
```java
99+
class Solution {
100+
private Map<Integer, Integer>[] g;
101+
102+
public long maxScore(int[][] edges) {
103+
int n = edges.length;
104+
g = new Map[n + 1];
105+
for (int i = 0; i < n + 1; ++i) {
106+
g[i] = new HashMap<>();
107+
}
108+
for (int i = 1; i < n; ++i) {
109+
int p = edges[i][0], w = edges[i][1];
110+
g[p].put(i, w);
111+
}
112+
return dfs(0)[1];
113+
}
114+
115+
private long[] dfs(int i) {
116+
long a = 0, b = 0;
117+
long t = 0;
118+
for (int j : g[i].keySet()) {
119+
long[] s = dfs(j);
120+
a += s[1];
121+
b += s[1];
122+
t = Math.max(t, s[0] - s[1] + g[i].get(j));
123+
}
124+
b += t;
125+
return new long[]{a, b};
126+
}
127+
}
128+
```
129+
130+
### **C++**
131+
132+
```cpp
133+
using ll = long long;
134+
135+
class Solution {
136+
public:
137+
vector<unordered_map<int, int>> g;
138+
139+
long long maxScore(vector<vector<int>>& edges) {
140+
int n = edges.size();
141+
g.resize(n + 1);
142+
for (int i = 1; i < n; ++i) {
143+
int p = edges[i][0], w = edges[i][1];
144+
g[p][i] = w;
145+
}
146+
return dfs(0).second;
147+
}
148+
149+
pair<ll, ll> dfs(int i) {
150+
ll a = 0, b = 0;
151+
ll s = 0;
152+
for (auto& [j, v] : g[i]) {
153+
auto t = dfs(j);
154+
a += t.second;
155+
b += t.second;
156+
s = max(s, t.first - t.second + v);
157+
}
158+
b += s;
159+
return {a, b};
160+
}
161+
};
162+
```
81163
164+
### **Go**
165+
166+
```go
167+
func maxScore(edges [][]int) int64 {
168+
n := len(edges)
169+
g := make([]map[int]int, n+1)
170+
for i := range g {
171+
g[i] = make(map[int]int)
172+
}
173+
for i := 1; i < n; i++ {
174+
p, w := edges[i][0], edges[i][1]
175+
g[p][i] = w
176+
}
177+
var dfs func(i int) []int
178+
dfs = func(i int) []int {
179+
a, b := 0, 0
180+
s := 0
181+
for j, v := range g[i] {
182+
t := dfs(j)
183+
a += t[1]
184+
b += t[1]
185+
s = max(s, t[0]-t[1]+v)
186+
}
187+
b += s
188+
return []int{a, b}
189+
}
190+
return int64(dfs(0)[1])
191+
}
192+
193+
func max(a, b int) int {
194+
if a > b {
195+
return a
196+
}
197+
return b
198+
}
82199
```
83200

84201
### **TypeScript**

‎solution/2300-2399/2378.Choose Edges to Maximize Score in a Tree/README_EN.md

+116-1
Original file line numberDiff line numberDiff line change
@@ -64,13 +64,128 @@ Note that we cannot choose more than one edge because all edges are adjacent to
6464
### **Python3**
6565

6666
```python
67-
67+
class Solution:
68+
def maxScore(self, edges: List[List[int]]) -> int:
69+
def dfs(i):
70+
a = b = 0
71+
t = 0
72+
for j in g[i]:
73+
x, y = dfs(j)
74+
a += y
75+
b += y
76+
t = max(t, x - y + g[i][j])
77+
b += t
78+
return a, b
79+
80+
g = defaultdict(lambda: defaultdict(lambda: -inf))
81+
for i, (p, w) in enumerate(edges[1:], 1):
82+
g[p][i] = w
83+
return max(dfs(0))
6884
```
6985

7086
### **Java**
7187

7288
```java
89+
class Solution {
90+
private Map<Integer, Integer>[] g;
91+
92+
public long maxScore(int[][] edges) {
93+
int n = edges.length;
94+
g = new Map[n + 1];
95+
for (int i = 0; i < n + 1; ++i) {
96+
g[i] = new HashMap<>();
97+
}
98+
for (int i = 1; i < n; ++i) {
99+
int p = edges[i][0], w = edges[i][1];
100+
g[p].put(i, w);
101+
}
102+
return dfs(0)[1];
103+
}
104+
105+
private long[] dfs(int i) {
106+
long a = 0, b = 0;
107+
long t = 0;
108+
for (int j : g[i].keySet()) {
109+
long[] s = dfs(j);
110+
a += s[1];
111+
b += s[1];
112+
t = Math.max(t, s[0] - s[1] + g[i].get(j));
113+
}
114+
b += t;
115+
return new long[]{a, b};
116+
}
117+
}
118+
```
119+
120+
### **C++**
121+
122+
```cpp
123+
using ll = long long;
124+
125+
class Solution {
126+
public:
127+
vector<unordered_map<int, int>> g;
128+
129+
long long maxScore(vector<vector<int>>& edges) {
130+
int n = edges.size();
131+
g.resize(n + 1);
132+
for (int i = 1; i < n; ++i) {
133+
int p = edges[i][0], w = edges[i][1];
134+
g[p][i] = w;
135+
}
136+
return dfs(0).second;
137+
}
138+
139+
pair<ll, ll> dfs(int i) {
140+
ll a = 0, b = 0;
141+
ll s = 0;
142+
for (auto& [j, v] : g[i]) {
143+
auto t = dfs(j);
144+
a += t.second;
145+
b += t.second;
146+
s = max(s, t.first - t.second + v);
147+
}
148+
b += s;
149+
return {a, b};
150+
}
151+
};
152+
```
73153
154+
### **Go**
155+
156+
```go
157+
func maxScore(edges [][]int) int64 {
158+
n := len(edges)
159+
g := make([]map[int]int, n+1)
160+
for i := range g {
161+
g[i] = make(map[int]int)
162+
}
163+
for i := 1; i < n; i++ {
164+
p, w := edges[i][0], edges[i][1]
165+
g[p][i] = w
166+
}
167+
var dfs func(i int) []int
168+
dfs = func(i int) []int {
169+
a, b := 0, 0
170+
s := 0
171+
for j, v := range g[i] {
172+
t := dfs(j)
173+
a += t[1]
174+
b += t[1]
175+
s = max(s, t[0]-t[1]+v)
176+
}
177+
b += s
178+
return []int{a, b}
179+
}
180+
return int64(dfs(0)[1])
181+
}
182+
183+
func max(a, b int) int {
184+
if a > b {
185+
return a
186+
}
187+
return b
188+
}
74189
```
75190

76191
### **TypeScript**

‎solution/2300-2399/2378.Choose Edges to Maximize Score in a Tree/Solution.cpp

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
using ll = long long;
2+
3+
class Solution {
4+
public:
5+
vector<unordered_map<int, int>> g;
6+
7+
long long maxScore(vector<vector<int>>& edges) {
8+
int n = edges.size();
9+
g.resize(n + 1);
10+
for (int i = 1; i < n; ++i) {
11+
int p = edges[i][0], w = edges[i][1];
12+
g[p][i] = w;
13+
}
14+
return dfs(0).second;
15+
}
16+
17+
pair<ll, ll> dfs(int i) {
18+
ll a = 0, b = 0;
19+
ll s = 0;
20+
for (auto& [j, v] : g[i]) {
21+
auto t = dfs(j);
22+
a += t.second;
23+
b += t.second;
24+
s = max(s, t.first - t.second + v);
25+
}
26+
b += s;
27+
return {a, b};
28+
}
29+
};

‎solution/2300-2399/2378.Choose Edges to Maximize Score in a Tree/Solution.go

+32
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
func maxScore(edges [][]int) int64 {
2+
n := len(edges)
3+
g := make([]map[int]int, n+1)
4+
for i := range g {
5+
g[i] = make(map[int]int)
6+
}
7+
for i := 1; i < n; i++ {
8+
p, w := edges[i][0], edges[i][1]
9+
g[p][i] = w
10+
}
11+
var dfs func(i int) []int
12+
dfs = func(i int) []int {
13+
a, b := 0, 0
14+
s := 0
15+
for j, v := range g[i] {
16+
t := dfs(j)
17+
a += t[1]
18+
b += t[1]
19+
s = max(s, t[0]-t[1]+v)
20+
}
21+
b += s
22+
return []int{a, b}
23+
}
24+
return int64(dfs(0)[1])
25+
}
26+
27+
func max(a, b int) int {
28+
if a > b {
29+
return a
30+
}
31+
return b
32+
}

‎solution/2300-2399/2378.Choose Edges to Maximize Score in a Tree/Solution.java

+29
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
class Solution {
2+
private Map<Integer, Integer>[] g;
3+
4+
public long maxScore(int[][] edges) {
5+
int n = edges.length;
6+
g = new Map[n + 1];
7+
for (int i = 0; i < n + 1; ++i) {
8+
g[i] = new HashMap<>();
9+
}
10+
for (int i = 1; i < n; ++i) {
11+
int p = edges[i][0], w = edges[i][1];
12+
g[p].put(i, w);
13+
}
14+
return dfs(0)[1];
15+
}
16+
17+
private long[] dfs(int i) {
18+
long a = 0, b = 0;
19+
long t = 0;
20+
for (int j : g[i].keySet()) {
21+
long[] s = dfs(j);
22+
a += s[1];
23+
b += s[1];
24+
t = Math.max(t, s[0] - s[1] + g[i].get(j));
25+
}
26+
b += t;
27+
return new long[]{a, b};
28+
}
29+
}

‎solution/2300-2399/2378.Choose Edges to Maximize Score in a Tree/Solution.py

+17
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution:
2+
def maxScore(self, edges: List[List[int]]) -> int:
3+
def dfs(i):
4+
a = b = 0
5+
t = 0
6+
for j in g[i]:
7+
x, y = dfs(j)
8+
a += y
9+
b += y
10+
t = max(t, x - y + g[i][j])
11+
b += t
12+
return a, b
13+
14+
g = defaultdict(lambda: defaultdict(lambda: -inf))
15+
for i, (p, w) in enumerate(edges[1:], 1):
16+
g[p][i] = w
17+
return max(dfs(0))

0 commit comments

Comments
 (0)