SDOI2013「直径」

题目

Description
小 Q 最近学习了一些图论知识。根据课本，有如下定义。
树：无回路且连通的无向图，每条边都有正整数的权值来表示其长度。如果一棵树有 N 个节点，可以证明其有且仅有 N-1 条边。
路径：一棵树上，任意两个节点之间最多有一条简单路径。我们用 dis(a,b)表示点 a 和点 b 的路径上各边长度之和。称 dis(a,b)为 a、b 两个节点间的距离。
直径：一棵树上，最长的路径为树的直径。树的直径可能不是唯一的。
现在小 Q 想知道，对于给定的一棵树，其直径的长度是多少，以及有多少条边满足所有的直径都经过该边

Input
第一行包含一个整数 N，表示节点数。
接下来 N-1 行，每行三个整数 a, b, c，表示点 a 和点 b 之间有一条长度为 c的无向边。

Output
共两行。第一行一个整数，表示直径的长度。第二行一个整数，表示被所有直径经过的边的数量。

Sample Input

6
3 1 1000
1 4 10
4 2 100
4 5 50
4 6 100

Sample Output

1110
2

Data Constraint
对于 20%的测试数据：N≤100
对于 40%的测试数据：N≤1000
对于 70%的测试数据：N≤100000
对于 100%的测试数据：2≤N≤200000，所有点的编号都在 1…N 的范围内，边的权值≤10^9。
对于每个测试点，若输出文件的第一行与标准输出相同，则得到该测试点20%的分数，若输出文件的第二行与标准输出相同，则得到该测试点 80%的分数，两项可累加。
本题使用自定义校验器，为防止自定义校验器出错，即使你无法正确得出某一问的答案，也应在相应的位置随便输出一个数字。

Hint
直径共有两条，3 到 2 的路径和 3 到 6 的路径。这两条直径都经过边(3, 1)和边(1, 4)。

思路

显然需分两步解决，第一步先求出树的直径，详见【树的路径笔记】。

作图分析：

需保证的是 l 的右边不会再出现一棵以直径上的点 i 为根的子树满足到i的最大距离等于 i 到 A 的最大距离（如果相等，那么那一条直径不会经过当前的这条边）。r 同理。
求出直径后，枚举 l,r 。l~r 的边数即为所求。

$\text{Accepted Code:}$

#include <bits/stdc++.h>
#pragma GCC diagnostic error "-std=gnu++11"
#define reg register
using namespace std;

typedef long long ll;

namespace fast_IO {
	template <typename conv> inline void read(conv &x) {
		char ch=getchar(); int flag=1; x=0;
		while (!isdigit(ch)) {if (ch=='-') flag=-flag; ch=getchar();}
		while (isdigit(ch)) {x=(x<<1)+(x<<3)+ch-48; ch=getchar();}
		x*=flag;
	}
	template <typename conv , typename ... Args> inline void read(conv &first , Args & ... args) {
		read(first);
		read(args...);
	}
	
	template <typename conv> inline void write(conv x) {
		if (x<0) {putchar('-'); x=-x;}
		if (x>9) {write(x/10);}
		putchar(x%10+48);
	}
	template <typename conv , typename ... Args> inline void write(conv first , Args ... args) {
		write(first);
		write(args...);
	}
}
using namespace fast_IO;

const int maxn=200005;
ll dis[maxn] , Max (-0x7FFFFFFF) , s , t;
ll n , m , cnt (0) , head[maxn] , vis[maxn];
ll dep[maxn] , fa[maxn] , l , r , ans , son[maxn];

struct Edge {
	int to , next;
	ll data;
} edge[maxn<<1];
void add(int u , int v , ll val) {
	edge[++cnt]=(Edge){v , head[u] , val};
	head[u]=cnt;
}

void dfs(int x , int father) {
	for (reg int i=head[x]; i; i=edge[i].next) {
		int u=edge[i].to;
		
		if (u==father) continue;
		
		fa[u]=x;
		dis[u]=dis[x]+edge[i].data;
		
		dfs(u , x);
	}
}

void dfs2(int u , int father) {
	ll maxn=0;
	
	dep[u]=0;
	for (reg int i=head[u]; i; i=edge[i].next) {
		int v=edge[i].to;
		
		if (v==fa[u] || vis[v]==1) continue;
		
		dfs2 (v , u);
		maxn=max(maxn , dep[v]+edge[i].data);
	}
	
	dep[u]=maxn;	
}

int main () {
	read(n);
	for (reg int i=1; i<n; i++) {
		ll x , y , z;
		read(x , y , z);
		add(x , y , z); add(y , x , z);
	}
	
	dfs(1 , 0);
	
	for (reg int i=1; i<=n; i++) {
		if (dis[i]>Max) {Max=dis[i]; s=i;}
		dis[i]=0;
	}
	
	dfs(s , 0);
	
	Max=-0x7FFFFFFF;
	for (reg int i=1; i<=n; i++) {
		if (dis[i]>Max) {Max=dis[i]; t=i;}
	}
	write(Max); putchar('\n');
	
	l=t; r=s;
	int now=t;
	while (now!=s) {
		vis[now]=1;
		son[fa[now]]=now;
		now=fa[now];
	}
	
	now=t;
	while (now!=s) {
		dep[now]=0;
		dfs2(now , 0);
		if (dep[now]==Max-dis[now]) l=now;
		now=fa[now];
	}
	
	now=s;
	while (now) {
		dfs2(now , 0);
		if (dep[now]==dis[now]) r=now;
		now=son[now];
	}
	
	while (l>0 && l!=r) {
		l=fa[l];
		ans++;
	}
	write(ans);
	
	return 0;
}