给一个无向图，每次删除一些边，求它的连通分量。这道题第一眼看上去想到的就是并查集，不过并不是那么容易能想出来正解，因为如果使用一个裸的并查集必然会超时，所以说记录下来两个数组，一个数组记录的是从前往后找使任意某两个不连通的点连通的第一条边，另一个数组记录的就是从后往前找使任意两个不连通的点连通的第一条边，然后对于k次实验，每次实验都只需要扫描两个数组，从前往后找的数组只要那条边的序号小于l且使两个不连通的点连通了那就连通了，同理，从后往前找的数组大于r且使两个不连通的点连通了也就连通了，都合并完以后直接求连通分量即可。

view code
 1 #include <cstdio>
 2 #include <cstring>
 3 int p[510], ll[10010], rr[10010];
 4 int a[10010], ac;
 5 int b[10010], bc;
 6 int find(int x){
 7     return p[x] != x ? p[x] = find(p[x]) : x;
 8 }
 9 bool marge(int x, int y){
10     x = find(x); y = find(y);
11     if (x == y) return 0;
12     p[y] = x;
13     return 1;
14 }
15 int main(){
16     memset(a, 0, sizeof(a));
17     memset(b, 0, sizeof(b));
18     ac = 0, bc = 0;
19     int n, m, k;
20     scanf("%d%d", &n, &m);
21     for (int i = 1; i <= m; i++) scanf("%d%d", &ll[i], &rr[i]);
22     for (int i = 1; i <= n; i++) p[i] = i;
23     for (int i = 1; i <= m; i++)
24         if (marge(ll[i], rr[i])) a[ac++] = i;
25     for (int i = 1; i <= n; i++) p[i] = i;
26     for (int i = m; i > 0; i--)
27         if (marge(ll[i], rr[i])) b[bc++] = i;
28     scanf("%d", &k);
29     while (k--){
30         for (int i = 1; i <= n; i++) p[i] = i;
31         int z = n, l, r;
32         scanf("%d%d", &l, &r);
33         for (int i = 0; i < ac; i++)
34             if (a[i] < l)
35                 if (marge(ll[a[i]], rr[a[i]])) z -= 1;
36         for (int i = 0; i < bc; i++)
37             if (b[i] > r)
38                 if (marge(ll[b[i]], rr[b[i]])) z -= 1;
39         printf("%d\n", z);
40     }
41     return 0;
42 }
43 

并查集合并小组，这个自然是不用说的，主要的问题是怎么求第K大值。

首先，线段树每一个结点存储的是组内元素的个数区间内有多少个组，初始化的时候所有的组中都是一个元素，所以当区间左端点为1的时候，结点的值为n，然后每次合并，原有小组的空间内结点值-1，合并后的新组空间内结点值+1，线段树这么维护完了以后，询问过程中，如果右子树的值大于k，那么第k大数一定在右子树当中。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define lson l, m, rt << 1
 9 #define rson m + 1, r, rt << 1 | 1
10 const int maxn = 200010;
11 int sum[maxn << 2], n, q;
12 struct data{
13     int p, num;
14 }p[maxn];
15 void build(int l, int r, int rt){
16     if (l == 1) sum[rt] = n;
17     else sum[rt] = 0;
18     if (l == r) return;
19     int m = (l + r) >> 1;
20     build(lson);
21     build(rson);
22 }
23 void update(int x, int f, int l, int r, int rt){
24     if (!f) sum[rt] -= 1;
25     else sum[rt] += 1;
26     if (l == r) return;
27     int m = (l + r) >> 1;
28     if (x <= m) update(x, f, lson);
29     else update(x, f, rson);
30 }
31 void query(int k, int l, int r, int rt){
32     if (l == r){
33         printf("%d\n", l);
34         return;
35     }
36     int m = (l + r) >> 1;
37     if (sum[rt << 1 | 1] >= k) query(k, rson);
38     else query(k - sum[rt << 1 | 1], lson);
39 }
40 int find(int x){
41     if (p[x].p == x) return x;
42     int temp = p[x].p;
43     p[x].p = find(temp);
44     p[x].num = p[temp].num + p[x].num;
45     return p[x].p;
46 }
47 int main(){
48     while (~scanf("%d%d", &n, &q)){
49         for (int i = 0; i <= n; i++){
50             p[i].p = i; p[i].num = 1;
51         }
52         build(1, n, 1);
53         while (q--){
54             int op;
55             scanf("%d", &op);
56             if (op == 0){
57                 int x, y;
58                 scanf("%d%d", &x, &y);
59                 x = find(x);
60                 y = find(y);
61                 if (x == y) continue;
62                 update(p[x].num, 0, 1, n, 1);
63                 update(p[y].num, 0, 1, n, 1);
64                 update(p[x].num + p[y].num, 1, 1, n, 1);
65                 p[y].p = x;
66                 p[x].num += p[y].num;
67             }
68             if (op == 1){
69                 int k;
70                 scanf("%d", &k);
71                 query(k, 1, n, 1);
72             }
73         }
74     }
75     return 0;
76 }
77 

能够互相交流的放到同一个集合里面，最后有多少个集合，就需要花集合数目-1的钱，因为一个集合中只需要有一个人学会另外一个集合中的任意一个人回的任意一门语言两个集合的人就可以互相交流。

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 using namespace std;
 6 int p[110], n, m, a[110][110], num[110];
 7 int find(int x){
 8     return p[x] != x ? p[x] = find(p[x]) : x;
 9 }
10 int cmp(int a, int b){
11     return a > b;
12 }
13 int main(){
14     while (~scanf("%d%d", &n, &m)){
15         memset(a, 0, sizeof(a));
16         for (int i = 0; i <= n; i++) p[i] = i;
17         for (int i = 0; i < n; i++){
18             scanf("%d", &a[i][0]);
19             for (int j = 1; j <= a[i][0]; j++) scanf("%d", &a[i][j]);
20         }
21         for (int i = 0; i < n; i++)
22           for (int j = 0; j < n; j++)
23             if (j != i){
24                 int r1 = find(i), r2 = find(j);
25                 if (r1 == r2) continue;
26                 else
27                   for (int k = 1; k <= a[i][0]; k++)
28                     for (int l = 1; l <= a[j][0]; l++)
29                       if (a[i][k] == a[j][l]) p[r2] = r1;
30             }
31         int cnt = 0;
32         bool b = 0;
33         for (int i = 0; i < n; i++) if (a[i][0] != 0) b = 1;
34         for (int i = 0; i < n; i++) if (p[i] == i) cnt += 1;
35         int ans = cnt - 1;
36         if (!b) ans = n;
37         printf("%d\n", ans);
38     }
39     return 0;
40 

这道题，所有的物种之间有三个关系，平等，吃与被吃，那么这三个关系可以分别用0,1,2来表示，如果遇到的两个生物从来没有处理过，或者说有一个没有处理过，那么这句话一定是跟前面的所有真话没有冲突的，如果这句话也没有违背剩下的两个条件，就可以把这个物种存进来，合并到一个集合中，并且关系给好好的设定一下，由于只有三个物种，而且三个物种之间的关系非常明确，我们就可以推导出来压缩路径的时候各个元素之间的关系的换算关系，所以呢～～～推导我也没弄明白……（- -||），如果遇到的两个物种全都处理过了，那么查找的时候必然是在同一个集合中，那就看它们的关系是否冲突就行了……如果它俩是同一个物种，那么它俩和根节点的关系一定就是一样一样的，如果不是同一个物种，换算公式啦…… 

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define M 50010
 9 struct data
10 {
11     int p, r;
12 }p[M];
13 int find(int x)
14 {
15     int temp;
16     if (x == p[x].p) return x;
17     temp = p[x].p;
18     p[x].p = find(temp);
19     p[x].r = (p[x].r + p[temp].r) % 3;
20     return p[x].p;
21 }
22 int main()
23 {
24     int n, k;
25     int d, x, y;
26     int r1, r2;
27     int sum = 0;
28     cin >> n >> k;
29     for (int i = 1; i <= n; i++)
30     {
31         p[i].p = i;
32         p[i].r = 0;
33     }
34     for (int i = 0; i < k; i++)
35     {
36         scanf("%d%d%d", &d, &x, &y);
37         if (x > n || y > n)
38         {
39             sum++;
40             continue;
41         }
42         if (d == 2 && x == y)
43         {
44             sum++;
45             continue;
46         }
47         r1 = find(x); r2 = find(y);
48         if (r1 != r2)
49         {
50             p[r2].p = r1;
51             p[r2].r = (3 + (d - 1) + p[x].r - p[y].r) % 3;
52         }
53         else
54         {
55             if (d == 1 && p[x].r != p[y].r)
56             {
57                 sum++;
58                 continue;
59             }
60             if (d == 2 && ((3 - p[x].r + p[y].r) % 3 != (d - 1)))
61             {
62                 sum++;
63                 continue;
64             }
65         }
66     }
67     cout << sum << endl;
68     return 0;
69 

求最小生成树中第S大的边，结点给的是坐标（坑爹啊）

view code
 1 #include <iostream>  
 2 #include <cstdio>  
 3 #include <cstring>  
 4 #include <cstdlib>  
 5 #include <cmath>  
 6 #include <algorithm>  
 7 using namespace std;  
 8 #define N 500  
 9 struct edge  
10 {  
11     int u, v;  
12     double w;  
13 }e[250000];  
14 struct data  
15 {  
16     int x, y;  
17 }a[N];  
18 int S, P, tot, cnt, p[N];  
19 double dis(data a, data b)  
20 {  
21     int x = a.x - b.x;  
22     int y = a.y - b.y;  
23     double xx = x * x;  
24     double yy = y * y;  
25     return sqrt(xx + yy);  
26 }  
27 int find(int x)  
28 {  
29     return p[x] != x ? p[x] = find(p[x]) : x;  
30 }  
31 void add(int x, int y, double z)  
32 {  
33     tot++;  
34     e[tot].u = x;  
35     e[tot].v = y;  
36     e[tot].w = z;  
37 }  
38 double cmp(double a, double b)  
39 {  
40     return a > b;  
41 }  
42 double cmp2(edge a, edge b)  
43 {  
44     return a.w < b.w;  
45 }  
46 int main()  
47 {  
48     int r1, r2, t;  
49     double ans, w[250000];  
50     cin >> t;  
51     while (t--)  
52     {  
53         cin >> S >> P;  
54         for (int i = 0; i < P; i++) p[i] = i;  
55         tot = ans = cnt = 0;  
56         memset(e, 0, sizeof(e));  
57         memset(w, 0, sizeof(w));  
58         for (int i = 0; i < P; i++) scanf("%d%d", &a[i].x, &a[i].y);  
59         for (int i = 0; i < P; i++)  
60           for (int j = 0; j < P; j++)  
61           {  
62               if (i != j) add(i, j, dis(a[i], a[j]));  
63           }  
64         sort(e + 1, e + 1 + tot, cmp2);  
65         for (int i = 0; i < tot; i++)  
66         {  
67             r1 = find(e[i].u); r2 = find(e[i].v);  
68             if (r1 != r2)  
69             {  
70                 p[r2] = r1; w[cnt++] = e[i].w;  
71             }  
72         }  
73         sort(w, w + cnt, cmp);  
74         if (S == 0) ans = w[0];  
75         else ans = w[S - 1];  
76         printf("%.2lf\n", ans);  
77     }  
78     return 0;  
79 

又被坑了一把，求的是最小生成树的最大边的长度，无端奉献了两次WA。。

view code
 1 #include <iostream>  
 2 #include <cstdio>  
 3 #include <cstdlib>  
 4 #include <cstring>  
 5 #include <cmath>  
 6 #include <algorithm>  
 7 using namespace std;  
 8 #define N 501  
 9 #define M 250000  
10 #define max(a, b) a > b ? a : b  
11 int t, a[N][N], p[N], tot;  
12 struct edge  
13 {  
14     int u, v, w;  
15 }e[M];  
16 int find(int x)  
17 {  
18     return p[x] != x ? p[x] = find(p[x]) : x;  
19 }  
20 int cmp(edge a, edge b)  
21 {  
22     return a.w < b.w;  
23 }  
24 void add(int x, int y, int z)  
25 {  
26     tot++;  
27     e[tot].u = x; e[tot].v = y; e[tot].w = z;  
28 }  
29 int main()  
30 {  
31     int ans, r1, r2, n;  
32     cin >> t;  
33     while (t--)  
34     {  
35         cin >> n;  
36         ans = tot = 0; memset(e, 0, sizeof(e));  
37         for (int i = 0; i < n; i++) p[i] = i;  
38         for (int i = 0; i < n; i++)  
39           for (int j = 0; j < n; j++)  
40           {  
41               cin >> a[i][j];  
42               if (i != j && a[i][j] > 0) add(i, j, a[i][j]);  
43           }  
44         sort(e + 1, e + 1 + tot, cmp);  
45         for (int i = 1; i <= tot; i++)  
46         {  
47             r1 = find(e[i].u); r2 = find(e[i].v);  
48             if (r1 != r2)  
49             {  
50                 p[r2] = r1;  
51                 ans = max(ans, e[i].w);  
52             }  
53         }  
54         cout << ans << endl;  
55     }  
56     return 0;  
57 

用题意啊，输入什么的来卡人的题最没有节操了

这道题的输入非常之纠结，看了好久没看明白，后来借助着某个大神的博客的翻译（我真不认识啊），弄明白是怎么回事儿了。

输入每行的第一个字符是按照字典序给的，表示起点，然后的数字表示的是从这一点出发有多少条链接不是上面的点的道路，然后是各个道路的终点以及道路的长度，最后求的是最小生成树的边权值，我还是只会kruskal啊……

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 struct edge
 9 {
10     int u, v, w;
11 }e[900];
12 int p[30], tot;
13 void add(int x, int y, int z)
14 {
15     tot++;
16     e[tot].u = x;
17     e[tot].v = y;
18     e[tot].w = z;
19     tot++;
20     e[tot].u = y;
21     e[tot].v = x;
22     e[tot].w = z;
23 }
24 int find(int x)
25 {
26     return p[x] != x ? p[x] = find(p[x]) : x;
27 }
28 int cmp(edge a, edge b)
29 {
30     return a.w < b.w;
31 }
32 int main()
33 {
34     int n, r1, r2, ans, k, d;
35     char c, s;
36     while (scanf("%d", &n) != EOF)
37     {
38         tot = ans = 0;
39         memset(e, 0, sizeof(e));
40         if (n == 0) break;
41         for (int i = 0; i < n; i++) p[i] = i;
42         for (int i = 1; i < n; i++)
43         {
44             scanf("\n%c %d", &c, &k);
45             for (int j = 0; j < k; j++)
46             {
47                 scanf(" %c %d", &s, &d);
48                 add(c - 'A', s - 'A', d);
49             }
50         }
51         sort(e + 1, e + 1 + tot, cmp);
52         for (int i = 1; i <= tot; i++)
53         {
54             r1 = find(e[i].u); r2 = find(e[i].v);
55             if (r1 != r2)
56             {
57                 p[r2] = r1;
58                 ans += e[i].w;
59             }
60         }
61         printf("%d\n", ans);
62     }
63     return 0;
64 

裸的最小生成树，但是题意非常不好理解，就是说每一串字符相当于一个点，任意两个字符串中不容字符的个数相当于边权，这样来建图求最小生成树。还是只会用kruskal啊。。

view code
 1 #include <iostream>  
 2 #include <cstdio>  
 3 #include <cstring>  
 4 #include <cstdlib>  
 5 #include <cmath>  
 6 #include <algorithm>  
 7 using namespace std;  
 8 struct edge  
 9 {  
10     int u, v, w;  
11 }e[4000000];  
12 char data[2001][8];  
13 int p[2001];  
14 int tot;  
15 int cmp(edge a, edge b)  
16 {  
17     return a.w < b.w;  
18 }  
19 int find(int x)  
20 {  
21     return p[x] != x ? p[x] = find(p[x]) : x;  
22 }  
23 void add(int x, int y, int z)  
24 {  
25     tot++;  
26     e[tot].u = x;  
27     e[tot].v = y;  
28     e[tot].w = z;  
29 }  
30 int main()  
31 {  
32     int r1, r2, sum, n, ans;  
33     while (scanf("%d", &n) != EOF)  
34     {  
35         if (n == 0) break;  
36         tot = 0; memset(e, 0, sizeof(e)); ans = 0;  
37         for (int i = 0; i < n; i++) p[i] = i;  
38         for (int i = 0; i < n; i++) scanf("%s", data[i]);  
39         for (int i = 0; i < n; i++)  
40           for (int j = 0; j < n; j++)  
41           {  
42               sum = 0;  
43               if (i != j)  
44                 for (int k = 0; k < 8; k++)  
45                   if (data[i][k] != data[j][k]) sum++;  
46               add(i, j, sum);  
47           }  
48         sort(e + 1, e + 1 + tot, cmp);  
49         for (int i = 1; i <= tot; i++)  
50         {  
51             r1 = find(e[i].u); r2 = find(e[i].v);  
52             if (r1 != r2)  
53             {  
54                 p[r2] = r1;  
55                 ans += e[i].w;  
56             }  
57         }  
58         printf("The highest possible quality is 1/%d.\n", ans);  
59     }  
60     return 0;  
61 

裸的最小生成树求边权值，给的是邻接矩阵，但是邻接矩阵的kruskal我不会用，就转换成了边表然后使用，说实话挺蛋疼的，但是好歹A掉了。。。

并查集入门题

view code
 1 #include <iostream>  
 2 #include <cstdio>  
 3 #include <cstdlib>  
 4 #include <cstring>  
 5 #include <cmath>  
 6 #include <algorithm>  
 7 using namespace std;  
 8 #define N 5010  
 9 int p[N];  
10 int find(int x)  
11 {  
12     return p[x] != x ? p[x] = find(p[x]) : x;  
13 }  
14 int main()  
15 {  
16     int n, m, q;  
17     int x, y, r1, r2;  
18     scanf("%d%d%d", &n, &m, &q);  
19     for (int i = 1; i <= n; i++) p[i] = i;  
20     for (int i = 1; i <= m; i++)  
21     {  
22         scanf("%d%d", &x, &y);  
23         r1 = find(x); r2 = find(y);  
24         if (r1 != r2) p[r2] = r1;  
25     }  
26     for (int i = 1; i <= q; i++)  
27     {  
28         scanf("%d%d", &x, &y);  
29         r1 = find(x); r2 = find(y);  
30         if (r1 == r2) printf("Yes\n");  
31         else printf("No\n");  
32     }  
33     return 0;  
34 

这道题让我略显纠结了，因为要找哪个是裁判，我YY了好几种想法，但是最终结果都是一个混乱，不过最终找到了这个解法。。

其中有一个是裁判的话，那么这个裁判的存在一定会导致这里面的关系出现混乱，因为弱国没有裁判，那么三组人非常和谐，因为他们三组人出的东西都是一样一样的，而裁判出的东西是非常随意的，一会儿这个一会儿那个，所以如果裁判在这个组中，那么最终结果一定会出现矛盾。

看一看时间复杂度，貌似不是那么可怕，可以接受，那么就可以挨个儿的从组内排除，如果一直没有出现矛盾，那么那个人就是应该被排除的，也就是裁判。

当然，那个不可能和无法决定着实让我小蒙圈了一下，但是后来反应过来了，没有裁判是不可能的，裁判有很多个的话就是无法决定的

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define N 505
 9 #define M 2010
10 #define max(a, b) a > b ? a : b
11 struct parent
12 {
13     int p, r;
14 }p[N];
15 int find(int x)
16 {
17     int temp;
18     if (x != p[x].p)
19     {
20         temp = p[x].p;
21         p[x].p = find(temp);
22         p[x].r = (p[temp].r + p[x].r) % 3;
23     }
24     return p[x].p;
25 }
26 int main()
27 {
28     int x[M], y[M], d[M];
29     int r1, r2;
30     int n, m;
31     bool ju;
32     int cnt, ansi, ansn, t;
33     char c;
34     while (scanf("%d%d", &n, &m) != EOF)
35     {
36         for (int i = 0; i < m; i++)
37         {
38             scanf("%d%c%d", &x[i], &c, &y[i]);
39             if (c == '=') d[i] = 0;
40             if (c == '>') d[i] = 1;
41             if (c == '<') d[i] = 2;
42         }
43         cnt = ansi = ansn = 0;
44         for (int i = 0; i < n; i++)
45         {
46             ju = 1;
47             for (int j = 0; j < n; j++)
48             {
49                 p[j].p = j; p[j].r = 0;
50             }
51             for (int j = 0; j < m; j++)
52             {
53                 if (x[j] == i || y[j] == i) continue;
54                 r1 = find(x[j]); r2 = find(y[j]);
55                 if (r1 != r2)
56                 {
57                     p[r2].p = r1;
58                     p[r2].r = (6 + p[x[j]].r - p[y[j]].r - d[j]) % 3;
59                 }
60                 else if ((p[x[j]].r - p[y[j]].r + 3) % 3 != d[j])
61                 {
62                     ju = 0;
63                     ansi = max(ansi, j + 1);
64                     break;
65                 }
66             }
67             if (ju)
68             {
69                 cnt++;
70                 ansn = i;
71                 if (cnt > 1) break;
72             }
73         }
74         if (cnt == 0) printf("Impossible\n");
75         if (cnt == 1) printf("Player %d can be determined to be the judge after %d lines\n", ansn, ansi);
76         if (cnt > 1) printf("Can not determine\n");
77     }
78     return 0;
79 

题目和POJ那几道题类似，都是并查集向量偏移来做，关系也比较好推导，p[x].r表示的是x与根节点的差，下面就是推导关系了

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define N 200010
 9 struct data
10 {
11     int p, r;
12 }p[N];
13 int a[N];
14 int find(int x)
15 {
16     int temp;
17     if (p[x].p != x)
18     {
19         temp = p[x].p;
20         p[x].p = find(temp);
21         p[x].r = p[x].r + p[temp].r;
22     }
23     return p[x].p;
24 }
25 int main()
26 {
27     int n, m;
28     int x, y, s;
29     int r1, r2;
30     int ans;
31     while (scanf("%d%d", &n, &m) != EOF)
32     {
33         memset(a, -1, sizeof(a));
34         ans = 0;
35         for (int i = 1; i <= n; i++)
36         {
37             p[i].p = i;
38             p[i].r = 0;
39         }
40         for (int i = 0; i < m; i++)
41         {
42             scanf("%d%d%d", &x, &y, &s);
43             x--;
44             r1 = find(x); r2 = find(y);
45             if (r1 != r2)
46             {
47                 p[r2].p = r1;
48                 p[r2].r = p[x].r + s - p[y].r;
49             }
50             else
51             {
52                 if (p[y].r - p[x].r != s) ans++;
53             }
54         }
55         printf("%d\n", ans);
56     }
57     return 0;
58 

大意就是给一些点的指向关系，最后问能否组成一棵树。

用并查集写了，每次给的两个点不在相同集合，就合并，合并一次相当于多增加了一条边，所以在合并的时候记录一下边数，如果合并过程中出现了环，那么说明不是一棵树，如果之后点数与边数加一不相等，也不是一棵树，所以需要记录点的个数，我用的是string类，每次find一下，最后求string的长度，有点儿偷懒屌丝了，不过发觉确实是方便，但是我的代码因此奇葩了不少……

一定要注意，空树也是一棵树，需要加条件判断，我就是因为少了一个条件，WA了好几次……

附代码：

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define N 100000
 9 int p[N], n, r;
10 string num;
11 int find(int x)
12 {
13     return p[x] != x ? p[x] = find(p[x]) : x;
14 }
15 void init()
16 {
17     for (int i = 1; i <    N; i++)
18       p[i] = i;
19     n = 0; r = 0;
20 }
21 int main()
22 {
23     int t = 1;
24     int x, y;
25     int r1, r2;
26     bool j = 1;
27     init();
28     while (scanf("%d%d", &x, &y) != EOF)
29     {
30         if (x < 0 || y < 0) break;
31         if (x == 0 && y == 0)
32         {
33             int l = num.size();
34             if (l != r + 1 && l > 0) j = 0;
35             if (j) printf("Case %d is a tree.\n", t++);
36             else printf("Case %d is not a tree.\n", t++);
37             init();
38             num.clear();
39             j = 1;
40             continue;
41         }
42         if (x == y) j = 0;
43         if (num.find(x - '0') == -1) num.push_back(x - '0');
44         if (num.find(y - '0') == -1) num.push_back(y - '0');
45         r1 = find(x); r2 = find(y);
46         if (r1 == r2) j = 0;
47         if (r1 != r2)
48         {
49             p[r2] = r1;
50             r++;
51         }
52     }
53     return 0;
54 }
55 

裸的最小生成树，捉急的是他给的是每个点的x，y坐标，所以需要重新建边，因为某些问题，CE好几次，WA好几次，语言要选择C++，否则会WA，而且你还不知道怎么WA的

view code
 1 #include <iostream>  
 2 #include <cstdio>  
 3 #include <cstdlib>  
 4 #include <cstring>  
 5 #include <cmath>  
 6 #include <algorithm>  
 7 using namespace std;  
 8 #define N 101  
 9 #define M 10000  
10 int tot;  
11 struct nn  
12 {  
13     double x, y;  
14 }a[N];  
15 struct ee  
16 {  
17     int u, v;  
18     double w;  
19 }e[M];  
20 int p[N];  
21 double dis(int x, int y)  
22 {  
23     double xx = a[x].x - a[y].x;  
24     double yy = a[x].y - a[y].y;  
25     double d = xx * xx + yy * yy;  
26     return sqrt(d);  
27 }  
28 void init(int x, int y)  
29 {  
30     tot++;  
31     e[tot].u = x;  
32     e[tot].v = y;  
33     e[tot].w = dis(x, y);  
34 }  
35 int find(int x)  
36 {  
37     return p[x] != x ? p[x] = find(p[x]) : x;  
38 }  
39 bool cmp(ee a, ee b)  
40 {  
41     return a.w < b.w;  
42 }  
43 int main()  
44 {  
45     int n;  
46     int r1, r2;  
47     double d;  
48     while (cin >> n)  
49     {  
50         tot = 0;  
51         d = 0;  
52         memset(e, 0, sizeof(e));  
53         memset(a, 0, sizeof(a));  
54         for (int i = 1; i <= n; i++) p[i] = i;  
55         for (int i = 1; i <= n; i++) scanf("%lf%lf", &a[i].x, &a[i].y);  
56           for (int i = 1; i <= n; i++)  
57             for (int j = 1; j <= n; j++)  
58               if (i != j)  
59                 init(i, j);  
60         sort(e + 1, e + 1 + tot, cmp);  
61         for (int i = 1; i <= tot; i++)  
62         {  
63             r1 = find(e[i].u); r2 = find(e[i].v);  
64             if (r1 != r2)  
65             {  
66                 p[r2] = r1;  
67                 d += e[i].w;  
68             }  
69         }  
70         printf("%.2lf\n", d);  
71     }  
72     return 0;  
73 

这道题当指令是M的时候，就是并查集的合并工作了，C的时候自然就是查找，但是麻烦就是怎么去弄明白那个x下面到底有多少个元素，而且它是整列整列的弄的，所以需要找个东西标记一下。

用一个域u标记元素x的上面有多少个元素，用一个域d标记元素x的下面有多少个元素，合并的时候只要更新这两个域内的值就行了，那么对于每一个查找指令，答案就是x所在集合根节点下面的元素个数减去元素x上面的元素个数再减去x本身咯～不过这个真心不好想啊～

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <cstdlib>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define N 30001
 9 struct data
10 {
11     int p, u, d;
12 }p[N];
13 int find(int x)
14 {
15     int t;
16     if (p[x].p != x)
17     {
18         t = p[x].p;
19         p[x].p = find(t);
20         p[x].u += p[t].u;
21     }
22     return p[x].p;
23 }
24 int main()
25 {
26     int P;
27     int x, y;
28     int r1, r2;
29     char c;
30     for (int i = 1; i < N; i++)
31     {
32         p[i].p = i;
33         p[i].u = 0;
34         p[i].d = 1;
35     }
36     cin >> P;
37     while (P--)
38     {
39         scanf("\n%c", &c);
40         if (c == 'M')
41         {
42             scanf(" %d %d", &x, &y);
43             r1 = find(x); r2 = find(y);
44             if (r1 != r2)
45             {
46                 p[r2].p = r1;
47                 p[r2].u = p[r1].d;
48                 p[r1].d += p[r2].d;
49             }
50         }
51         if (c == 'C')
52         {
53             scanf(" %d", &x);
54             y = find(x);
55             printf("%d\n", p[y].d - p[x].u - 1);
56         }
57     }
58     return 0;
59 

首先，所有的电脑的坐标全都给记下来，然后开始了指令的执行，再执行指令的时候，把所有能连接上的电脑合并到一个集合里面，然后需要检查两台电脑是否能够连接的时候，直接检查两个电脑是不是在一个集合里面就行了。

但是千万不要忘了，在刚开始的时候，所有的电脑全都是坏的，坏电脑是放不进去集合里面的（我会说因为这个标记上的错误样例都没过去吗？）

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstdlib>
 4 #include <cstring>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define N 1010
 9 struct data
10 {
11     int x, y;
12 }k[N];
13 int p[N], d;
14 bool dis(int a, int b)
15 {
16     int x = k[a].x - k[b].x;
17     int y = k[a].y - k[b].y;
18     if (x * x + y * y <= d * d) return 1;
19     else return 0;
20 }
21 int find(int x)
22 {
23     return p[x] != x ? p[x] = find(p[x]) : x;
24 }
25 int main()
26 {
27     int n;
28     int x, y;
29     int r1, r2;
30     char c;
31     bool f[N];
32     cin >> n >> d;
33     for (int i = 1; i <= n; i++)
34     {
35         p[i] = i;
36         scanf("%d%d", &k[i].x, &k[i].y);
37         f[i] = 0;
38     }
39     while (scanf("\n%c", &c) != EOF)
40     {
41         if (c == 'O')
42         {
43             scanf("%d", &x);
44             f[x] = 1;
45             for (y = 1; y <= n; y++)
46             {
47                 if (y != x && dis(x, y) && f[y])
48                 {
49                     r1 = find(x); r2 = find(y);
50                     if (r1 != r2)
51                       p[r2] = r1;
52                 }
53             }
54         }
55         if (c == 'S')
56         {
57             scanf("%d%d", &x, &y);
58             r1 = find(x); r2 = find(y);
59             if (r1 == r2) printf("SUCCESS\n");
60             else printf("FAIL\n");
61         }
62     }
63     return 0;
64 

这道题给的小组中的元素实际上是一定属于一个集合里面的，那么小组中每一个元素都要合并到一起，当然，有的元素可能已经是其它集合里面的了，不过没关系，我们需要的只是患病团体和不患病团体，最终所有的人全都合并完以后，明显患病团体应该是含有0号人的那个集合，那么我们只需要查找一下0集合里面存在多少个元素就可以了。

view code
 1 #include <iostream>  
 2 #include <cstdio>  
 3 #include <cstdlib>  
 4 #include <cstring>  
 5 #include <cmath>  
 6 #include <algorithm>  
 7 using namespace std;  
 8 #define N 30010  
 9 struct data  
10 {  
11     int p, n;  
12 }p[N];  
13 int find(int x)  
14 {  
15     int temp;  
16     if (x == p[x].p) return x;  
17     temp = p[x].p;  
18     p[x].p = find(temp);  
19     return p[x].p;  
20 }  
21 int main()  
22 {  
23     int n, m, k;  
24     int a[N];  
25     int r1, r2;  
26     while (scanf("%d%d", &n, &m) != EOF)  
27     {  
28         if (n == 0 && m == 0) break;  
29         for (int i = 0; i < n; i++)  
30         {  
31             p[i].p = i;  
32             p[i].n = 1;  
33         }  
34         for (int i = 0; i < m; i++)  
35         {  
36             memset(a, 0, sizeof(a));  
37             scanf("%d", &k);  
38             for (int j = 0; j < k; j++) scanf("%d", &a[j]);  
39             for (int j = 1; j < k; j++)  
40             {  
41                 r1 = find(a[j - 1]); r2 = find(a[j]);  
42                 if (r1 != r2)  
43                 {  
44                     p[r2].p = r1;  
45                     p[r1].n += p[r2].n;  
46                 }  
47             }  
48         }  
49         int r = find(0);  
50         printf("%d\n", p[r].n);  
51     }  
52     return 0;  
53 }  
54 

首先，如果两个虫子中有一个虫子是以前从来没有处理过的，那么两个虫子就可以合并到一个集合里面，而且这两个虫子一定是异性，如果两个虫子都处理过了，那就在集合之中各种查找就行，看看两只虫子到底是异性还是同性，而我们知道了集合中各种虫子的关系，加以区分就可以了。那么小弟我今天刚刚学会并查集向量偏移这个思想，就稍稍的推一下哈～

首先，假定两只虫子的是异性的时候，偏移量为1，同性的时候，偏移量为0，毋庸置疑，初始化并查集的时候由于所有虫子的根节点都是它们本身，那么所有虫子的偏移量都是0。下面我们来考虑一下向量的多边形定则，如果是一个四边性，有四个顶点A，B，C，D，那么向量A→D=A→B+B→C+C→D，那么我们合并集合的时候就完全可以借鉴这种多边形定则的思想，把两个元素之间的关系看成是一个向量，推导出来公式加一下下就可以啦～不过要注意方向啊。

下面附AC代码

view code
 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <cstdlib>
 5 #include <cmath>
 6 #include <algorithm>
 7 using namespace std;
 8 #define N 2010
 9 struct data
10 {
11     int p, r;
12 }p[N];
13 int find(int x)
14 {
15     int temp;
16     if (p[x].p == x) return x;
17     temp = p[x].p;
18     p[x].p = find(temp);
19     p[x].r = (p[x].r + p[temp].r) % 2;
20     return p[x].p;
21 }
22 int main()
23 {
24     int t;
25     int n, k;
26     int x, y;
27     int r1, r2;
28     bool ju;
29     cin >> t;
30     for (int j = 1; j <= t; j++)
31     {
32         ju = 0;
33         cin >> n >> k;
34         for (int i = 1; i <= n; i++)
35         {
36             p[i].p = i;
37             p[i].r = 0;
38         }
39         for (int i = 0; i < k; i++)
40         {
41             scanf("%d%d", &x, &y);
42             r1 = find(x); r2 = find(y);
43             if (r1 != r2)
44             {
45                 p[r2].p = r1;
46                 p[r2].r = (1 + p[x].r - p[y].r) % 2;
47             }
48             else
49             {
50                 if (((2 - p[x].r + p[y].r) % 2) != 1)
51                   ju = 1;
52             }
53         }
54         printf("Scenario #%d:\n", j);
55         if (ju) cout << "Suspicious bugs found!" << endl << endl;
56         else cout << "No suspicious bugs found!" << endl << endl;
57     }
58     return 0;
59 }
60