启发式合并

比如说这道P3295 [SCOI2016]萌萌哒其实就是一道启发式合并，其说白了，便是拖延的操作，把每一个对区间每一个点的操作，留到查询的时候一起来做，比如说这道题，就是启发式的并查集，将单点合并变成区间合并，之前的倍增题目里讲过了，就不复述了啦。看这个P3201 [HNOI2009] 梦幻布丁这个也可以用到启发式的合并，感觉这些题都有一个共同点，都是区间修改，而且都是区间查询，而且拿数据结构维护极其困难，这时候就可以看看数据范围，合适的话就选择启发式合并啦通常来说，这东西的时间是O（nlogn）无论是查询或是修改。
具体看代码，不想说，昨晚有人有点小破防，一共只睡了三四个小时哈哈哈哈哈哈哈哈哈，累了不想说了，欸问题就是，这个我们需要将小的合并到大的上面，具体而言，比较，交换，合并，结束，大概吧：

#include<bits/stdc++.h>
using namespace std;
int n,m;
int c[1200001],sz[1200001],st[1200001],f[1200001],hd[1200001],net[1200001],ans; 
void hb(int x,int y)
{
	for(int i=hd[x];i;i=net[i]) ans-=(c[i-1]==y)+(c[i+1]==y);
	for(int i=hd[x];i;i=net[i]) c[i]=y;
	net[st[x]]=hd[y],hd[y]=hd[x],sz[y]+=sz[x];
	hd[x]=st[x]=sz[x]=0;
	return ; 
}
int main()
{
//	memset(last,-1,sizeof(last));
	scanf("%d%d",&n,&m);
	 for(int i=1;i<=n;++i) 
	 {
        scanf("%d",&c[i]),f[c[i]]=c[i];
        ans+=c[i]!=c[i-1];
        if(!hd[c[i]]) st[c[i]]=i;
        ++sz[c[i]],net[i]=hd[c[i]],hd[c[i]]=i;
    }
 	while(m--)
 	{
 		int p;scanf("%d",&p);
		if(p==2) printf("%d\n",ans);
		else 
		{
			int x,y;scanf("%d%d",&x,&y);
			if(x==y) continue; 	
			if(sz[f[x]]>sz[f[y]]) swap(f[x],f[y]);
			if(!sz[f[x]]) continue ;
			hb(f[x],f[y]);
		}	
	}
	return 0;
}

然后有一道板子冷战 黑暗爆炸 - 4668

//下午睡了一会，还是补上写法吧，大佬并没有用路径压缩的算法而是采用了按秩合并的方式。 
//所谓的秩，有两种定义方法。一种是表示树的深度（未路径压缩时），另一种是表示集合的大小。
//按秩合并就是把秩小的并查集合并为秩较大的并查集的儿子。
//最终得到的并查集会有树形结构。同时为了维护这个树形结构，就不能再使用路径压缩优化了。
//把所有关系看成一颗树，那么答案就是树上路径的最大值。
//使用并查集，为了方便，我们按秩合并。
//还得是你呀lca（可惜没用倍增 
#include<cstdio>
#include<cctype>
#include<algorithm>
#include<cstring>
using namespace std;
int n,m;
int ans=0,cnt=0,a[500005];
int fa[500005],dep[500005],s[500005];
int findfa(int x)
{
	if(fa[x]==x) return x;
	int y=findfa(fa[x]);dep[x]=dep[fa[x]]+1;
	return y;
}
void lca(int x,int y)
{
	while(x!=y)
	{
		if(dep[x]<dep[y]) swap(x,y);
		ans=max(ans,a[x]);x=fa[x];
	}
	return ;
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++) fa[i]=i,s[i]=1;
	for(int i=1;i<=m;i++)
	{
		int p,x,y;scanf("%d%d%d",&p,&x,&y);x^=ans,y^=ans;
		if(p==1) 
		{
			int fx=findfa(x),fy=findfa(y);ans=0;	
			if(fy==fx) lca(x,y);printf("%d\n",ans);
		}
		else 
		{
			int fx=findfa(x),fy=findfa(y);cnt++;
			if(fx!=fy)
			{
				if(s[fx]>=s[fy]) fa[fy]=fx,a[fy]=cnt,s[fx]+=s[fy];
				else fa[fx]=fy,a[fx]=cnt,s[fy]+=s[fx]; 
			}
		}
	}
	return 0;
 } 

再看一道按秩合并的题目Bond这题的精髓在于，一个优秀的合并以及一个不错的lca，帅帅帅。还有一个就是最小生成树的同时做并查集。

#include<bits/stdc++.h>
using namespace std;
int n,m,zz=0;
int fa[52010],s[52010],w[52010],wi[52010];
struct pp
{
	int x,y,v;
};pp p[52010];
bool cmp(const pp &x,const pp &y)
{
	return x.v<y.v;
}
int findfa(int x)
{
	if(fa[x]==x) return x;
	return findfa(fa[x]);
}
void hb(int x,int y,int v)
{
	int fx=findfa(x),fy=findfa(y);
	if(fx==fy) return ;
	if(s[fx]<s[fy]) fa[fx]=fy,w[fx]=v;
	else 
	{
		fa[fy]=fx;w[fy]=v;
		if(s[fx]==s[fy]) s[fx]++;
	}
	return ;
}
int solve(int x,int y)
{
	memset(wi,0,sizeof(wi));int ans=1,ans1=0;
	while(1)
	{
		wi[x]=ans;
		if(fa[x]==x) break;
		ans=max(ans,w[x]);x=fa[x];
	}	
	while(1)
	{
		if(wi[y]) 
		{
			ans1=max(wi[y],ans1);
			break;	
		}
		else if(fa[y]==y) break;
		else ans1=max(ans1,w[y]),y=fa[y];
	}
	return ans1;
}
int main()
{
	while(scanf("%d%d",&n,&m)==2)
	{
		if(zz++) putchar('\n');
		for(int i=1;i<=n;i++) fa[i]=i,w[i]=0,s[i]=0;
		for(int i=1;i<=m;i++) scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].v);
		sort(p+1,p+m+1,cmp);
		for(int i=1;i<=m;i++) hb(p[i].x,p[i].y,p[i].v);
		int q;scanf("%d",&q);
		while(q--)
		{
			int x,y;scanf("%d%d",&x,&y);
			printf("%d\n",solve(x,y));
		}
	}
	return 0;
}//xyynb!

P5578 [PA2014]Fiolki这道题算是合并吧，但是一个很另类的题目，以建树来合并点，然后通过lca的操作来搞。慢慢看吧。大佬说：就是其实把两个反应物向生成物连一条边，那么就形成了一个二叉树森林（不一定联通），叶子结点都是原来的试剂，如果两种试剂会反应，那么它们会在lca的位置相遇，然后反应生成沉淀，生成的沉淀质量为2倍较小质量数，然后各自减去这个转化量。显然lca深度比较大沉淀先发生，于是我们就找出了这些沉淀的顺序。注意lca深度相同时，要按照给出顺序排，题目说了按照反应优先顺序给出这kk对可以反应的物质。

#include<bits/stdc++.h>
//#define int long long 
using namespace std;
int n,m,k;
long long ans=0;
int dep[420001],pos[220001];//pos是当前试剂所在的编号
int len=0,tot=0,cnt=0,db[420001][30];
int last[420001],g[220001];
struct pp
{
	int x,y,next;
};pp p[400005];
struct node 
{
	int a,b,cd,id;
};node q[500005];
bool cmp(const node &x,const node &y)
{
	if(x.cd!=y.cd) return x.cd>y.cd;
	return x.id<y.id;
}
void ins(int x,int y)
{
	int now=++len;
	p[now]={x,y,last[x]};last[x]=now;
	return ;
} 
void getdb(int x,int fa)
{
	dep[x]=dep[fa]+1;db[x][0]=fa;
	for(int i=1;(1<<i)<=dep[x];i++) db[x][i]=db[db[x][i-1]][i-1];
	for(int i=last[x];i!=-1;i=p[i].next)
	{
		int y=p[i].y;
		if(y!=fa) getdb(y,x);
	}
	return ;
}
int getlca(int x,int y)
{
	if(dep[x]>dep[y]) swap(x,y);
	for(int i=20;i>=0;i--) 
	{
		if(dep[x]<=dep[y]-(1<<i)) y=db[y][i];
	}
	if(x==y) return x;
	for(int i=20;i>=0;i--)
	{
		if(db[x][i]!=db[y][i]) x=db[x][i],y=db[y][i];
	}
	return db[x][0];
}
signed main()
{
	memset(last,-1,sizeof(last));
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=n;i++) scanf("%d",&g[i]),pos[i]=i;
	for(int i=1;i<=m;i++)
	{
		int x,y;scanf("%d%d",&x,&y);
		ins(n+i,pos[x]);ins(n+i,pos[y]);
		pos[y]=n+i;
	}
	for(int i=n+m;i>=1;i--)//倒着搞，因为后面的在更上面 
	{
		if(db[i][0]==0) getdb(i,0); 
	}
	for(int i=1;i<=k;i++)
	{
		int a,b,lca;scanf("%d%d",&a,&b);lca=getlca(a,b);//printf("*%d",lca);
		if(lca==0) continue ;
		node tmp;tmp.a=a,tmp.b=b,tmp.cd=dep[lca],tmp.id=i;
		q[++cnt]=tmp; 	
	}
	sort(q+1,q+cnt+1,cmp);
	for(int i=1;i<=cnt;i++)
	{
		int minn=min(g[q[i].a],g[q[i].b]);
		g[q[i].a]-=minn;g[q[i].b]-=minn;
		ans+=1ll*2*minn;
	}
	printf("%lld",ans);
	return 0;	
}

再来一题》》P5507 机关，算了下次吧这道看起启发式搜索很难欸。