feat: add solutions to lc problem: No.3367 (#3815)

No.3367.Maximize Sum of Weights after Edge Removals

Author: yanglbme

solution/3300-3399/3367.Maximize Sum of Weights after Edge Removals/README.md

@@ -88,25 +88,200 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3300-3399/3367.Ma
 #### Python3
 
 ```python
-
+class Solution:
+    def maximizeSumOfWeights(self, edges: List[List[int]], k: int) -> int:
+        def dfs(u: int, fa: int) -> Tuple[int, int]:
+            s = 0
+            t = []
+            for v, w in g[u]:
+                if v == fa:
+                    continue
+                a, b = dfs(v, u)
+                s += a
+                if (d := (w + b - a)) > 0:
+                    t.append(d)
+            t.sort(reverse=True)
+            return s + sum(t[:k]), s + sum(t[: k - 1])
+
+        n = len(edges) + 1
+        g: List[List[Tuple[int, int]]] = [[] for _ in range(n)]
+        for u, v, w in edges:
+            g[u].append((v, w))
+            g[v].append((u, w))
+        x, y = dfs(0, -1)
+        return max(x, y)
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    private List<int[]>[] g;
+    private int k;
+
+    public long maximizeSumOfWeights(int[][] edges, int k) {
+        this.k = k;
+        int n = edges.length + 1;
+        g = new List[n];
+        Arrays.setAll(g, i -> new ArrayList<>());
+        for (var e : edges) {
+            int u = e[0], v = e[1], w = e[2];
+            g[u].add(new int[] {v, w});
+            g[v].add(new int[] {u, w});
+        }
+        var ans = dfs(0, -1);
+        return Math.max(ans[0], ans[1]);
+    }
+
+    private long[] dfs(int u, int fa) {
+        long s = 0;
+        List<Long> t = new ArrayList<>();
+        for (var e : g[u]) {
+            int v = e[0], w = e[1];
+            if (v == fa) {
+                continue;
+            }
+            var res = dfs(v, u);
+            s += res[0];
+            long d = w + res[1] - res[0];
+            if (d > 0) {
+                t.add(d);
+            }
+        }
+        t.sort(Comparator.reverseOrder());
+        for (int i = 0; i < Math.min(t.size(), k - 1); ++i) {
+            s += t.get(i);
+        }
+        return new long[] {s + (t.size() >= k ? t.get(k - 1) : 0), s};
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    long long maximizeSumOfWeights(vector<vector<int>>& edges, int k) {
+        int n = edges.size() + 1;
+        vector<vector<pair<int, int>>> g(n);
+        for (auto& e : edges) {
+            int u = e[0], v = e[1], w = e[2];
+            g[u].emplace_back(v, w);
+            g[v].emplace_back(u, w);
+        }
+        using ll = long long;
+        auto dfs = [&](auto&& dfs, int u, int fa) -> pair<ll, ll> {
+            ll s = 0;
+            vector<ll> t;
+            for (auto& [v, w] : g[u]) {
+                if (v == fa) {
+                    continue;
+                }
+                auto [a, b] = dfs(dfs, v, u);
+                s += a;
+                ll d = w + b - a;
+                if (d > 0) {
+                    t.push_back(d);
+                }
+            }
+            ranges::sort(t, greater<>());
+            for (int i = 0; i < min((int)t.size(), k - 1); ++i) {
+                s += t[i];
+            }
+            return {s + (t.size() >= k ? t[k - 1] : 0), s};
+        };
+
+        auto [x, y] = dfs(dfs, 0, -1);
+        return max(x, y);
+    }
+};
 ```
 
 #### Go
 
 ```go
+func maximizeSumOfWeights(edges [][]int, k int) int64 {
+	n := len(edges) + 1
+	g := make([][][]int, n)
+	for _, e := range edges {
+		u, v, w := e[0], e[1], e[2]
+		g[u] = append(g[u], []int{v, w})
+		g[v] = append(g[v], []int{u, w})
+	}
+
+	var dfs func(u, fa int) (int64, int64)
+	dfs = func(u, fa int) (int64, int64) {
+		var s int64
+		var t []int64
+		for _, e := range g[u] {
+			v, w := e[0], e[1]
+			if v == fa {
+				continue
+			}
+			a, b := dfs(v, u)
+			s += a
+			d := int64(w) + b - a
+			if d > 0 {
+				t = append(t, d)
+			}
+		}
+		sort.Slice(t, func(i, j int) bool {
+			return t[i] > t[j]
+		})
+		for i := 0; i < min(len(t), k-1); i++ {
+			s += t[i]
+		}
+		s2 := s
+		if len(t) >= k {
+			s += t[k-1]
+		}
+		return s, s2
+	}
+
+	x, y := dfs(0, -1)
+	return max(x, y)
+}
+```
 
+#### TypeScript
+
+```ts
+function maximizeSumOfWeights(edges: number[][], k: number): number {
+    const n = edges.length + 1;
+    const g: [number, number][][] = Array.from({ length: n }, () => []);
+    for (const [u, v, w] of edges) {
+        g[u].push([v, w]);
+        g[v].push([u, w]);
+    }
+    const dfs = (u: number, fa: number): [number, number] => {
+        let s = 0;
+        const t: number[] = [];
+
+        for (const [v, w] of g[u]) {
+            if (v === fa) continue;
+
+            const [a, b] = dfs(v, u);
+            s += a;
+            const d = w + b - a;
+            if (d > 0) t.push(d);
+        }
+
+        t.sort((a, b) => b - a);
+        for (let i = 0; i < Math.min(t.length, k - 1); i++) {
+            s += t[i];
+        }
+        const s2 = s;
+        if (t.length >= k) {
+            s += t[k - 1];
+        }
+
+        return [s, s2];
+    };
+
+    const [x, y] = dfs(0, -1);
+    return Math.max(x, y);
+}
 ```
 
 <!-- tabs:end -->