BZOJ 2959 长跑 (LCT、并查集)

题目链接

https://www.lydsy.com/JudgeOnline/problem.php?id=2959

题解

真是被这题搞得心态大崩……调了7个小时……然而并查集都能写成\(O(n^2)\)的我还能怪谁呢

显然要把每个边双连通分量缩成点，点权为边双连通分量内所有点点权和，然后答案就等于两点路径上点权和

现在需要用LCT维护，就比较麻烦

大概是一边LCT一边使用并查集分别维护连通块和边双连通分量

加边时，若两点不联通，则link, 然后在维护连通块的并查集里并起来

若两点联通但不在同一边双中，则把这两个点路径上的所有边双缩到一起（其实就是“删除点”），顺便加入到边双连通分量的并查集中

这个可以通过把路径的splay提取出来进行DFS实现，因为每个点只会被删一次所以复杂度正确

但是这里由于缩点，我们每次在lct中访问父亲的时候要求它树上父亲在并查集里的代表元素。。。所以很容易写错

时间复杂度\(O(n\log n\alpha(n))\).

代码

#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<cassert>
#include<ctime>
#define llong long long
using namespace std;

const int N = 1.5e5;
struct SplayNode
{
	int son[2],fa,sum,val,rev;
} spl[N+3];
int uf1[N+3],uf2[N+3];
int stk[N+3];
int a[N+3];
int n,q;

inline int read()
{
    int ret = 0; char ch = getchar();
    while(ch < '0' || ch > '9') ch = getchar();
    while(ch >= '0' && ch <= '9') ret = (ret << 3) + (ret << 1) + ch - '0' , ch = getchar();
    return ret;
}

int findfa(int id,int u)
{
	if(id==0)
	{
		int i = u;
		while(u!=uf1[u]) {u = uf1[u];}
		while(uf1[i]!=u)
		{
			int j = uf1[i]; uf1[i] = u; i = j;
		}
	}
	else
	{
		int i = u;
		while(u!=uf2[u]) {u = uf2[u];}
		while(uf2[i]!=u)
		{
			int j = uf2[i]; uf2[i] = u; i = j;
		}
	}
	return u;
}

bool isroot(int u) {int uu = findfa(1,spl[u].fa); return spl[uu].son[0]!=u && spl[uu].son[1]!=u;}
bool sondir(int u) {return u==spl[findfa(1,spl[u].fa)].son[1];}

void pushup(int u)
{
	spl[u].sum = spl[spl[u].son[0]].sum+spl[u].val+spl[spl[u].son[1]].sum;
}

void pushdown(int u)
{
	int ls = spl[u].son[0],rs = spl[u].son[1];
	if(spl[u].rev)
	{
		spl[u].rev = 0;
		if(ls)
		{
			swap(spl[ls].son[0],spl[ls].son[1]);
			spl[ls].rev ^= 1;
		}
		if(rs)
		{
			swap(spl[rs].son[0],spl[rs].son[1]);
			spl[rs].rev ^= 1;
		}
	}
}

void rotate(int u)
{
	int x = findfa(1,spl[u].fa),y = findfa(1,spl[x].fa); bool dir = sondir(u)^1;
	if(!isroot(x)) {spl[y].son[sondir(x)] = u;}
	spl[u].fa = y;
	spl[x].son[dir^1] = spl[u].son[dir];
	if(spl[x].son[dir^1]) {spl[spl[x].son[dir^1]].fa = x;}
	spl[u].son[dir] = x; spl[x].fa = u;
	pushup(x);
}

void splaynode(int u)
{
	int x = u,tp = 0,y;
	while(!isroot(x)) {tp++; stk[tp] = x; x = findfa(1,spl[x].fa);}
	pushdown(x);
	while(tp) {pushdown(stk[tp]); tp--;}
	while(!isroot(u))
	{
		x = findfa(1,spl[u].fa),y = findfa(1,spl[x].fa);
		if(!isroot(x)) {sondir(x)^sondir(u) ? rotate(u) : rotate(x);}
		rotate(u);
	}
	pushup(u);
}

void access(int u)
{
	for(int i=0; u; i=u,u=findfa(1,spl[u].fa))
	{
		splaynode(u);
		spl[u].son[1] = i; pushup(u);
	}
}

void makeroot(int u)
{
	access(u); splaynode(u);
	spl[u].rev ^= 1; swap(spl[u].son[0],spl[u].son[1]);
}

void link(int u,int v)
{
	makeroot(u); spl[u].fa = v;
}

void dfs(int u,int u0)
{
	uf2[u] = u0;
	pushdown(u);
	if(spl[u].son[0]) dfs(spl[u].son[0],u0);
	if(spl[u].son[1]) dfs(spl[u].son[1],u0);
}

int main()
{
	scanf("%d%d",&n,&q);
	for(int i=1; i<=n; i++) uf1[i] = uf2[i] = i;
	for(int i=1; i<=n; i++) a[i] = read(),spl[i].val = spl[i].sum = a[i];
	while(q--)
	{
		int opt; opt = read();
		if(opt==1)
		{
			int u,v; u = read(),v = read();
			int uu = findfa(0,u),vv = findfa(0,v);
			if(uu!=vv)
			{
				link(findfa(1,u),findfa(1,v));
				uf1[uu] = vv;
			}
			else
			{
				uu = findfa(1,u),vv = findfa(1,v);
				makeroot(uu); access(vv); splaynode(vv);
				spl[vv].val = spl[vv].sum;
				dfs(vv,vv);
				spl[vv].son[0] = 0;
			}
		}
		else if(opt==2)
		{
			int u,x; u = read(),x = read(); int delta = x-a[u]; a[u] = x;
			int uu = findfa(1,u); splaynode(uu);
			spl[uu].val += delta; spl[uu].sum += delta;
		}
		else if(opt==3)
		{
			int u,v; u = read(),v = read();
			int uu = findfa(1,u),vv = findfa(1,v);
			int uuu = findfa(0,uu),vvv = findfa(0,vv);
			if(uuu!=vvv) {puts("-1"); continue;}
			else
			{
				makeroot(uu); access(vv); splaynode(vv);
				printf("%d\n",spl[vv].sum);
			}
		}
	}
	return 0;
}