2023-07-16力扣每日一题

链接：

834. 树中距离之和

题意：

给定一个树，有n个节点，需要得到每个节点与其他节点的距离和

解：

还以为是弗洛伊德，一看范围3E4直接晕倒

想了四个小时，实在是想不出来了，看了一下评论里的转移公式

设DP[i]为节点 i 与其他节点的距离和，DP[F]是节点 i 的父节点与其他节点的距离和

那么从F移动到 i 会有怎么样的距离变化，首先离F的距离+1，但是离 i 的距离-1，这两者抵消

然后离 i 的所有子节点（这里指的不是直接子节点）距离均-1，离除了F、i和 i 的所有子节点距离均+1

由此可得转移公式DP[i]=DP[F] - child_num + (n-child_num-2)

那么解题时只需要确定DP[root]和每个节点的子节点数量

代码解释：

我这个写法太繁琐也太低效，毕竟只是一只蒟蒻，凑合着看吧

执行用时：328 ms, 在所有 C++ 提交中击败了15.71%的用户
内存消耗：117.7 MB, 在所有 C++ 提交中击败了5.00%的用户

首先我弄了两个二维容器temp和child，temp用来本来的边集变成可以通过端点查询的存储方式，以便于用BFS创建一个以0为根节点的树，然后就是建树，child存储直接节点，在BFS的过程中，使用深度变量deep*直接子节点数量child_num所有子节点的数量，用于初始化DP[root]

然后先跑一轮dfs_childNum()通过递归，将每个节点（除了roor)的子节点数量存入DP数组（临时存储）

然后使用DP()通过递归，将DP[i]通过DP[F]和临时存储在DP[i]的子节点数量，计算结果~~（应该最好用迭代DFS）~~

这个转移公式雀食很妙，大佬牛牛

实际代码：

#include<bits/stdc++.h>
using namespace std;
int dfs_childNum(int &n,vector<vector<int>>& child,vector<int>& dp,int mao,int father)//递归返回子节点总数 
{
    int child_num=child[mao].size();//子节点数量

    for(auto c:child[mao])//遍历子节点 
    {
        child_num+=dfs_childNum(n,child,dp,c,mao);
    }
    
    if(mao!=0) dp[mao]=child_num;
    return child_num;
}
void DP(int &n,vector<vector<int>>& child,vector<int>& dp,int mao,int father)//DP函数 
{
    if(mao!=0) dp[mao]=dp[father]-dp[mao]+(n-dp[mao]-2);
    for(auto c:child[mao])//遍历子节点 
    {
        DP(n,child,dp,c,mao);
    }
}
vector<int> sumOfDistancesInTree(int n, vector<vector<int>>& edges)
{
    vector<vector<int>>temp (n,vector<int>());//边转换 
    vector<vector<int>>child (n,vector<int>());//以0节点为根建树 
    vector<int>dp(n,0);//DP数组 
    for(auto edge:edges)
    {
        temp[edge[0]].push_back(edge[1]);
        temp[edge[1]].push_back(edge[0]);
    }
    vector<int>nows={0};int deep=0;//深度
    while(true)//初始化 DP数组-初始状态 child数组-建树 
    {
        deep++;//提高深度 
        vector<int>nn;
        for(auto now:nows)//广度搜索 
        {
            //cout<<"NOW"<<now<<endl;//当前搜索点NOW 
            int child_num=temp[now].size();//子节点数量 
            for(auto t:temp[now])//遍历链接 
            {
                //cout<<"T"<<t<<endl;//NOW的链接
                if(child[t].empty())//NOW的子节点
                {
                    //cout<<"emptyT"<<t<<endl;
                    child[now].push_back(t);
                    nn.push_back(t);
                }
                else child_num--;//NOW的父节点 
            }
            //更新 初始状态
            //cout<<"update"<<child_num<<" in deep"<<deep<<endl;
            dp[0]+=child_num*deep;
        }
        nows=nn;//更新 当前搜索点集 
        if(nows.empty()) break;//没有 当前搜索点 
    }
    dfs_childNum(n,child,dp,0,-1);
    /*
    动态规划 初始状态 与 状态转移
    */ 
    DP(n,child,dp,0,-1);
    return dp;
}
int main()
{
    vector<vector<int>> edges;
    int n;cin>>n;
    for(int i=1;i<n;i++)
    {
        int a,b;cin>>a>>b;
        vector<int>temp{a,b};
        edges.push_back(temp);
    }
    vector<int>ans=sumOfDistancesInTree(n,edges);
    for(auto i:ans)
    {
        cout<<i<<endl;
    }
    return 0;
}

限制：

• 1 <= n <= 3 * 104
• edges.length == n - 1
• edges[i].length == 2
• 0 <= ai, bi < n
• ai != bi
• 给定的输入保证为有效的树