可撤销并查集模板

CF891C Envy

#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#define inf 0x7fffffff
#define ll long long
//#define int long long
//#define double long double
#define re int
#define void inline void
#define eps 1e-5
//#define mod 1e9+7
//#define ls(p) p<<1
//#define rs(p) p<<1|1
//#define pi acos(-1.0)
#define pb push_back
#define P pair < int , int >
#define mk make_pair
#define fi first
#define se second
//#define unordered_map map
//#define __int128 long long
using namespace std;
using namespace __gnu_pbds;
const int M=1e5+5;
const int mod=1e9+7;
const int N=2e6+5;
vector < P > ee[N],q[N];
pair < P , int > e[N];
int ans[N];
int n,m;
namespace DSU
{
	int fa[N],rk[N];
	void init(int n){for(re i=1;i<=n;i++)  rk[i]=1,fa[i]=i;}
	int get(int x){return x==fa[x]?x:get(fa[x]);}
	void merge(int x,int y)
	{
		if(rk[x]==rk[y])  rk[x]++;
		if(rk[x]<rk[y])  swap(x,y);
		fa[y]=x;
	}
}
void undo(int w,int l,int r)
{
	int id=q[w][l].fi;
	vector < pair < P , P > > st;
	for(re i=l;i<r;i++)
	{
		int x=q[w][i].se;
		int u=e[x].fi.fi,v=e[x].fi.se;
		int fx=DSU::get(u),fy=DSU::get(v);
		if(fx==fy)  ans[id]=1;
		else
		{
			if(DSU::rk[fx]<DSU::rk[fy])  swap(fx,fy);
			st.pb(mk(mk(fy,DSU::fa[fy]),mk(fx,DSU::fa[fx])));
			if(DSU::rk[fx]==DSU::rk[fy])  DSU::rk[fx]++;
			DSU::fa[fy]=fx;
		}
	}
	for(re i=st.size()-1;i>=0;i--)
	{
		DSU::fa[st[i].fi.fi]=st[i].fi.se;
		DSU::rk[st[i].se.fi]=st[i].se.se;
	}
}
void solve()
{
	int Q;
	cin>>n>>m;
	DSU::init(n);
	for(re i=1;i<=m;i++)
	{
		int x,y,z;
		scanf("%d%d%d",&x,&y,&z);
		e[i]=mk(mk(x,y),z);
		ee[z].pb(mk(x,y));
	}
	cin>>Q;
	for(re i=1;i<=Q;i++)
	{
		int k;
		scanf("%d",&k);
		for(re j=1;j<=k;j++)
		{
			int x;
			scanf("%d",&x);
			q[e[x].se].pb(mk(i,x));
		}
	}
	for(re w=1;w<=505050;w++)
	{
		for(re l=0,r;l<q[w].size();l=r)
		{
			for(r=l;r<q[w].size()&&q[w][l].fi==q[w][r].fi;r++);
			undo(w,l,r); 
		}
		for(re i=0;i<ee[w].size();i++)
		{
			int x=ee[w][i].fi;
			int y=ee[w][i].se;
			int fx=DSU::get(x),fy=DSU::get(y);
			if(fx!=fy)  DSU::merge(fx,fy);
		}
	}
	for(re i=1;i<=Q;i++)  puts(ans[i]?"NO":"YES");
}
signed main()
{
//	fflush(stdout);
//	srand(102321547);
//	freopen("D.in", "r", stdin);
//	freopen("Dout.txt", "w", stdout);
//	freopen("9.out", "w", stdout);
    int T=1;
//    cin>>T;
    for(re index=1;index<=T;index++)
    {
//        printf("Case #%d:\n",index);
        solve();
//        puts("");
    }
    return 0;
}
/*



*/
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
可持久化并查集是指在并查集的基础上,支持回退到任意历史版本。这个结构可以用来处理一些需要撤销或者回退操作的问题。以下是一个基本的可持久化并查集的实现。 ```python class Node: def __init__(self, parent=None, rank=0): self.parent = parent self.rank = rank class PersistentUnionFind: def __init__(self, size): self.n = size self.roots = [None] * (2 * size) self.ranks = [None] * (2 * size) def make_set(self, v): self.roots[v] = Node(v) self.ranks[v] = 0 def find(self, node, version): if node.parent is None: return node if node.parent != node: node.parent = self.find(node.parent, version) return node.parent def union(self, x, y, version): x_root = self.find(self.roots[x], version) y_root = self.find(self.roots[y], version) if x_root == y_root: return False if self.ranks[x_root] < self.ranks[y_root]: x_root, y_root = y_root, x_root new_root = Node(x_root, self.ranks[x_root] + (self.ranks[x_root] == self.ranks[y_root])) self.roots[x] = self.roots[y] = new_root self.ranks[x_root] = self.ranks[y_root] = new_root.rank return True def get_version(self): return len(self.roots) // self.n - 1 def get_root(self, v, version): return self.find(self.roots[v], version).parent.val ``` 这个代码中,我们使用了一个 `Node` 类来表示每个节点,其中 `parent` 表示节点的父亲,`rank` 表示节点的秩。我们需要用一个 `roots` 数组来保存所有版本的根节点,以及一个 `ranks` 数组来保存所有节点的秩。`make_set` 函数用来初始化一个新节点,这个节点的父亲指向自己,秩为 0。`find` 函数用来找到节点所在的集合的根节点。如果节点的父亲不是根节点,那么我们就递归地寻找它的父亲。在递归返回之前,我们将所有遍历过的节点的父亲都更新为根节点,这样可以加速下次查找。`union` 函数用来将两个节点所在的集合合并。首先找到两个节点所在集合的根节点,如果根节点相同,那么这两个节点已经在同一个集合中,不需要再次合并。否则,我们将秩较小的根节点挂在秩较大的根节点下面,同时更新秩。`get_version` 函数用来获取当前版本号,而 `get_root` 函数则用来获取节点在指定版本中所在的集合的根节点。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值