Sum of Distances in Tree

You are given a connected undirected tree with n nodes numbered from 0 to n - 1. The array edges contains the tree's n - 1 edges.
Return an integer array answer of length n, where answer[u] is the sum of the shortest-path distances from node u to every other node.

Function
sumOfDistancesInTree(n: int, edges: int[][]) → int[]

Examples
Example 1
n = 6
edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]
return = [8,12,6,10,10,10]
From node 0, the distances are 0, 1, 1, 2, 2, 2, which sum to 8. Repeating the definition for each root gives the returned array.
Example 2
n = 1
edges = []
return = [0]
The only node has distance 0 to itself.

Constraints
1 <= n <= 30000
edges.length = n - 1
Every row of edges is [u, v] with 0 <= u, v < n and u != v.
edges forms one connected tree.

The trick is rerooting. Pass one: root the tree at 0, compute count[u] (subtree size) and ans[0] (sum of depths) via DFS. Pass two: for each child c of parent p, ans[c] = ans[p] - count[c] + (n - count[c]). Moving the root from p to c brings count[c] nodes one step closer and pushes the other n - count[c] nodes one step farther. The common pitfall is the off-by-one in that formula, or using recursion on a 30000-node path-shaped tree and blowing the stack. Use an iterative DFS or raise the recursion limit. Also handle n = 1 returning [0]. Build an adjacency list, not a matrix. If you blank on the reroot step during the live OA, StealthCoder is the hedge: it reads the problem and hands you the two-pass solution without the proctor seeing it.

StealthCoder is the hedge for the one pattern you didn't drill. It runs invisibly during the screen share.