|
69 | 69 |
|
70 | 70 | <!-- 这里可写通用的实现逻辑 --> |
71 | 71 |
|
| 72 | +**方法一:树形 DP** |
| 73 | + |
| 74 | +题目实际上是让我们从树的所有节点中选出一些节点,使得这些节点的值之和最大,并且每条从根节点到叶子节点的路径上都有一个点没有被选中。 |
| 75 | + |
| 76 | +我们可以使用树形 DP 的方法解决这个问题。 |
| 77 | + |
| 78 | +我们设计一个函数 $dfs(i, fa),ドル其中 $i$ 表示当前以节点 $i$ 作为子树的根节点,且 $fa$ 表示 $i$ 的父节点,函数返回一个长度为 2ドル$ 的数组,其中 $[0]$ 表示该子树中所有节点的值之和,而 $[1]$ 表示该子树满足每条路径上都有一个点没有被选中的最大值。 |
| 79 | + |
| 80 | +其中 $[0]$ 的值可以直接通过 DFS 累加每个节点的值得到,而 $[1]$ 的值,则需要考虑两种情况,即节点 $i$ 是否被选中。如果被选中,那么节点 $i$ 的每个子树得必须满足每条路径上都有一个点没有被选中;如果没有被选中,那么节点 $i$ 的每个子树可以选取所有节点。我们取这两种情况中的最大值即可。 |
| 81 | + |
| 82 | +需要注意的是,叶子节点的 $[1]$ 的值为 0ドル,ドル因为叶子节点没有子树,所以不需要考虑每条路径上都有一个点没有被选中的情况。 |
| 83 | + |
| 84 | +答案为 $dfs(0, -1)[1]$。 |
| 85 | + |
| 86 | +时间复杂度 $O(n),ドル空间复杂度 $O(n)$。其中 $n$ 为节点数。 |
| 87 | + |
72 | 88 | <!-- tabs:start --> |
73 | 89 |
|
74 | 90 | ### **Python3** |
75 | 91 |
|
76 | 92 | <!-- 这里可写当前语言的特殊实现逻辑 --> |
77 | 93 |
|
78 | 94 | ```python |
79 | | - |
| 95 | +class Solution: |
| 96 | + def maximumScoreAfterOperations( |
| 97 | + self, edges: List[List[int]], values: List[int] |
| 98 | + ) -> int: |
| 99 | + def dfs(i: int, fa: int = -1) -> (int, int): |
| 100 | + a = b = 0 |
| 101 | + leaf = True |
| 102 | + for j in g[i]: |
| 103 | + if j != fa: |
| 104 | + leaf = False |
| 105 | + aa, bb = dfs(j, i) |
| 106 | + a += aa |
| 107 | + b += bb |
| 108 | + if leaf: |
| 109 | + return values[i], 0 |
| 110 | + return values[i] + a, max(values[i] + b, a) |
| 111 | + |
| 112 | + g = [[] for _ in range(len(values))] |
| 113 | + for a, b in edges: |
| 114 | + g[a].append(b) |
| 115 | + g[b].append(a) |
| 116 | + return dfs(0)[1] |
80 | 117 | ``` |
81 | 118 |
|
82 | 119 | ### **Java** |
83 | 120 |
|
84 | 121 | <!-- 这里可写当前语言的特殊实现逻辑 --> |
85 | 122 |
|
86 | 123 | ```java |
87 | | - |
| 124 | +class Solution { |
| 125 | + private List<Integer>[] g; |
| 126 | + private int[] values; |
| 127 | + |
| 128 | + public long maximumScoreAfterOperations(int[][] edges, int[] values) { |
| 129 | + int n = values.length; |
| 130 | + g = new List[n]; |
| 131 | + this.values = values; |
| 132 | + Arrays.setAll(g, k -> new ArrayList<>()); |
| 133 | + for (var e : edges) { |
| 134 | + int a = e[0], b = e[1]; |
| 135 | + g[a].add(b); |
| 136 | + g[b].add(a); |
| 137 | + } |
| 138 | + return dfs(0, -1)[1]; |
| 139 | + } |
| 140 | + |
| 141 | + private long[] dfs(int i, int fa) { |
| 142 | + long a = 0, b = 0; |
| 143 | + boolean leaf = true; |
| 144 | + for (int j : g[i]) { |
| 145 | + if (j != fa) { |
| 146 | + leaf = false; |
| 147 | + var t = dfs(j, i); |
| 148 | + a += t[0]; |
| 149 | + b += t[1]; |
| 150 | + } |
| 151 | + } |
| 152 | + if (leaf) { |
| 153 | + return new long[] {values[i], 0}; |
| 154 | + } |
| 155 | + return new long[] {values[i] + a, Math.max(values[i] + b, a)}; |
| 156 | + } |
| 157 | +} |
88 | 158 | ``` |
89 | 159 |
|
90 | 160 | ### **C++** |
91 | 161 |
|
92 | 162 | ```cpp |
93 | | - |
| 163 | +class Solution { |
| 164 | +public: |
| 165 | + long long maximumScoreAfterOperations(vector<vector<int>>& edges, vector<int>& values) { |
| 166 | + int n = values.size(); |
| 167 | + vector<int> g[n]; |
| 168 | + for (auto& e : edges) { |
| 169 | + int a = e[0], b = e[1]; |
| 170 | + g[a].emplace_back(b); |
| 171 | + g[b].emplace_back(a); |
| 172 | + } |
| 173 | + using ll = long long; |
| 174 | + function<pair<ll, ll>(int, int)> dfs = [&](int i, int fa) -> pair<ll, ll> { |
| 175 | + ll a = 0, b = 0; |
| 176 | + bool leaf = true; |
| 177 | + for (int j : g[i]) { |
| 178 | + if (j != fa) { |
| 179 | + auto [aa, bb] = dfs(j, i); |
| 180 | + a += aa; |
| 181 | + b += bb; |
| 182 | + leaf = false; |
| 183 | + } |
| 184 | + } |
| 185 | + if (leaf) { |
| 186 | + return {values[i], 0LL}; |
| 187 | + } |
| 188 | + return {values[i] + a, max(values[i] + b, a)}; |
| 189 | + }; |
| 190 | + auto [_, b] = dfs(0, -1); |
| 191 | + return b; |
| 192 | + } |
| 193 | +}; |
94 | 194 | ``` |
95 | 195 | |
96 | 196 | ### **Go** |
97 | 197 | |
98 | 198 | ```go |
| 199 | +func maximumScoreAfterOperations(edges [][]int, values []int) int64 { |
| 200 | + g := make([][]int, len(values)) |
| 201 | + for _, e := range edges { |
| 202 | + a, b := e[0], e[1] |
| 203 | + g[a] = append(g[a], b) |
| 204 | + g[b] = append(g[b], a) |
| 205 | + } |
| 206 | + var dfs func(int, int) (int64, int64) |
| 207 | + dfs = func(i, fa int) (int64, int64) { |
| 208 | + a, b := int64(0), int64(0) |
| 209 | + leaf := true |
| 210 | + for _, j := range g[i] { |
| 211 | + if j != fa { |
| 212 | + leaf = false |
| 213 | + aa, bb := dfs(j, i) |
| 214 | + a += aa |
| 215 | + b += bb |
| 216 | + } |
| 217 | + } |
| 218 | + if leaf { |
| 219 | + return int64(values[i]), int64(0) |
| 220 | + } |
| 221 | + return int64(values[i]) + a, max(int64(values[i])+b, a) |
| 222 | + } |
| 223 | + _, b := dfs(0, -1) |
| 224 | + return b |
| 225 | +} |
| 226 | +``` |
99 | 227 |
|
| 228 | +### **TypeScript** |
| 229 | + |
| 230 | +```ts |
| 231 | +function maximumScoreAfterOperations(edges: number[][], values: number[]): number { |
| 232 | + const g: number[][] = Array.from({ length: values.length }, () => []); |
| 233 | + for (const [a, b] of edges) { |
| 234 | + g[a].push(b); |
| 235 | + g[b].push(a); |
| 236 | + } |
| 237 | + const dfs = (i: number, fa: number): [number, number] => { |
| 238 | + let [a, b] = [0, 0]; |
| 239 | + let leaf = true; |
| 240 | + for (const j of g[i]) { |
| 241 | + if (j !== fa) { |
| 242 | + const [aa, bb] = dfs(j, i); |
| 243 | + a += aa; |
| 244 | + b += bb; |
| 245 | + leaf = false; |
| 246 | + } |
| 247 | + } |
| 248 | + if (leaf) { |
| 249 | + return [values[i], 0]; |
| 250 | + } |
| 251 | + return [values[i] + a, Math.max(values[i] + b, a)]; |
| 252 | + }; |
| 253 | + return dfs(0, -1)[1]; |
| 254 | +} |
100 | 255 | ``` |
101 | 256 |
|
102 | 257 | ### **...** |
|
0 commit comments