树的最长路径

方法一：两次bfs

先从任意一点P出发，找离它最远的点x，再从点x出发，找离它最远的点y，x到y的距离就是树的直径

方法二：树形dp

从某个点出发，求其最远距离与次远距离，两者之和最大的为树的直径

例题：树的最长路径

给定一棵树，树中包含 n 个结点（编号1~n）和 n−1 条无向边，每条边都有一个权值。

现在请你找到树中的一条最长路径。

换句话说，要找到一条路径，使得路径两端的点的距离最远。

注意：路径中可以只包含一个点。

输入格式

第一行包含整数 n。

接下来 n−1 行，每行包含三个整数 ai,bi,ci，表示点 ai 和 bi 之间存在一条权值为 ci 的边。

输出格式

输出一个整数，表示树的最长路径的长度。

数据范围

1≤n≤10000,
1≤ai,bi≤n,
−10^5≤ci≤10^5

输入样例：

6
5 1 6
1 4 5
6 3 9
2 6 8
6 1 7

输出样例：

22

代码1：

#include <algorithm>
#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int N = 10000+10;
int visited[N],d[N],head[N],nexts[N*2],ver[N*2],edge[N*2];
int n,maxv,tot;
void add(int x,int y,int z){
    ver[++tot]=y,edge[tot]=z;
    nexts[tot]=head[x],head[x]=tot;
}
int bfs(int u){
    queue<int>Q;
    Q.push(u);
    memset(visited,0,sizeof(visited));
    visited[u]=1;
    memset(d,0,sizeof(d));
    int v=u;
    while(!Q.empty()){
        int x=Q.front();
        Q.pop();
        for(int i=head[x];i;i=nexts[i]){
            int y=ver[i],z=edge[i];
            if(!visited[y]){
                visited[y]=1;
                d[y]=d[x]+z;
                Q.push(y);
                if(d[y]>maxv){
                    maxv=d[y];
                    v=y;
                }
            }
        }
    }
    return v;
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
        add(y,x,z);
    }
    int x=bfs(1);
    bfs(x);
    printf("%d",maxv);
    return 0;
}

代码2：

#include <algorithm>
#include <iostream>
#include <cstring>
using namespace std;
const int N = 10000+10;
int head[N],nexts[N*2],ver[N*2],edge[N*2];
int tot,ans;
void add(int x,int y,int z){
    ver[++tot]=y,edge[tot]=z;
    nexts[tot]=head[x],head[x]=tot;
}
int dp(int x,int father){
    int d1=0,d2=0;//最远距离与次远距离
    for(int i=head[x];i;i=nexts[i]){
        int y=ver[i],z=edge[i];
        if(y==father) continue;
        int temp=dp(y,x)+z;

        if(temp>d1){
            d2=d1;
            d1=temp;
        }
        else if(temp>d2){
            d2=temp;
        }
    }
    ans=max(ans,d1+d2);
    return d1;
}
int main(){
    int n;
    scanf("%d",&n);
    for(int i=1;i<n;i++){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z),add(y,x,z);
    }
    dp(1,0);
    printf("%d",ans);
    return 0;
}

代码3：

#include <iostream>
#include <algorithm>
using namespace std;
const int N = 10000+10;
int head[N],nexts[N*2],ver[N*2],edge[N*2];
int tot;
int down1[N],down2[N],up[N],p[N];
void add(int x,int y,int z){
    ver[++tot]=y,edge[tot]=z;
    nexts[tot]=head[x],head[x]=tot;
}
//子节点更新父节点
int dfs_down(int x,int father){
    down1[x]=down2[x]=0;
    for(int i=head[x];i;i=nexts[i]){
        int y=ver[i],z=edge[i];
        if(y==father) continue;
        int d=dfs_down(y,x)+z;
        
        if(d>down1[x]){
            down2[x]=down1[x],down1[x]=d;
            p[x]=y;
        }
        else if(d>down2[x]) down2[x]=d;
    }
    return down1[x];
}
//父节点更新子节点
void dfs_up(int x,int father){
    for(int i=head[x];i;i=nexts[i]){
        int y=ver[i],z=edge[i];
        if(y==father) continue;
        
        if(p[x]==y) up[y]=max(up[x],down2[x])+z;
        else up[y]=max(up[x],down1[x])+z;
        
        dfs_up(y,x);
    }
}
int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n-1;i++){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);
        add(y,x,z);
    }
    dfs_down(1,0);
    dfs_up(1,0);
    int res=0;
    for(int i=1;i<=n;i++){
        res=max(res,down1[i]+up[i]);
    }
    printf("%d",res);
    return 0;
}