feat: add solutions to lc problem: No.0834

No.0834.Sum of Distances in Tree

Author: yanglbme

solution/0500-0599/0552.Student Attendance Record II/README_EN.md

@@ -73,7 +73,7 @@ class Solution:
                 ans += dfs(i + 1, j, k + 1)
             ans += dfs(i + 1, j, 0)
             return ans % mod
-        
+
         mod = 10**9 + 7
         ans = dfs(0, 0, 0)
         dfs.cache_clear()
@@ -266,7 +266,7 @@ class Solution {
 public:
     int checkRecord(int n) {
         this->n = n;
-        memset(f, -1, sizeof(f));        
+        memset(f, -1, sizeof(f));
         return dfs(0, 0, 0);
     }
 

solution/0600-0699/0656.Coin Path/README.md

@@ -51,9 +51,9 @@
 
 题目需要我们找到从下标 1 到下标 n 的最小花费路径，且字典序最小，我们可以使用动态规划求解。
 
-我们定义 $f[i]$ 表示从下标 $i$ 到下标 $n-1$ 的最小花费。如果 $coins[n - 1] = -1$，则不存在从下标 $n-1$ 到下标 $n-1$ 的路径，直接返回空数组即可。否则，$f[n - 1] = coins[n - 1]$。
+我们定义 $f[i]$ 表示从下标 $i$ 到下标 $n-1$ 的最小花费。如果 $coins[n - 1] = -1$，则不存在从下标 $n-1$ 到下标 $n-1$ 的路径，直接返回空数组即可。否则 $f[n - 1] = coins[n - 1]$。
 
-接下来，我们从下标 $n-2$ 开始，逆向遍历数组，对于下标 $i$，如果 $coins[i] = -1$，则 $f[i] = \infty$，否则，$f[i] = \min_{j = i + 1}^{min(n - 1, i + maxJump)} f[j] + coins[i]$。
+接下来，我们从下标 $n-2$ 开始，逆向遍历数组，对于下标 $i$，如果 $coins[i] = -1$，则 $f[i] = \infty$，否则 $f[i] = \min_{j = i + 1}^{min(n - 1, i + maxJump)} f[j] + coins[i]$。
 
 然后我们判断 $f[0]$ 是否为 $\infty$，如果是，则不存在一条满足条件的路径，返回空数组即可。否则，我们的总花费为 $s = f[0]$，我们从下标 0 开始，向后遍历数组，如果 $f[i] = s$，则说明从下标 $i$ 到下标 $n-1$ 的花费为 $s$，我们将 $s$ 减去 $coins[i]$，并将下标 $i+1$ 加入到结果数组中，直到遍历到下标 $n-1$，返回结果数组即可。
 

solution/0800-0899/0834.Sum of Distances in Tree/README.md

@@ -57,22 +57,215 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：树形 DP（换根）**
+
+我们先跑一遍 DFS，计算出每个节点的子树大小，记录在数组 $size$ 中，并且统计出节点 $0$ 到其他节点的距离之和，记录在 $ans[0]$ 中。
+
+接下来，我们再跑一遍 DFS，枚举每个点作为根节点时，其他节点到根节点的距离之和。假设当前节点 $i$ 的答案为 $t$，当我们从节点 $i$ 转移到节点 $j$ 时，距离之和变为 $t - size[j] + n - size[j]$，即距离节点 $j$ 及其子树节点的距离之和减少 $size[j]$，而距离其它节点的距离之和增加 $n - size[j]$。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为树的节点数。
+
+相似题目：
+
+-   [2581. 统计可能的树根数目](/solution/2500-2599/2581.Count%20Number%20of%20Possible%20Root%20Nodes/README.md)
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class Solution:
+    def sumOfDistancesInTree(self, n: int, edges: List[List[int]]) -> List[int]:
+        def dfs1(i: int, fa: int, d: int):
+            ans[0] += d
+            size[i] = 1
+            for j in g[i]:
+                if j != fa:
+                    dfs1(j, i, d + 1)
+                    size[i] += size[j]
 
+        def dfs2(i: int, fa: int, t: int):
+            ans[i] = t
+            for j in g[i]:
+                if j != fa:
+                    dfs2(j, i, t - size[j] + n - size[j])
+
+        g = defaultdict(list)
+        for a, b in edges:
+            g[a].append(b)
+            g[b].append(a)
+
+        ans = [0] * n
+        size = [0] * n
+        dfs1(0, -1, 0)
+        dfs2(0, -1, ans[0])
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private int n;
+    private int[] ans;
+    private int[] size;
+    private List<Integer>[] g;
+
+    public int[] sumOfDistancesInTree(int n, int[][] edges) {
+        this.n = n;
+        g = new List[n];
+        ans = new int[n];
+        size = new int[n];
+        Arrays.setAll(g, k -> new ArrayList<>());
+        for (var e : edges) {
+            int a = e[0], b = e[1];
+            g[a].add(b);
+            g[b].add(a);
+        }
+        dfs1(0, -1, 0);
+        dfs2(0, -1, ans[0]);
+        return ans;
+    }
+
+    private void dfs1(int i, int fa, int d) {
+        ans[0] += d;
+        size[i] = 1;
+        for (int j : g[i]) {
+            if (j != fa) {
+                dfs1(j, i, d + 1);
+                size[i] += size[j];
+            }
+        }
+    }
+
+    private void dfs2(int i, int fa, int t) {
+        ans[i] = t;
+        for (int j : g[i]) {
+            if (j != fa) {
+                dfs2(j, i, t - size[j] + n - size[j]);
+            }
+        }
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> sumOfDistancesInTree(int n, vector<vector<int>>& edges) {
+        vector<vector<int>> g(n);
+        for (auto& e : edges) {
+            int a = e[0], b = e[1];
+            g[a].push_back(b);
+            g[b].push_back(a);
+        }
+        vector<int> ans(n);
+        vector<int> size(n);
+
+        function<void(int, int, int)> dfs1 = [&](int i, int fa, int d) {
+            ans[0] += d;
+            size[i] = 1;
+            for (int& j : g[i]) {
+                if (j != fa) {
+                    dfs1(j, i, d + 1);
+                    size[i] += size[j];
+                }
+            }
+        };
+
+        function<void(int, int, int)> dfs2 = [&](int i, int fa, int t) {
+            ans[i] = t;
+            for (int& j : g[i]) {
+                if (j != fa) {
+                    dfs2(j, i, t - size[j] + n - size[j]);
+                }
+            }
+        };
+
+        dfs1(0, -1, 0);
+        dfs2(0, -1, ans[0]);
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func sumOfDistancesInTree(n int, edges [][]int) []int {
+	g := make([][]int, n)
+	for _, e := range edges {
+		a, b := e[0], e[1]
+		g[a] = append(g[a], b)
+		g[b] = append(g[b], a)
+	}
+	ans := make([]int, n)
+	size := make([]int, n)
+	var dfs1 func(i, fa, d int)
+	dfs1 = func(i, fa, d int) {
+		ans[0] += d
+		size[i] = 1
+		for _, j := range g[i] {
+			if j != fa {
+				dfs1(j, i, d+1)
+				size[i] += size[j]
+			}
+		}
+	}
+	var dfs2 func(i, fa, t int)
+	dfs2 = func(i, fa, t int) {
+		ans[i] = t
+		for _, j := range g[i] {
+			if j != fa {
+				dfs2(j, i, t-size[j]+n-size[j])
+			}
+		}
+	}
+	dfs1(0, -1, 0)
+	dfs2(0, -1, ans[0])
+	return ans
+}
+```
+
+### **TypeScript**
 
+```ts
+function sumOfDistancesInTree(n: number, edges: number[][]): number[] {
+    const g: number[][] = Array.from({ length: n }, () => []);
+    for (const [a, b] of edges) {
+        g[a].push(b);
+        g[b].push(a);
+    }
+    const ans: number[] = new Array(n).fill(0);
+    const size: number[] = new Array(n).fill(0);
+    const dfs1 = (i: number, fa: number, d: number) => {
+        ans[0] += d;
+        size[i] = 1;
+        for (const j of g[i]) {
+            if (j !== fa) {
+                dfs1(j, i, d + 1);
+                size[i] += size[j];
+            }
+        }
+    };
+    const dfs2 = (i: number, fa: number, t: number) => {
+        ans[i] = t;
+        for (const j of g[i]) {
+            if (j != fa) {
+                dfs2(j, i, t - size[j] + n - size[j]);
+            }
+        }
+    };
+    dfs1(0, -1, 0);
+    dfs2(0, -1, ans[0]);
+    return ans;
+}
 ```
 
 ### **...**