[leetcode 834] 树中距离之和，深度搜索建树

题目描述

https://leetcode-cn.com/problems/sum-of-distances-in-tree/

分析

这个题是把所有的点都当做根节点，然后分别计算根节点到其他所有节点的距离之和。
我们可以用深度优先遍历的方式，从根节点出发，然后遍历所有的路径，这样就可以求得结果，但是这样的时间复杂度是O(n * n)，再结合这个困难的难度，应该是不行的。

那么以其他节点为根节点的所有路径的距离，是否和其他距离之间有着一些关系呢

公式的推导

我们假设两个节点是x和y，他们在树中有一条边连接着，然后我们去掉这条边，就可以得到一个以x为根节点的子树X，和一个以y为根节点的子树Y。

• 分析以x节点为根节点，然后计算所有节点到x节点的距离的情况

• 同理可得到以y为根节点，所有节点到y节点的距离的情况

• 然后把我们得到的两个等式相减，就可以得到一个新的方程式
  
  所有说我们可以得到一个公式 ： ret[y] = ret[x] + x@y - y@x
• ret[x]：是他的父亲节点所计算的结果，以父亲节点为根节点，其他节点到他的距离之和
• x@y：父亲节点x的所有孩子节点(不包括y节点)，经过x节点到这个根节点y的距离，曾经的儿子节点y反身做了爸爸，曾经的爸爸x变成了儿子。他的大小等同于x的孩子节点的数目，因为点经过一条路径的距离都是1
• y@x：y的孩子节点经过y点到x节点的距离。因为现在y的孩子节点需要到达y点就是最终的跟节点，所以需要减去多余的长度。他的大小等同于y的孩子节点的数目

变量

• vector<int> res：表示答案，res[i]表示以i为根节点，到其他节点的总长度
• vector<int> children：表示以0为孩子节点时，其他节点各自的孩子节点数目，包括跟节点。
• vector<int> dis：dis[i]表示以0节点为最初的跟节点时，i节点的所有子节点到i的距离之和

最后的计算公式

x的除过y的孩子节点数目，就相当于总结点的数目 - y的孩子节点数量

• x@y = n - children[y]
• y@x = children[y]

res[y] = res[x] + (n - children[y]) - children[y];

第一次dfs

第一次深度优先搜索的作用就是，先计算出一个最终的结果，这里我们选择0节点，形象的来说，他是所有节点的父亲节点。
在这次搜索的途中，我们还需要找到每一个结点所对应的孩子节点的数量，因为我们第二次搜索的时候需要用到，上面的公式推导也出来了。

这里我们需要两个参数，一个是孩子节点，一个是父亲节点。因为题目的描述是一个无向图，为了避免无限递归与重复的计算，我们需要排除他的父亲节点。

• children[index] += children[child]，当前节点的孩子节点数目，就等于他的孩子节点的孩子节点的数目之和，我们就可以用后序遍历递归的计算到。
• res[index] += res[child] + children[child]，递归计算出当前节点的孩子节点到他的距离，就是他有多少个孩子，他的孩子的孩子节点到他的孩子节点的距离。。。。。。。

	void dfs1(int index,int father)
    {
        for(auto& child : map[index])
            if(child != father)
            {
                dfs1(child,index);

                children[index] += children[child];
                res[index] += res[child] + children[child];
            }
    }

第二次dfs，求得最后的答案

这次我们利用第一次求得的其他节点到0节点的距离，然后递归的计算他的孩子节点的距离，这样是一个先序遍历的过程

利用前面推导出来的公式

res[y] = res[x] + (n - children[y]) - children[y];

	//从0向下递归再推出子树，再由子树推出所有子树
    void dfs2(int n,int index,int father)
    {
        for(auto& child : map[index])
            if(child != father)
            {
                //res[index] 父亲节点延伸的距离
                //(n - children[child]) 从孩子节点到父亲节点的距离
                //children[child] child到孩子节点的距离
                res[child] = res[index] + (n - children[child]) - children[child];
                dfs2(n,child,index);
            }
    }

程序源码

class Solution {
public:
    vector<int> dis;        //i点的所有子节点到i的距离之和
    vector<int> res;
    vector<int> children;   //以i为跟的树的孩子节点数量，包括根节点
    vector<vector<int> > map;

    vector<int> sumOfDistancesInTree(int N, vector<vector<int>>& edges) {
        map = vector<vector<int>>(N,vector<int>());
        dis = vector<int>(N,0);
        res = vector<int>(N,0);
        children = vector<int>(N,1);

        for(auto& e : edges)
        {
            map[e[0]].push_back(e[1]);
            map[e[1]].push_back(e[0]);
        }

        //求以0为根节点的距离之和，再求出分别求出以i为根节点的子树节点数量和
        dfs1(0,-1);
        //cout<<children[2];
        dfs2(N,0,-1);
        return res;
    }

    void dfs1(int index,int father)
    {
        for(auto& child : map[index])
            if(child != father)
            {
                dfs1(child,index);

                children[index] += children[child];
                res[index] += res[child] + children[child];
            }
    }

    //从0向下递归再推出子树，再由子树推出所有子树
    void dfs2(int n,int index,int father)
    {
        for(auto& child : map[index])
            if(child != father)
            {
                //res[index] 父亲节点延伸的距离
                //(n - children[child]) 从孩子节点到父亲节点的距离
                //children[child] child到孩子节点的距离
                res[child] = res[index] + (n - children[child]) - children[child];
                dfs2(n,child,index);
            }
    }
};