求树的直径的几种方法以及求树上所有点的最远距离

一、dp（由于定义不同，有两种写法,其实dp太灵活了说有几种写法都不奇怪）

　　一种是记录以每个节点(u)为根，到其子树的最远叶节点的最大距离(dp[u][1])和次大距离(dp[u][0]); 这样以该节点为根的子树的直径即为dp[u][0]+dp[u][1], 对于每个节点取max即为全树的直径；

void dfs(int u, int fa){
　　for(int i = 0; i < G[u].size(); i++){
        int v = G[u][i].to, w = G[u][i].w;
        if (v == fa) continue;
        dfs(v, u);
        if (dp[u][1] < dp[v][1]+w){//维护最大和次大值
            dp[u][0] = dp[u][1];
            dp[u][1] = dp[v][1]+w;
        }
        else if (dp[u][0] < dp[v][1]+w)
            dp[u][0] = dp[v][1]+w;
    }
    ans = max(ans, dp[u][1]+dp[u][0]);
}

　　

　　另一种是只记录最大距离，对于节点u，设dp[u]为以u为根的子树的直径，则dp[u]=max(dp[u], dp[u_son]+dist(u,u_son) ); 依旧对每个节点取max即为全树的直径；

void dfs(int u, int fa) {
    for(int i = 0; i < G[u].size(); i++){
        int v = G[u][i].to, w = G[u][i].w;
        if (v == fa) continue;
        dfs(v, u);
        ans = max(ans, dp[u] + dp[v] + w);
        dp[u] = max(dp[u], dp[v] + w);
　　}
}

 

二、两次dfs

　　我们直接借助hdu2196这道题看看dfs如何求直径以及树上所有点到树上最远点的距离。随便取一个点做dfs，找到以这个点为根的树的最远的叶子节点，之后再以此叶子节点为根做dfs，找到距他最远的节点及距离，这个距离即为树的直径。证明略，可用反证法。

　　下面说一下这道题中这三次dfs的作用。

　　第一次：以任意节点为根，根本目的是找到直径的一个端点a。在这个过程中记录了这个起点到各个节点的距离，不过不影响。如果这个节点就是直径的端点，那么很好，如果不是，我们也会在后面更新。

　　第二次：以第一次找到的这个端点a为根，再做一次dfs，找到另一个端点b，同时更新所有节点到a的距离。（如果第一次中任意选择的那个节点是一个端点的话，两次dfs就可以结束了，但我们不能保证次次碰巧）

　　第三次dfs以b为根，更新所有节点到b的距离。由于树上某个节点可以达到的最远距离一定是它到直径两个端点的距离的较大值，故算法结束。

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const int inf=0x3f3f3f3f;
const int maxn=1e4+50;
struct edge{
    int to,w;
    edge(int too,int ww):to(too),w(ww){}
};
vector<edge>G[maxn];
int dp[maxn],maxl,s;

void dfs(int u,int f,int len){//len:起点到u的距离
    if(maxl<len){
        s=u;
        maxl=len;
    }
    for(int i=0;i<G[u].size();i++){
        int to=G[u][i].to, w=G[u][i].w;
        if(f==to) continue;
        dfs(to,u,len+w);
        dp[to]=max(dp[to],len+w);
    }
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int n;
    while(cin>>n){
        memset(dp,0,sizeof(dp));
        for(int i=0;i<=n;i++) G[i].clear();
        for(int i=2,to,w;i<=n;i++){
            cin>>to>>w;
            G[i].push_back(edge(to,w));
            G[to].push_back(edge(i,w));
        }
        s=0; maxl=0;
        dfs(1,0,0);
        dfs(s,0,0);
        dfs(s,0,0);
        for(int i=1;i<=n;i++) cout<<dp[i]<<endl;
    }
    return 0;
}

 

　　另外这题有一种dp的写法，与上文所说的第一种dp有点像，有很多前辈的blog说的很详细了，就不赘述了。

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const int inf=0x3f3f3f3f;
const int maxn=1e4+50;
struct Edge{
    int to,w;
    Edge(int too,int ww){to=too,w=ww;}
};
vector<Edge>G[maxn];
int dp[3][maxn],id[maxn];
//id[u]: u在u的子树中得到最大距离时，所经过的第一个孩子结点
//dp[u][0]: u在u的所有子树中获得的最长距离
//dp[u][1]: u在u的所有子树中获得的次长距离
//dp[u][2]: u通过父亲获得的最长距离
void dfs1(int u,int f){
    for(int i=0;i<G[u].size();i++){//get最长
        int to=G[u][i].to,w=G[u][i].w;
        if(to==f) continue;
        dfs1(to,u);
        if(dp[0][u]<dp[0][to]+w){
            dp[0][u]=dp[0][to]+w;
            id[u]=to;
        }
    }
    for(int i=0;i<G[u].size();i++){//get次长
        int to=G[u][i].to,w=G[u][i].w;
        if(to==f||id[u]==to) continue;
        dp[1][u]=max(dp[1][u],dp[0][to]+w);
    }
}
void dfs2(int u,int f){
    for(int i=0;i<G[u].size();i++){
        int to=G[u][i].to,w=G[u][i].w;
        if(to==f) continue;
        if(to==id[u])
            dp[2][to]=max(dp[2][u],dp[1][u])+w;
        else
            dp[2][to]=max(dp[2][u],dp[0][u])+w;

        dfs2(to,u);
    }
}

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    int n;
    while(cin>>n){
        memset(dp,0,sizeof(dp));
        for(int i=0;i<=n;i++) G[i].clear();
        for(int i=2,to,w;i<=n;i++){
            cin>>to>>w;
            G[i].push_back(Edge(to,w));
            G[to].push_back(Edge(i,w));
        }
        dfs1(1,0);
        dfs2(1,0);
        for(int i=1;i<=n;i++)
            cout<<max(dp[0][i],dp[2][i])<<endl;
    }
    return 0;
}