WaWa的奇妙冒险（第十周集训自闭现场）

（一）并查集入门

1.简述并查集

何为并查集，简单说说个人理解，对于有向图和无向图的结点进行集合分类的操作。

就本质上来说，就是给同一集合内的所有点找到一个祖先/首领结点，然后通过判断结点祖先是否相同来确定这两个结点是否在同一个集合内。

除此之外，一般通过平衡建树和压缩路径的方式减小找到祖先的时间（实际上个人感觉压缩路径就已经很好地解决了这个问题，因为除非是大量的多结点集合重复合并，不然不会存在路径非常长的结点找祖父这种情况）

运用：
1.以并查集为主的题目，靠并查集操作就能得到答案（一般而言除了裸题，都会是集合带权或者集合、结点带权啥的），依题目变形程度确认难度。

2.以并查集为辅助的题目，一般用来确认题目的集合划分，然后在此基础上进行操作，找出答案

2.带权并查集

（1）集合带权

给整个集合的每个结点都赋予一个权值，但因为实际上把每个结点都更新一次并不优秀，所以实际上讲祖父结点的权值设立为整个集合所拥有的集合权值，在每次查询某个集合内结点的集合权值时，只要找到它的祖父结点然后输出祖父结点的权值即可。

More is better hdu - 1856

思路：一道经典的结合带权并查集题目，要求的是集合大小，操作方式和上面所说的一样，更新祖父结点的权值即可，当祖父结点变更的时候，老的祖父结点的权值用于更新新祖父结点的权值，然后老祖父结点失去意义（或者说不再可能被查询到，所以当做失效）

#include 
using namespace std;
const int maxn = 1e7 + 5;

int pre[maxn],h[maxn];
int find(int x){
	return pre[x] = pre[x] == x ?x :find(pre[x]);
}

int main()
{
	int x,y,n,ans;
	while(~scanf("%d",&n)){
		for(int i = 1;i <= maxn-5;++i) pre[i] = i,h[i] = 1;
		
		int ans = 1;
		for(int i = 0;i < n;++i){
			scanf("%d%d",&x,&y);
			int xx = find(x);
			int yy = find(y);
			if(xx == yy) continue;
			pre[xx] = yy;
			h[yy] += h[xx];
			if(h[yy] > ans) ans = h[yy];
		}
		
		printf("%d\n",ans);
	}	
	
	return 0;
}

（2）结点带权

结点带权一般指的就是对于集合内，每个结点都带有各自的权值，但因为难以实现各个权值结点都直接更新，所以采用保留根结点集合权值，压缩路径时更新结点权值的方式完成结点权值的更新。

做一个简单阐述（灵魂画手不敢画图），首先我们先假设一个四到五层的结点零权值二叉树，对于父节点附加的权值，要求加到所有的子节点上，只要在父节点逐渐往后走的路上，把父节点的权值累加到子节点上就好了。

那么对于带权并查集而言，我们同样可以通过暂存的方式，把增加的结点权值暂存在原父节点（一般而言会保证父结点权值为0），在路径压缩经过那个点的时候我们就顺道更新了结点权值，对于子节点还没更新，父节点就被被更新的情况，可以视作暂存了多个父节点的权值。（**申明：**此处的父节点更新的权值，一般为集合权值）。

实际上，个人认为，结点权值可以视作一种分块的更新结点权值，但此处做何解释，还没有想通透，暂时放一放。

放一个一般更新常规的带权并查集用的板子，绝大部分水题都能用

int find(int x){
	if(pre[x] == x) return x;
	int t = pre[x];
	pre[x] = find(pre[x]);
	ans[x] += ans[t];
	return pre[x];
}

Cube Stacking POJ - 1988

思路：集合带权整个集合的高度，结点带权结点下面结点的数量，用集合权值更新祖父结点的权值，然后在查找的时候更新相应子节点的权值

#include 
using namespace std;
const int maxn = 1e5+5;

int pre[30005],h[30005],ans[30005];
int find(int x){
	if(pre[x] == x) return x;
	int t = pre[x];
	pre[x] = find(pre[x]);
	ans[x] += ans[t];
	return pre[x];
}

int main()
{
	int x,y,p,m,t;
	char k;
	scanf("%d",&p);
	for(int i = 1;i <= 30000;++i) pre[i] = i,h[i] = 1,ans[i] = 0;
	for(int i = 0;i < p;++i){
		cin >> k;
		if(k == 'M'){
			scanf("%d%d",&x,&y);
			int xx = find(x);
			int yy = find(y);
			if(xx == yy) continue;
			
			pre[xx] = yy;
			ans[xx] = h[yy];
			h[yy] += h[xx];
		}
		else{
			scanf("%d",&x);
			find(x);
			printf("%d\n",ans[x]);
		}
	}
	
	return 0;
}

Dragon Balls HDU - 3635

思路：和上题实际上没啥区别，更新集合权值（大小），更新结点权值（移动步数）——更新祖父结点的步数再进行一个find就好了。

#include 
using namespace std;

int pre[10005],h[10005],mos[10005];
int find(int x){
	if(pre[x] == x) return x;
	int t = pre[x];
	pre[x] = find(pre[x]);
	mos[x] += mos[t];
	return pre[x];
}

int main()
{
	int x,y,n,m,t;
	char k;
	scanf("%d",&t);
	for(int o = 1;o <= t;++o){
		scanf("%d%d",&n,&m);
		for(int i = 1;i <= n;++i) pre[i] = i,mos[i] = 0,h[i] = 1;
		printf("Case %d:\n",o);
		for(int i = 0;i < m;++i){
			cin >> k;
			if(k == 'T'){
				scanf("%d%d",&x,&y);
				int xx = find(x);
				int yy = find(y);
				if(xx == yy) continue;
				pre[xx] = yy;
				h[yy] += h[xx];
				mos[xx]++;
			}
			else{
				scanf("%d",&x);
				int idx = find(x);
				printf("%d %d %d\n",idx,h[idx],mos[x]);
			}
		}
	}
	
	return 0;
}

（3）权值变形

上述的结点或者集合权值都是简单的大小、步数之类的，实际上，权值可以是很多类型，比如说，不冲突的集合数量。

数据分割 百度之星

思路：找到第一个不满足的条件，然后记录一次即可，这里因为有相同或者不相同，不相同的集合只要不冲突就可以存在，要把这个集合所有不冲突的集合设为集合权值，这里就用了set进行处理，权值的更新也进行一定的修改。

#include 
#include 
using namespace std;
const int maxn = 1e5 + 5;
const int INF = 1e5+1;

set <int> s[maxn],e;
int ans[maxn];
int pre[maxn];
int find(int x){
	return pre[x] = pre[x] == x ?x :find(pre[x]);
}

void init(){
	set<int>::iterator it;
	for(it = e.begin();it != e.end();it++){
		s[*it].clear();
		pre[*it] = *it;
	}
	return ;
}

int main()
{
	int x,y,k,t,cnt = 0,len = 0;
	scanf("%d",&t);
	for(int i = 0;i <= maxn-5;++i) pre[i] = i;
	for(int i = 0;i < t;++i){
		scanf("%d%d%d",&x,&y,&k);
		cnt++;
		e.insert(x);e.insert(y);
		x = find(x);y = find(y);
		if(k){
			if(x == y) continue;
			if(s[x].count(y)) ans[len++] = cnt,cnt = 0,init();
			else{
				pre[x] = y;
				for(set<int>::iterator it = s[x].begin();it != s[x].end();it++){
					s[*it].erase(x);
					s[*it].insert(y);
					s[y].insert(*it);
				}
			}
		}
		else{
			if(x == y) ans[len++] = cnt,cnt = 0,init();
			else s[x].insert(y),s[y].insert(x);
		}
	}
	printf("%d\n",len);
	for(int i = 0;i < len;++i) printf("%d\n",ans[i]);

	return 0;
}

（4）种类并查集

1.两种种类的，一般就再设立一个敌对数组，敌人的敌人就是朋友，在更新完新集合之后，顺道更新敌人，因为老的敌人已经防到了集合里，所以不用担心更新问题

Find them, Catch them POJ - 1703

思路：如上所述进行操作即可

#include 
using namespace std;

int pre[100005],e[100005];

int find(int x){
	return pre[x] = pre[x] == x ?x :find(pre[x]);
}

int main()
{
	int t,n,m,x,y;
	char k;
	scanf("%d",&t);
	while(t--){
		scanf("%d%d",&n,&m);
		for(int i = 1;i <= n;++i) pre[i] = i,e[i] = 0;
		for(int i = 0;i < m;++i){
			getchar();
			scanf("%c%d%d",&k,&x,&y);
			if(k == 'D'){
				if(e[x]) pre[find(e[x])] = pre[find(y)];
				if(e[y]) pre[find(e[y])] = pre[find(x)];
				e[x] = y;
				e[y] = x;
			}
			else{
				if(find(x) == find(e[y])) printf("In different gangs.\n");
				else if(find(x) == find(y)) printf("In the same gang.\n");
				else printf("Not sure yet.\n");
			}
		}
	}
	return 0;
}

当种类变得更多，根据相应的关系，我们可以采取种类赋权（这个其实还太玩懂，写实写了一次来着），或者使用扩展域（简单来说，就是把一个点拆成多个点，然后n成倍数处理即可）

下面附上用这两种写法写的经典题目食物链

食物链 HDU - 1182

思路：扩展域

#include 
using namespace std;
const int maxn = 15e4+5;

int pre[maxn];
int find(int x){
	return pre[x] = pre[x] == x ?x :find(pre[x]);
}

int main()
{
	int n,k,d,x,y,ans = 0;
	scanf("%d%d",&n,&k);
	for(int i = 1;i <= n*3;++i) pre[i] = i;
	for(int i = 0;i < k;++i){
		scanf("%d%d%d",&d,&x,&y);
		if(x < 1 || y < 1 || x > n || y > n || (d == 2 && x == y)) {ans++;continue;}
		if(d == 1){
			if(pre[find(x)] == pre[find(y+n)] || pre[find(x)] == pre[find(y+2*n)]) {ans++;continue;}
			pre[find(x)] = pre[find(y)];
			pre[find(x+n)] = pre[find(y+n)];
			pre[find(x+2*n)] = pre[find(y+2*n)];
		}
		else{
			if(pre[find(x)] == pre[find(y)] || pre[find(x)] == pre[find(y+n)]) {ans++;continue;}
			pre[find(x)] = pre[find(y+2*n)];
			pre[find(x+n)] = pre[find(y)];
			pre[find(x+2*n)] = pre[find(y+n)];
		}
	}
	printf("%d\n",ans);
	return 0;
}

思路：0吃1,1吃2,2吃0，用%3更新循环链，并且集合也能判断是否已经分类

#include 
using namespace std;
const int maxn = 5e4 + 5;

int po[maxn];
int pre[maxn];
int find(int x){
	if(pre[x] == x) return x;
	int t = pre[x];
	pre[x] = find(pre[x]);
	po[x] = (po[x] + po[t]) % 3;
	return pre[x];
}

int main()
{
	int n,k,d,x,y,ans = 0;
	scanf("%d%d",&n,&k);
	for(int i = 1;i <= n;++i) pre[i] = i,po[i] = 0;
	for(int i = 0;i < k;++i){
		scanf("%d%d%d",&d,&x,&y);
		if(x > n || y > n || (d == 2 && x == y)) {ans++;continue;}
		int xx = find(x);
		int yy = find(y);
		if(d == 1){
			if(xx == yy && po[x] != po[y]) {ans++;continue;}
			po[yy] = (po[x] - po[y] + 3) % 3;
			pre[yy] = xx;
		}
		else{
			if(xx == yy && (po[x]+1) % 3 != po[y]) {ans++;continue;}
			po[yy] = (po[x] - po[y] + 4) % 3;
			pre[yy] = xx;
		}
	}
	printf("%d\n",ans);
	return 0;
}

（5）区间并查集

到现在只做了一题，实际上并没有太多理解，现在的感觉是和普通并查集并没有太大区别，维护祖父结点为0，将边权值转变为点权值就好了

#include 
#include 
using namespace std;
const int maxn = 2e5+5;

int pre[maxn],po[maxn];

void init(int n){
	for(int i = 0;i <= n;++i) pre[i] = i,po[i] = 0;
	return ;
}

int find(int x){
	if(pre[x] == x) return x;
	int t = pre[x];
	pre[x] = find(pre[x]);
	po[x] += po[t];
	return pre[x];
}

int main()
{
    int x,y,d,n,m,ans;
    while(~scanf("%d%d",&n,&m)){
	    init(n);
	    ans = 0;
	    for(int i = 0;i < m;++i){
	       	scanf("%d%d%d",&x,&y,&d);
	       	int xx = find(x-1);
	       	int yy = find(y);
	       	if(xx != yy){
	       		pre[yy] = xx;
	       		po[yy] = po[x-1] + d - po[y];
			}
			else if(po[x-1] + d != po[y]) ans++;
		}
		printf("%d\n",ans);
	}
	return 0;
}

（二）LCA

粗看了离线的tarjan和倍增算法，转RMQ看过了，感觉还是不太懂，因为目前只会写tarjan，所以只讲讲倍增法

倍增LCA：
1.入度为0预处理建树，建立深度树
2.再迭代预处理dp数组，找到1,2，4，…父节点（实际上和多重背包的二进制优化类似）
3.LCA到相同深度，再往上找第一个公共父节点即可

简单贴一道仙人掌树的题
ccpc 秦皇岛 Forest Program

#include 
#include 
using namespace std;
typedef long long ll;
const ll mod = 998244353;
const int maxn = 5e5+10;

struct edg{
	int to,next;
} e[maxn << 1];
int lcnt,ecnt;
int head[maxn],pre[maxn],x[maxn],y[maxn],dep[maxn],p[maxn][20];

void init(int n){
	lcnt = ecnt = 0;
	e[0].next = e[0].to = 0;
	for(int i = 1;i <= n;++i) pre[i] = i,head[i] = 0,dep[i] = 0;
	memset(p,0,sizeof(p));
	return ;
}

void add(int u,int v){
	e[++ecnt].to = v;
	e[ecnt].next = head[u];
	head[u] = ecnt;
	return ;
}

int find(int n){
	return pre[n] = pre[n] == n ?n :find(pre[n]);
}

void dfs(int u){
	for(int i = head[u];i;i = e[i].next){
		int v = e[i].to;
		if(!dep[v]){
			dep[v] = dep[u]+1;
			p[v][0] = u;
			dfs(v);
		}
	}
	return ;
}

void change(int n){
	for(int i = 1;(1 << i) <= n;++i){
		for(int j = 1;j <= n;++j){
			if(p[j][i-1]){
				p[j][i] = p[p[j][i-1]][i-1];
			}
		}
	}
	return ;
}

ll qpow(ll a,ll b){
	ll res = 1;
	while(b){
		if(b & 1) res = (res*a) % mod;
		a = (a*a) % mod;
		b >>= 1;
	}
	return res;
}

int lca(int u,int v){
	if(dep[u] > dep[v]) swap(u,v);
	int len = dep[v] - dep[u];
	int tu = u,tv = v;
	for(int i = len,j = 0;i;i >>= 1,++j){
		if(i & 1) tv = p[tv][j];
	}
	
	if(tu == tv) return tu;
	for(int i = 19;i >= 0;--i){
		if(p[tu][i] == p[tv][i]) continue;
		tu = p[tu][i];
		tv = p[tv][i];
	}
	return p[tu][0];
}

int main()
{
	int u,v,n,m;
	while(~scanf("%d%d",&n,&m)){
		init(n);
		
		for(int i = 0;i < m;++i){
			scanf("%d%d",&u,&v);
			if(find(u) == find(v)) x[lcnt] = u,y[lcnt++] = v;
			else{
				pre[find(u)] = pre[find(v)];
				add(u,v);
				add(v,u);
			}
		}
		
		for(int i = 1;i <= n;++i){
			if(pre[i] == i){
				dep[i] = 1;
				dfs(i);
			}
		}
		
		change(n);
		
		ll ans = 1;
		for(int i = 0;i < lcnt;++i){
			ll k = lca(x[i],y[i]);
			ll s = dep[x[i]] + dep[y[i]] - dep[k]*2 + 1;
			ans = ans*(qpow(2,s)-1) % mod;
			m -= s;
		}
		ans = ans*qpow(2,m) % mod;
		
		printf("%lld\n",ans);
	}	
	return 0;
}

（三）状压背包

上周是水了两题状压背包，之后回来水水，迟点更