lightoj-1094-Farthest Nodes in a Tree【树的直径模板】

1094 - Farthest Nodes in a Tree

PDF (English)

Statistics

Forum

Time Limit: 2 second(s)

Memory Limit: 32 MB

Given a tree (a connected graph with no cycles), you have to find the farthest nodes in the tree. The edges of the tree are weighted and undirected. That means you have to find two nodes in the tree whose distance is maximum amongst all nodes.

Input

Input starts with an integer T (≤ 10), denoting the number of test cases.

Each case starts with an integer n (2 ≤ n ≤ 30000) denoting the total number of nodes in the tree. The nodes are numbered from 0 to n-1. Each of the next n-1 lines will contain three integers u v w (0 ≤ u, v < n, u ≠ v, 1 ≤ w ≤ 10000) denoting that node u and v are connected by an edge whose weight is w. You can assume that the input will form a valid tree.

Output

For each case, print the case number and the maximum distance.

Sample Input	Output for Sample Input
2 4 0 1 20 1 2 30 2 3 50 5 0 2 20 2 1 10 0 3 29 0 4 50	Case 1: 100 Case 2: 80

Notes

Dataset is huge, use faster i/o methods.

树的直径是指树的最长简单路。

求法: 两遍BFS :先任选一个起点BFS找到最长路的终点，再从终点进行BFS，则第二次BFS找到的最长路即为树的直径；从任意一点u出发搜到的最远的点一定是s、t中的一点，然后在从这个最远点开始搜，就可以搜到另一个最长路的端点，即用两遍广搜就可以找出树的最长路；

原理: 设起点为u,第一次BFS找到的终点v一定是树的直径的一个端点

证明: 1) 如果u 是直径上的点，则v显然是直径的终点(因为如果v不是的话，则必定存在另一个点w使得u到w的距离更长，则于BFS找到了v矛盾)
        2) 如果u不是直径上的点，则u到v必然于树的直径相交(反证),那么交点到v 必然就是直径的后半段了
            所以v一定是直径的一个端点，所以从v进行BFS得到的一定是直径长度

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int MAXN = 30000 + 10;
struct Edge
{
    int from, to, val, next;
};
Edge edge[MAXN * 2];
int head[MAXN];//每个节点的头“指针”
int edgenum;//总边数
void init()
{
    memset(head, -1, sizeof(head));
    edgenum = 0;
}
void addEdge(int u, int v, int w)
{
    edge[edgenum].from = u;
    edge[edgenum].to = v;
    edge[edgenum].val = w;
    edge[edgenum].next = head[u];// u 节点的头"指针 "
    head[u] = edgenum++;
}

int ans;//记录最后结果
int Tnode;//记录S-T的端点
int dist[MAXN];//以该节点结尾的最长路
bool vis[MAXN];//标记节点是否被访问过
int n;
void BFS(int s)
{
    memset(dist, 0, sizeof(dist));
    memset(vis, false, sizeof(vis));
    queue<int> Q;
    Q.push(s);
    vis[s] = true; dist[s] = 0; ans = 0;
    while(!Q.empty())
    {
        int u=Q.front(); Q.pop();
        for(int i=head[u]; i!= -1; i=edge[i].next)
        {
            int v = edge[i].to;
            if(!vis[v])
            {
                if(dist[v]<dist[u]+edge[i].val)
                {
                    dist[v]=dist[u]+edge[i].val;
                }
                vis[v] = true;
                Q.push(v);
            }
        }
    }
    for(int i = 0; i < n; i++)
    {
        if(ans < dist[i])
        {
            ans = dist[i];
            Tnode = i;   // 记录端点 
        }
    }
}
int main()
{
    int t,test=0;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        int a,b,c;
        init();
        for(int i=1;i<n;i++)
        {
            scanf("%d %d %d",&a,&b,&c);
            addEdge(a,b,c);
			addEdge(b,a,c);
			// BES(0);	BFS(Tnode) 若这两句放在这，结果正确，但会超时 
        }
        BFS(0); BFS(Tnode);  
        printf("Case %d: %d\n",++test,ans);
    }
    return 0;
}