可撤销并查集

 解决在树上加边或删边后的两点联通性问题,线段树线段表示时间,结点存储这个时间段内存在的边,线段树使用区间修改,单点查询.查询时先把每个结点储存的边的两端利用并查集合并,离开时需要利用栈进行撤销.

#include<iostream>
#include<cstdio>
#include<cstring>
#include<map>
#include<vector>
#include<stack>
using namespace std;
typedef pair<int,int> pii;
int n,m;
int p[10010],rk[10010];
vector<pii>edge[200010*4];
struct Query
{
    int u,v,t;
    Query(int a=0,int b=0,int c=0):u(a),v(b),t(c){}
}q[200010];
struct node
{
    int a,b,c,d;
    node(int a1,int b1,int c1,int d1):a(a1),b(b1),c(c1),d(d1){}
};
stack<node>st;
map<pii,int>mp;
int ans[200010];
void add(int now,int l,int r,int x,int y,pii z)
{
    if(x<=l&&r<=y)
    {
        edge[now].push_back(z);
        return;
    }
    int mid=(l+r)>>1;
    if(y<=mid)
    add(now<<1,l,mid,x,y,z);
    else if(x>mid)
    add(now<<1|1,mid+1,r,x,y,z);
    else
    {
        add(now<<1,l,mid,x,y,z);
        add(now<<1|1,mid+1,r,x,y,z);
    }
}
int find(int x)
{return p[x]==x?x:find(p[x]);}
void undo()
{
    node tmp=st.top();st.pop();
    p[tmp.b]=tmp.b;
    rk[tmp.a]=tmp.c;
}
void query(int now,int l,int r)
{
    for(int i=0;i<edge[now].size();++i)
    {
       // cout<<edge[now][i].first<<' '<<edge[now][i].second<<endl;
        int x=find(edge[now][i].first),y=find(edge[now][i].second);
        if(rk[x]<rk[y])swap(x,y);
        st.push(node(x,y,rk[x],rk[y]));
        p[y]=x;
        if(rk[x]==rk[y])rk[x]++;
    }
    if(l==r)
    {
        int x=find(q[l].u),y=find(q[l].v);
        //   cout<<q[l][i].u<<' '<<q[l][i].v<<endl;
        if(x==y)
        ans[q[l].t]=1;
        else
        ans[q[l].t]=2;
        for(int i=0;i<edge[now].size();++i)undo();
        return;
    }
    int mid=(l+r)>>1;
    query(now<<1,l,mid);
    query(now<<1|1,mid+1,r);
    for(int i=0;i<edge[now].size();++i)undo();
}
int main()
{
   // freopen("1.txt","r",stdin);
    cin>>n>>m;
    for(int i=1;i<=n;++i)p[i]=i;
    for(int i=1;i<=m;++i)
    {
        char s[16];int x,y;
        scanf("%s%d%d",s,&x,&y);
        if(s[0]=='Q')
        {
            q[i]=Query(x,y,i);          
        }
        else if(s[0]=='C')
        {
            if(x>y)swap(x,y);
            pii tmp;tmp.first=x,tmp.second=y;
            if(mp.find(tmp)==mp.end())
            {
                mp.insert({tmp,i});
            }
        }
        else
        {
            if(x>y)swap(x,y);
            pii tmp;tmp.first=x,tmp.second=y;
            map<pii,int>::iterator it=mp.find(tmp);
            if(it==mp.end())
            continue;
           // cout<<1<<endl;
            add(1,1,m,it->second,i,tmp);
            mp.erase(it);
        }
    }
    for(map<pii,int>::iterator it=mp.begin();it!=mp.end();++it)
    add(1,1,m,it->second,m,it->first);
    query(1,1,m);
    for(int i=1;i<=m;++i)
    {
        if(ans[i]==1)
        printf("Yes\n");
        else if(ans[i]==2)
        printf("No\n");
    }
    return 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、付费专栏及课程。

余额充值