HDU 5333 Undirected Graph（动态树）

题意

给定一棵 \(n\) 个节点， \(m\) 条边的无向图，每个点有点权，有 \(q\) 个询问，每次询问若删去存在一个节点权值在 \([L,R]\) 范围外的边，剩下的图构成了多少个连通块（询问间相互独立）。

\(1\leq n,q \leq 10^5\)

\(1\leq m \leq 2\times 10^5\)

思路

题目意思在简化一下，就是求连接两个点权在 \([L,R]\) 中的边和原图中的所有节点构成的连通块数。

对于两维的询问，在没有强制在线的情况下，可以考虑离线消维。我们把询问按右端点升序排列，将边按照连接两点点权最大值排列，一条一条的往图中添加，加到值为 \(p\) 的边时，我们需回答 \(R\) 小于等于 \(p\) 的询问。

这样加的边满足了 \(R\) 的要求，接下来仅需考虑 \(L\) ，我们令边权为连接两点权值的最小值，显然如果增加了一条权较大的边并形成了环，那么环中较小的边便没有意义了（因为权较大的边可以影响更多的询问）。那么只需要用 \(\text{LCT}\) 维护一个最大生成树（下有讲解）即可。

继续分析，如果我们加入了一条权为 \(p\) 的边，不难发现 \(L\) 值在 \([1,p]\) 范围内的答案都会减少 \(1\)（连通块个数少 \(1\) ）；反过来，如果断开了一条权为 \(p\) 的边，\(L\) 值在 \([1,p]\) 的答案都会增加 \(1\) 。那在维护最大生成树的过程中，实时记录每个 \(L\) 的答案即可，我选择用树状数组进行区间修改，单点查询。

\(\text{LCT}\) 用来维护边权，最好写的写法就是直接把边当作一个点塞进 \(\text{LCT}\) 里，这个点的点权就是边权。在此基础上，用 \(\text{LCT}\) 维护最小/大生成树，只需要在连接边 \((u,v)\) 时询问目前的路径 \((u,v)\) 的最大/小值，以及对应的边的位置，如果可以替换，就断开那条边，并连接 \((u,v)\)。

代码

#include<bits/stdc++.h>
#define FOR(i,x,y) for(int i=(x),i##END=(y);i<=i##END;++i)
#define DOR(i,x,y) for(int i=(x),i##END=(y);i>=i##END;--i)
template<typename T,typename _T>inline bool chk_min(T &x,const _T y){return y<x?x=y,1:0;}
template<typename T,typename _T>inline bool chk_max(T &x,const _T y){return x<y?x=y,1:0;}
typedef long long ll;
const int N=1e5+5,M=2e5+5;
template<const int maxn,const int maxm,typename T>struct Linked_list
{
	int head[maxn],nxt[maxm],tot;T to[maxm];
	Linked_list(){clear();}
	T &operator [](const int x){return to[x];}
	void clear(){memset(head,-1,sizeof(head)),tot=0;}
	void add(int u,T v){to[tot]=v,nxt[tot]=head[u],head[u]=tot++;}
	#define EOR(i,G,u) for(int i=G.head[u];~i;i=G.nxt[i])
};
struct FenwickTree
{
	#define lowbit(x) ((x)&-(x))
	int c[N],n;
	void init(int _n){n=_n;FOR(i,0,n)c[i]=0;}
	void update(int k,int val){for(;k<=n;k+=lowbit(k))c[k]+=val;}
	int query(int k){int res=0;for(;k>0;k^=lowbit(k))res+=c[k];return res;}
	void update(int l,int r,int val){update(l,val),update(r+1,-val);}
	#undef lowbit
};
struct Query
{
	int id,l,r;
	bool operator <(const Query &_)const{return r<_.r;}
};
struct node
{
	int x,y;
	node(int _x=0,int _y=0){x=_x,y=_y;}
	bool operator <(const node &_)const{return y<_.y;}
};
struct LinkCutTree
{
	int ch[N+M][2],fa[N+M];node pw[N+M],Mi[N+M];
	int stk[N+M],tp;
	bool rev[N+M];
	void init(){create(0,node(1e9,1e9));}
	void create(int x,node val){ch[x][0]=ch[x][1]=fa[x]=rev[x]=0;pw[x]=Mi[x]=val;}
	bool isroot(int x){return x!=ch[fa[x]][0]&&x!=ch[fa[x]][1];}
	void reved(int x)
	{
		std::swap(ch[x][0],ch[x][1]);
		rev[x]^=1;
	}
	void push_up(int x)
	{
		Mi[x]=std::min(std::min(Mi[ch[x][0]],Mi[ch[x][1]]),pw[x]);
	}
	void push_down(int x)
	{
		if(rev[x])
		{
			if(ch[x][0])reved(ch[x][0]);
			if(ch[x][1])reved(ch[x][1]);
			rev[x]=0;
		}
	}
	void rotate(int x)
	{
		int y=fa[x],z=fa[y],k=(x==ch[y][1]);
		if(!isroot(y))ch[z][y==ch[z][1]]=x; fa[x]=z;
		ch[y][k]=ch[x][!k]; if(ch[x][!k])fa[ch[x][!k]]=y;
		ch[x][!k]=y,fa[y]=x;
		push_up(y),push_up(x);
	}
	void splay(int x)
	{
		stk[tp=1]=x;
		for(int y=x;!isroot(y);y=fa[y])stk[++tp]=fa[y];
		while(tp)push_down(stk[tp]),tp--;
		while(!isroot(x))
		{
			int y=fa[x],z=fa[y];
			if(!isroot(y))(x==ch[y][1])==(y==ch[z][1])?rotate(y):rotate(x);
			rotate(x);
		}
	}
	void access(int x)
	{
		for(int y=0;x;y=x,x=fa[x])
			splay(x),ch[x][1]=y,push_up(x);
	}
	void make_root(int x)
	{
		access(x),splay(x),reved(x);
	}
	int get_root(int x)
	{
		access(x),splay(x);
		while(ch[x][0])push_down(x),x=ch[x][0];
		splay(x);
		return x;
	}
	bool link(int x,int y)
	{
		make_root(x);
		if(get_root(y)==x)return false;
		fa[x]=y;
		return true;
	}
	bool cut(int x,int y)
	{
		make_root(x);
		if(get_root(y)!=x||ch[x][1]!=y||ch[y][0])return false;
		ch[x][1]=fa[y]=0;
		push_up(x);
		return true;
	}
	bool lift(int x,int y)
	{
		make_root(x);
		return get_root(y)==x;
	}
	node query(int x,int y)
	{
		lift(x,y);
		return Mi[x];
	}
};
Linked_list<N,M,int>G;
LinkCutTree LCT;
FenwickTree FT;
Query qry[N];int otp[N];
int U[N+M],V[N+M],cur;
int n,m,q;

int main()
{
	LCT.init();
	while(~scanf("%d%d%d",&n,&m,&q))
	{
		G.clear();FT.init(n);cur=n;
		FT.update(1,n,n);
		FOR(i,1,n)LCT.create(i,node(1e9,1e9));
		FOR(i,1,m)
		{
			int u,v;
			scanf("%d%d",&u,&v);
			if(u>v)std::swap(u,v);
			G.add(v,u);
		}
		FOR(i,1,q)scanf("%d%d",&qry[i].l,&qry[i].r),qry[i].id=i;
		std::sort(qry+1,qry+q+1);
		int j=1;
		FOR(i,1,n)
		{
			EOR(k,G,i)
			{
				int l=G[k];bool flg=0;
				if(!LCT.lift(i,l))flg=1;
				else
				{
					node tmp=LCT.query(i,l);
					if(tmp.y<l)
					{
						LCT.cut(tmp.x,U[tmp.x]),LCT.cut(tmp.x,V[tmp.x]);
						FT.update(1,tmp.y,1);
						flg=1;
					}
				}
				if(flg)
				{
					cur++;
					LCT.create(cur,node(cur,l));
					U[cur]=i,V[cur]=l;
					LCT.link(cur,i),LCT.link(cur,l);
					FT.update(1,l,-1);
				}
			}
			while(j<=q&&qry[j].r<=i)
			{
				otp[qry[j].id]=FT.query(qry[j].l);
				j++;
			}
		}
		FOR(i,1,q)printf("%d\n",otp[i]);
	}
	return 0;
}