An undirected, connected tree with N
nodes labelled 0...N-1
and N-1
edges
are given.
The i
th edge connects nodes edges[i][0]
and edges[i][1]
together.
Return a list ans
, where ans[i]
is the sum of the distances between node i
and all other nodes.
Example 1:
Input: N = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]] Output: [8,12,6,10,10,10] Explanation: Here is a diagram of the given tree: 0 / \ 1 2 /|\ 3 4 5 We can see that dist(0,1) + dist(0,2) + dist(0,3) + dist(0,4) + dist(0,5) equals 1 + 1 + 2 + 2 + 2 = 8. Hence, answer[0] = 8, and so on.
Note: 1 <= N <= 10000
题目理解:用给定一个无向图,保证这个无向图可以构成树,这棵树有N个节点,问每一个节点到其他所有节点的距离之和
解题思路:可以很明显的看出来,如果用f(cur)表示cur节点到其他所有节点的距离之和,那么f(cur)与f(cur的父节点)之间是有关系的,仔细分析一下我们可以了解到:
f(cur)= f(cur的父节点)- cur的所有子节点个数 + (N - 2)
因为要知道每一个节点的子节点个数,因此首先要遍历一次整棵树,记录这一信息。每次只需要知道父节点的信息,因此我们考虑使用层次遍历。而且我们还需要计算出循环的第一个信息,即f(根节点),这样,就可以得到答案了。
class Solution {
boolean[] visited;
int[] numOfChild;
Map<Integer, List<Integer>> connected;
int sum;
int[] res;
public int[] sumOfDistancesInTree(int N, int[][] edges) {
if(N < 2)
return new int[N];
visited = new boolean[N];
numOfChild = new int[N];
Arrays.fill(numOfChild, -1);
connected = new HashMap<Integer, List<Integer>>();
for(int[] it : edges){
if(!connected.containsKey(it[0]))
connected.put(it[0], new ArrayList<Integer>());
connected.get(it[0]).add(it[1]);
if(!connected.containsKey(it[1]))
connected.put(it[1], new ArrayList<Integer>());
connected.get(it[1]).add(it[0]);
}
sum = 0;
BFS(0, 0);
//剩下的只需要遍历整棵树就可以
Arrays.fill(visited, false);
res = new int[N];
res[0] = sum;
helper(0, N);
return res;
}
public int BFS(int root, int layer){
sum += layer;
if(numOfChild[root] != -1)
return numOfChild[root];
visited[root] = true;
int num = 0;
for(int child : connected.get(root)){
if(visited[child])//如果是上层节点,就不访问
continue;
num += BFS(child, layer + 1) + 1;
}
numOfChild[root] = num;
return num;
}
public void helper(int root, int N){
visited[root] = true;
for(int child : connected.get(root)){
if(visited[child])//如果是上层节点,就不访问
continue;
int temp = res[root] - 2 * numOfChild[child] + N - 2;
//System.out.println(root + " " + child + " " + res[root] + " " + numOfChild[child]);
res[child] = temp;
helper(child, N);
}
}
}