【模板】tyvjP1520 树的直径 [2017年5月计划 清北学堂51精英班Day3]

P1520 树的直径

时间: 1000ms / 空间: 131072KiB / Java类名: Main

描述

树的直径，即这棵树中距离最远的两个结点的距离。每两个相邻的结点的距离为1，即父亲结点与儿子结点或儿子结点与父子结点之间的距离为1.有趣的是，从树 的任意一个结点a出发，走到距离最远的结点b，再从结点b出发，能够走的最远距离，就是树的直径。树中相邻两个结点的距离为1。你的任务是：给定一棵树， 求这棵树中距离最远的两个结点的距离。

输入格式

输入共n行
第一行是一个正整数n，表示这棵树的结点数
接下来的n-1行，每行三个正整数a,b,w。表示结点a和结点b之间有一条边，长度为w
数据保证一定是一棵树，不必判错。

输出格式

输出共一行
第一行仅一个数，表示这棵树的最远距离

测试样例1

输入

4

1 2 10

1 3 12

1 4 15

输出

27

备注

10%的数据满足1<=n<=5
40%的数据满足1<=n<=100
100%的数据满足1<=n<=10000 1<=a,b<=n 1<=w<=10000Tgotmacp

 

 

两种方法。

 

第一种，钦定一个根节点，以香港记者的速度跑一边BFS并找到最长链。

然后钦定最长链的终点为根，再以香港记者的速度跑一边BFS，找到的最长链就是直径。

 

第二种，钦定一个根节点，dfs或dfs，从下往上，记dp1[i]为节点i下面子树的最长链长，dp2[i]为节点i下面子树的次长链长，答案是两个加和。

 

求-1s

 

方法1：

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #define max(a,b) ((a) > (b) ? (a) : (b))
 #define min(a,b) ((a) > (b) ? (b) : (a))
 #define lowbit(a) ((a) & (-(a)))
 
 int read()
 {
     int x = ;char ch = getchar();char c = ch;
     while(ch > '' || ch < '')c = ch, ch = getchar();
     while(ch <= '' && ch >= '')x = x *  + ch - '', ch = getchar();
     if(c == '-')return -x;
     return x;
 }
 
 const int INF = 0x3f3f3f3f;
 const int MAXN =  + ;
 const int MAXE = MAXN * ;
 
 int head[MAXN];
 int cnt;
 int n;
 int tmp1,tmp2,tmp3;
 struct Edge
 {
     int u,v,w,next;
 }edge[MAXE];
 inline void insert(int a,int b,int c)
 {
     edge[++cnt] = Edge{a,b,c,head[a]};
     head[a] = cnt;
 }
 inline void init()
 {
     n = read();
     for(int i = ;i < n;i ++)
     {
         tmp1 = read();tmp2 = read();tmp3 = read();
         insert(tmp1, tmp2, tmp3);
         insert(tmp2, tmp1, tmp3);
     }
 }
 
 int queue[MAXN];
 int ans;
 bool b[MAXN];
 int lenth[MAXN];//lenth[i]表示节点i到根节点的长度
 int bfs(int root)
 {
     memset(queue, , sizeof(queue));
     memset(b, , sizeof(b));
     int head = ,tail = ;
     int a = ;
     queue[tail] = root;
     lenth[root] = ;
     b[root] = true;
 
     int mnode = root,m = ;
     do
     {
         int x = queue[head];
         head ++;
         for(int pos = ::head[x];pos;pos = edge[pos].next)
         {
             int tmp = edge[pos].v;
             if(!b[tmp])
             {
                 b[tmp] = true;
                 queue[++tail] = tmp;
                 lenth[tmp] = lenth[x] + edge[pos].w;
                 if(lenth[tmp] > m)m = lenth[tmp],mnode = tmp;
                 a ++;
             }
         }
     }while(a < n);
     ans = max(ans, m);
     return mnode;
 }
 inline void work()
 {
     bfs(bfs());
 }
 inline void shuchu()
 {
     printf("%d", ans);
 }
 int main()
 {
     init();
     work();
     shuchu();
     return ;
 }

 

方法2：

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <algorithm>
 #define max(a,b) ((a) > (b) ? (a) : (b))
 #define min(a,b) ((a) > (b) ? (b) : (a))
 #define lowbit(a) ((a) & (-(a)))
 
 int read()
 {
     int x = ;char ch = getchar();char c = ch;
     while(ch > '' || ch < '')c = ch, ch = getchar();
     while(ch <= '' && ch >= '')x = x *  + ch - '', ch = getchar();
     if(c == '-')return -x;
     return x;
 }
 
 const int INF = 0x3f3f3f3f;
 const int MAXN =  + ;
 const int MAXE = MAXN * ;
 
 int head[MAXN];
 int cnt;
 int n;
 int tmp1,tmp2,tmp3;
 struct Edge
 {
     int u,v,w,next;
 }edge[MAXE];
 inline void insert(int a,int b,int c)
 {
     edge[++cnt] = Edge{a,b,c,head[a]};
     head[a] = cnt;
 }
 inline void init()
 {
     n = read();
     for(int i = ;i < n;i ++)
     {
         tmp1 = read();tmp2 = read();tmp3 = read();
         insert(tmp1, tmp2, tmp3);
         insert(tmp2, tmp1, tmp3);
     }
 }
 
 int queue[MAXN];
 int ans;
 bool b[MAXN];
 int dp1[MAXN];//最长路
 int dp2[MAXN];//次长路
 int lenth[MAXN];//lenth[i]表示节点i到根节点的长度
 void bfs(int root)
 {
     int head = ,tail = ;
     int a = ;
     queue[tail] = root;
     lenth[root] = ;
     b[root] = true;
 
     int mnode = root,m = ;
     do
     {
         int x = queue[head];
         head ++;
         for(int pos = ::head[x];pos;pos = edge[pos].next)
         {
             int tmp = edge[pos].v;
             if(!b[tmp])
             {
                 b[tmp] = true;
                 queue[++tail] = tmp;
                 a ++;
             }
         }
     }while(a < n);
     for(int i = tail;i >= ;i --)
     {
         int x = queue[i];
         if(!::head[i])
         {
             b[i] = false;
         }
         else
         {
             int m1 = ,m2 = ;
             for(int pos = ::head[x];pos;pos = edge[pos].next)
             {
                 int tmp = edge[pos].v;
                 if(!b[tmp])
                 {
                     if(m1 < dp1[tmp] + edge[pos].w)
                     {
                         m2 = m1;
                         m1 = dp1[tmp] + edge[pos].w;
                     }
                     else if(m2 < dp1[tmp] + edge[pos].w)
                     {
                         m2 = dp1[tmp] + edge[pos].w;
                     }
                 }
             }
             dp1[x] = m1;dp2[x] = m2;
         }
         b[x] = false;
         ans = max(ans, dp1[x] + dp2[x]);
     }
 }
 inline void work()
 {
     bfs();
 }
 inline void shuchu()
 {
     printf("%d", ans);
 }
 int main()
 {
     init();
     work();
     shuchu();
     return ;
 }