Hdu 2419 Boring Game (数据结构_并查集)
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=2419
题目大意：给定n个点m条边的无向图，每个点有点权。有q个操作，每个操作有三种：1、查询和某个点连通的大于k的最小点权 2、将某点的点权更新为k 3、删除某条边。
解题思路：08年网络赛的题目，全场5个人过，但绝对是难度中等的并查集好题。从这题我学到了对给定操作序列问题的一种很有效的处理方法--逆序处理，还学会STL里set的几个操作，收获颇丰啊。
我们先不想其他的，考虑这个问题的三种操作要我们做什么。第一种操作就是找某个连通分量的大于k的最小点权，第二种和第三种如果是暴力q*n求解，那么就自然而然地模拟。
但是复杂度太高了，q为30万，n为2万，最多操作60亿次。因为有牵扯到连通分量，考虑用并查集做。那么第一个操作就是要找某个根所有儿子中权值大于k的最小值，着好像和我们平时做的并查集不一样，平时都是利用根的信息，这就是本题的一个亮点。第二个操作似乎要先找到根再来遍历儿子，再来更新点权，第三个操作似乎要将某个集合拆成两个集合。
这些操作如果正序来做，的确很吓人，第一个我们可以通过STL的set来应付，set的lower_bound方法不就是题目描述的这功能吗？第三个操作要拆集合很困难，但我们逆序转换成合并集合，则要简单、飘逸许多，也不影响结果。这就是本题的两个亮点。
分析差不多就这样，接着就是代码实现，我第一次用set操作，参看了百度和某神牛的代码，效率还不错，256ms，排名第三。
测试数据：
3 3 8
4 5 8
1 2
2 3
1 3
F 1 4
E 1 3
F 2 7
E 2 3
E 1 2
F 2 7
U 3 6
F 3 3
out: Case XX: 4.500
1 0 1
0
F 1 0
out: Case XX: 0.00
3 3 8
8 8 8
1 2
2 3
1 3
F 1 9
F 1 8
E 1 3
E 2 3
E 1 2
F 1 8
U 3 6
F 3 7
out: Case XX: 4.000
3 3 9
8 8 8
1 2
2 3
1 3
F 1 9
F 1 8
U 1 5
E 2 3
E 1 2
E 1 3
F 1 5
U 1 6
F 1 6
out:Case XX: 4.750
3 3 11
8 8 8
1 2
2 3
1 3
F 1 9
F 1 8
U 1 5
F 1 6
E 2 3
E 1 2
E 1 3
U 1 4
F 1 5
U 1 6
F 1 6
out: Case XX: 4.400
C艹代码：
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <set>
#include <algorithm>
using namespace std;
#define MAX 20010
#define PAIR pair<int,int>
struct Query {
char ope[3];
int x,y;
}query[300010];
double ans;
int cost[MAX]; //cost[i]表示每个点的权值
int n,m,q,time,fa[MAX]; //fa[i]表示i属于哪个集合
multiset<int> map[MAX]; //存放图，本题将无向图转换为有向图，因为只要判是否连通
multiset<int> ver[MAX]; //存放以某点为父亲的所有节点
int GetPa(int x) { //获取x点的父亲，并进行路径压缩
int p = x,tp;
while (p != fa[p]) p = fa[p];
while (x != p) {
tp = fa[x];
fa[x] = p,x = tp;
}
return p;
}
void UnionSet(int x,int y) { //将y属于的集合和x属于的集合合并
int px = GetPa(x);
int py = GetPa(y);
if (px == py) return;
if (px > py) swap(px,py);
fa[px] = py;
multiset<int>::iterator it;
for (it = ver[px].begin(); it != ver[px].end(); ++it)
ver[py].insert(*it); //合并时子节点也需要合并
}
int main()
{
int i,j,k,cas = 0,a,b,pa;
while (scanf("%d%d%d",&n,&m,&q) != EOF) {
for (i = 1; i <= n; ++i) {
fa[i] = i;
map[i].clear();
ver[i].clear();
scanf("%d",&cost[i]);
}
for (i = 1; i <= m; ++i) {
scanf("%d%d",&a,&b); //边从小点连到大点
if (a < b) map[a].insert(b);
else map[b].insert(a);
}
for (i = 1; i <= q; ++i) { //先处理所有操作，再往回查询，加边
scanf("%s %d%d",query[i].ope,&a,&b);
query[i].x = a,query[i].y = b;
if (query[i].ope[0] == 'U') {
//保存原来的点权，并更新点权
query[i].y = cost[a];
cost[a] = b;
}
else if (query[i].ope[0] == 'E') {
//先删除这条边，后面再添加，这样不需要拆集合
if (a < b) map[a].erase(map[a].find(b));
else map[b].erase(map[b].find(a));
}
}
for (i = 1; i <= n; ++i)
ver[i].insert(cost[i]);
multiset<int>::iterator it;
for (i = 1; i <= n; ++i) //用处理完的图建立并查集
for (it = map[i].begin(); it != map[i].end(); ++it)
UnionSet(i,*it);
ans = time = 0;
for (i = q; i >= 1; --i) {
a = query[i].x,b = query[i].y;
if (query[i].ope[0] == 'F') {
time++,pa = GetPa(a);
it = ver[pa].lower_bound(b);//set的这个方法很好地应付查询操作
if (it != ver[pa].end()) ans += *it;
}
else if (query[i].ope[0] == 'U') {
//更新回去
pa = GetPa(a);
it = ver[pa].find(cost[a]);
ver[pa].erase(it);
ver[pa].insert(b);
cost[a] = b;
}
else UnionSet(a,b); //这一步是逆序处理的关键益处，变得异常简单
}
printf("Case %d: %.3lf\n",++cas,ans/time);
}
}
本文ZeroClock原创，但可以转载，因为我们是兄弟。