codeforces 466C Civilization 并查集+dfs

    很容易想到并查集，合并操作的时候在每部分找到一个点使这个点在这棵树上到其他点的最长路径最短，然后将这两个点连线，求一下新的链的长度取最大值就可以了。

    设每部分最长路径为 s，到其他点最长路径最短的点的最长路径L为s / 2 (向上取整)

    证明：

             1.到其他点最长路径为 s / 2 的点一定存在

                    考虑最长链上的中点m，则m到链较长那边的端点a的路径长为 s/2，假设这条路径不是到m的最长路径，最长路径链接到的点为a1，那么a1->m->b （b为最长链另一个端点）的长度一定大于 a->m->b的长度，与a->m->b为最长链矛盾，因此这条路径一定是到m的最长路径，因此一定存在一个点到其他点最长路径为 s / 2

             2.不存在到其他点最长路径小于 s/2 的点

                       对于树上任意一点k ,由于树的连通性 ，k一定通过 a->m->b上某个点m1与a和b连通，则 k到a的路径长度s1=|k->m1|+|m1->a|,k到b的路径为 s2=|k->m1|+|m1->b| 不妨设  s1>=s2 ,则 |m1->a|>=|m1->b|>= s / 2

                       即 s1 >= |m1->a| >= s / 2

            由1可知 L <= s / 2

            由2可知 L >= s / 2

            因此 L == s/2

     证明完毕

     然后一开始用dfs求一下最长链就好  

     注意dfs要从并查集的根的地方开始     

     又wa了N次，我真蠢= =

    

#pragma warning(disable:4996)
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn = 300005;
int f[maxn],s[maxn],n,m,q;
int root(int x) {
	if (f[x] == -1) return x;
	return f[x] = root(f[x]);
}
void merge(int x, int y) {
	x = root(x);
	y = root(y);
	if (x != y) {
		s[x] = max((s[x] + 1) / 2 + (s[y] + 1) / 2 + 1, s[x]);
		s[x] = max(s[x], s[y]);
		f[y] = x;
	}
}
vector<int> G[maxn];
bool v[maxn];
int dfs(int x) {
	v[x] = 1;
	int a = 0, son, t;
	for (int i = 0;i < G[x].size();i++) if (!v[G[x][i]]) {
		son = G[x][i];
		t=dfs(son);
		s[x] = max(s[x], s[son]);
		s[x] = max(t + a, s[x]);
		a = max(a, t);
	}
	return a + 1;
}
int main() {
	memset(f, -1, sizeof(f));
	cin >> n >> m >> q;
	int a, b;
	for (int i = 0;i < m;i++) {
		scanf("%d%d", &a, &b);
		G[a].push_back(b);
		G[b].push_back(a);
		merge(a, b);
	}
	for (int i = 1;i <= n;i++) if(root(i)==i) dfs(i);
	while (q--) {
		int md, x, y;
		scanf("%d", &md);
		if (md == 1) {
			scanf("%d", &x);
			printf("%d\n", s[root(x)]);
		}
		else {
			scanf("%d%d", &x, &y);
			merge(x, y);
		}
	}
	return 0;
}