Codeforces Round 650E Clockwork Bomb（并查集）

题意：有两棵树，现在可以将第一棵树的边去除，然后在两个节点之间连一条新边使得第一棵树变成第二棵树，但是这种操作有一个限制条件，就是任何时刻，图中不能出现环，问操作数最少的步骤。

思路：首先可以明确一点，就是一定存在某种操作序列，使得第一棵树变成第二棵树。考虑两棵树之间相同的边，可以把这些边包含的点缩成一个点考虑，要在这两个缩点后的图上进行操作，只需要每次从树的叶子节点开始改边就能保证满足题目中没有环的条件。

我们称这缩点后的点为大点，可以发现第一棵树除了根大点外每个大点中深度最低的那个小点与父节点之间的边是要被改变的，而他们要改成的边是第二棵树中这个大点中深度最低的点与父节点之间的边，所以我们考虑用并查集来做，每个大点即一个并查集，并查集的根为第二棵树中要改变的点，然后在第一棵树中dfs一次，每次如果遇见不在第二棵树中的边，那么查询当前节点所在并查集中的根，将第一棵树中这个节点和父节点之间的边改成他所在并查集的根与它在第二棵树中父节点之间的边。注意dfs的时候先处理子节点再处理当前节点，因为这样可以保证先从叶子节点开始处理，不会在操作过程中出现环。

[cpp]  view plain  copy

1. #include<bits/stdc++.h>  
2. #define eps 1e-6  
3. #define LL long long  
4. #define pii pair<int, int>  
5. #define pb push_back  
6. #define mp make_pair  
7. //#pragma comment(linker, "/STACK:1024000000,1024000000")  
8. using namespace std;  
9.   
10. const int MAXN = 5000100;  
11. //const int INF = 0x3f3f3f3f;  
12. struct Ans {  
13.     int a, b, c, d;  
14.     Ans(int a, int b, int c, int d) : a(a), b(b), c(c), d(d) {}  
15. };  
16. int n;  
17. vector<Ans> ans;  
18. vector<int> G[2][MAXN];  
19. int fa[2][MAXN];  
20. int pa[MAXN];  
21.   
22. int Find(int x)   
23. {  
24.     return x == pa[x] ? x : Find(pa[x]);  
25. }  
26.   
27.   
28. void dfs(int id, int cur, int p) {  
29.     for (int i = 0; i < G[id][cur].size(); i++) {  
30.         int u = G[id][cur][i];  
31.         if (u == p) continue;  
32.         fa[id][u] = cur;  
33.         dfs(id, u, cur);  
34.     }  
35. }  
36.   
37.   
38. void dfs2(int cur, int p) {  
39.     for (int i = 0; i < G[0][cur].size(); i++) {  
40.         int u = G[0][cur][i];  
41.         if (u == p) continue;  
42.         dfs2(u, cur);  
43.         if (cur != fa[1][u] && u != fa[1][cur]) {  
44.             ans.pb(Ans(u, cur, Find(u), fa[1][Find(u)]));  
45.         }  
46.     }  
47. }  
48. int main()  
49. {  
50.     //freopen("input.txt", "r", stdin);  
51.     scanf("%d", &n);  
52.     for (int i = 1; i < n; i++) {  
53.         int u, v;  
54.         scanf("%d%d", &u, &v);  
55.         G[0][u].pb(v);  
56.         G[0][v].pb(u);  
57.     }  
58.     for (int i = 1; i < n; i++) {  
59.         int u, v;  
60.         scanf("%d%d", &u, &v);  
61.         G[1][u].pb(v);  
62.         G[1][v].pb(u);  
63.     }  
64.     dfs(0, 1, 0);  
65.     dfs(1, 1, 0);  
66.     for (int i = 2; i <= n; i++) {  
67.         int u = fa[1][i];  
68.         if (u == fa[0][i] || i == fa[0][u])   
69.             pa[i] = u;  
70.         else  
71.             pa[i] = i;  
72.     }  
73.     dfs2(1, 0);  
74.     cout << ans.size() << endl;  
75.     for (int i = 0; i < ans.size(); i++)   
76.         printf("%d %d %d %d\n", ans[i].a, ans[i].b, ans[i].c, ans[i].d);  
77.     return 0;  
78. }