@@ -88,25 +88,200 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3367.Ma
8888#### Python3
8989
9090``` python
91- 91+ class Solution :
92+ def maximizeSumOfWeights (self edges : List[List[int ]], k : int ) -> int :
93+ def dfs (u : int , fa : int ) -> Tuple[int , int ]:
94+ s = 0
95+ t = []
96+ for v, w in g[u]:
97+ if v == fa:
98+ continue
99+ a, b = dfs(v, u)
100+ s += a
101+ if (d := (w + b - a)) > 0 :
102+ t.append(d)
103+ t.sort(reverse = True )
104+ return s + sum (t[:k]), s + sum (t[: k - 1 ])
105+ 106+ n = len (edges) + 1
107+ g: List[List[Tuple[int , int ]]] = [[] for _ in range (n)]
108+ for u, v, w in edges:
109+ g[u].append((v, w))
110+ g[v].append((u, w))
111+ x, y = dfs(0 , - 1 )
112+ return max (x, y)
92113```
93114
94115#### Java
95116
96117``` java
97- 118+ class Solution {
119+ private List<int[]> [] g;
120+ private int k;
121+ 122+ public long maximizeSumOfWeights (int [][] edges , int k ) {
123+ this . k = k;
124+ int n = edges. length + 1 ;
125+ g = new List [n];
126+ Arrays . setAll(g, i - > new ArrayList<> ());
127+ for (var e : edges) {
128+ int u = e[0 ], v = e[1 ], w = e[2 ];
129+ g[u]. add(new int [] {v, w});
130+ g[v]. add(new int [] {u, w});
131+ }
132+ var ans = dfs(0 , - 1 );
133+ return Math . max(ans[0 ], ans[1 ]);
134+ }
135+ 136+ private long [] dfs (int u , int fa ) {
137+ long s = 0 ;
138+ List<Long > t = new ArrayList<> ();
139+ for (var e : g[u]) {
140+ int v = e[0 ], w = e[1 ];
141+ if (v == fa) {
142+ continue ;
143+ }
144+ var res = dfs(v, u);
145+ s += res[0 ];
146+ long d = w + res[1 ] - res[0 ];
147+ if (d > 0 ) {
148+ t. add(d);
149+ }
150+ }
151+ t. sort(Comparator . reverseOrder());
152+ for (int i = 0 ; i < Math . min(t. size(), k - 1 ); ++ i) {
153+ s += t. get(i);
154+ }
155+ return new long [] {s + (t. size() >= k ? t. get(k - 1 ) : 0 ), s};
156+ }
157+ }
98158```
99159
100160#### C++
101161
102162``` cpp
103- 163+ class Solution {
164+ public:
165+ long long maximizeSumOfWeights(vector<vector<int >>& edges, int k) {
166+ int n = edges.size() + 1;
167+ vector<vector<pair<int, int>>> g(n);
168+ for (auto& e : edges) {
169+ int u = e[ 0] , v = e[ 1] , w = e[ 2] ;
170+ g[ u] .emplace_back(v, w);
171+ g[ v] .emplace_back(u, w);
172+ }
173+ using ll = long long;
174+ auto dfs = [ &] (auto&& dfs, int u, int fa) -> pair<ll, ll> {
175+ ll s = 0;
176+ vector<ll > t;
177+ for (auto& [ v, w] : g[ u] ) {
178+ if (v == fa) {
179+ continue;
180+ }
181+ auto [ a, b] = dfs(dfs, v, u);
182+ s += a;
183+ ll d = w + b - a;
184+ if (d > 0) {
185+ t.push_back(d);
186+ }
187+ }
188+ ranges::sort(t, greater<>());
189+ for (int i = 0; i < min((int)t.size(), k - 1); ++i) {
190+ s += t[ i] ;
191+ }
192+ return {s + (t.size() >= k ? t[ k - 1] : 0), s};
193+ };
194+ 195+ auto [x, y] = dfs(dfs, 0, -1);
196+ return max(x, y);
197+ }
198+ };
104199```
105200
106201#### Go
107202
108203``` go
204+ func maximizeSumOfWeights (edges [][]int , k int ) int64 {
205+ n := len (edges) + 1
206+ g := make ([][][]int , n)
207+ for _ , e := range edges {
208+ u , v , w := e[0 ], e[1 ], e[2 ]
209+ g[u] = append (g[u], []int {v, w})
210+ g[v] = append (g[v], []int {u, w})
211+ }
212+ 213+ var dfs func (u, fa int ) (int64 , int64 )
214+ dfs = func (u, fa int ) (int64 , int64 ) {
215+ var s int64
216+ var t []int64
217+ for _ , e := range g[u] {
218+ v , w := e[0 ], e[1 ]
219+ if v == fa {
220+ continue
221+ }
222+ a , b := dfs (v, u)
223+ s += a
224+ d := int64 (w) + b - a
225+ if d > 0 {
226+ t = append (t, d)
227+ }
228+ }
229+ sort.Slice (t, func (i, j int ) bool {
230+ return t[i] > t[j]
231+ })
232+ for i := 0 ; i < min (len (t), k-1 ); i++ {
233+ s += t[i]
234+ }
235+ s2 := s
236+ if len (t) >= k {
237+ s += t[k-1 ]
238+ }
239+ return s, s2
240+ }
241+ 242+ x , y := dfs (0 , -1 )
243+ return max (x, y)
244+ }
245+ ```
109246
247+ #### TypeScript
248+ 249+ ``` ts
250+ function maximizeSumOfWeights(edges : number [][], k : number ): number {
251+ const = edges .length + 1 ;
252+ const : [number , number ][][] = Array .from ({ length: n }, () => []);
253+ for (const of edges ) {
254+ g [u ].push ([v , w ]);
255+ g [v ].push ([u , w ]);
256+ }
257+ const = (u : number , fa : number ): [number , number ] => {
258+ let s = 0 ;
259+ const : number [] = [];
260+ 261+ for (const of g [u ]) {
262+ if (v === fa ) continue ;
263+ 264+ const = dfs (v , u );
265+ s += a ;
266+ const = w + b - a ;
267+ if (d > 0 ) t .push (d );
268+ }
269+ 270+ t .sort ((a , b ) => b - a );
271+ for (let i = 0 ; i < Math .min (t .length , k - 1 ); i ++ ) {
272+ s += t [i ];
273+ }
274+ const = s ;
275+ if (t .length >= k ) {
276+ s += t [k - 1 ];
277+ }
278+ 279+ return [s , s2 ];
280+ };
281+ 282+ const = dfs (0 , - 1 );
283+ return Math .max (x , y );
284+ }
110285```
111286
112287<!-- tabs:end -->
0 commit comments