【模板】可持久化并查集

传送门

Solution

路径压缩的话,修改过于频繁,反而TLE掉
只要按秩合并就行了
其实就是可持久化数组?维护fa[i]dep[i]


Code 

bzoj 3673 可持久化并查集 by zky

#include<bits/stdc++.h>
#define ll long long
#define max(a,b) ((a)>(b)?(a):(b))
#define min(a,b) ((a)<(b)?(a):(b))
inline int read()
{
    int x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return x*f;
}
#define MN 100005
#define MM 3000005 
int n,m,fa[MM],dep[MM],rt[MN];
int sz,ls[MM],rs[MM];
#define mid ((l+r)>>1)
void Build(int &x,int l,int r)
{
    x=++sz;if(l==r)return (void)(fa[x]=l);
    Build(ls[x],l,mid);Build(rs[x],mid+1,r);
}
void Merge(int &x,int ori,int l,int r,int p,int f)
{
    x=++sz;ls[x]=ls[ori];rs[x]=rs[ori];
    if(l==r) return (void)(fa[x]=f,dep[x]=dep[ori]);
    p<=mid?Merge(ls[x],ls[ori],l,mid,p,f):Merge(rs[x],rs[ori],mid+1,r,p,f);
}
void update(int x,int l,int r,int p)
{
    if(l==r) return (void)(dep[x]++);
    p<=mid?update(ls[x],l,mid,p):update(rs[x],mid+1,r,p); 
}
int Query(int x,int l,int r,int p)
{
    if(l==r) return x;
    return p<=mid?Query(ls[x],l,mid,p):Query(rs[x],mid+1,r,p);
}
int getf(int x,int p)
{
    register int tmp=Query(x,1,n,p);
    return fa[tmp]==p?tmp:getf(x,fa[tmp]);
}
int main()
{
    register int i,opt,x,y;
    n=read();m=read();
    Build(rt[0],1,n);
    for(i=1;i<=m;++i)
    {
        opt=read();x=read();
        if(opt==1)
        {
            y=read();rt[i]=rt[i-1];
            x=getf(rt[i],x);y=getf(rt[i],y);
            if(fa[x]!=fa[y])
            {
                if(dep[x]>dep[y]) std::swap(x,y);
                Merge(rt[i],rt[i-1],1,n,fa[x],fa[y]);
                if(dep[x]==dep[y]) update(rt[i],1,n,fa[y]);
            }
        }
        else if(opt==2) rt[i]=rt[x];
        else if(opt==3)
        {
            y=read();rt[i]=rt[i-1];
            x=getf(rt[i],x),y=getf(rt[i],y);
            puts(fa[x]==fa[y]?"1":"0");
        }
    }
    return 0;
}



Blog来自PaperCloud,未经允许,请勿转载,TKS!

转载于:https://www.cnblogs.com/PaperCloud/p/10161239.html

### 可持久化并查集的实现 可持久化并查集是一种支持历史版本查询的并查集数据结构。它允许我们在任意时刻回溯到某个特定的历史状态,并在此基础上继续操作。以下是其基本原理和两种语言(C++ 和 Python)中的实现。 #### 基本原理 传统的并查集通过路径压缩优化,能够高效地完成查找与合并操作。然而,传统并查集不支持撤销或恢复到之前的某一状态。为了实现可持久化的特性,可以通过记录每次修改的操作日志或者利用树状数组/线段树等辅助数据结构来保存父节点的变化过程[^1]。 --- ### C++ 实现 在 C++ 中,我们通常借助向量 `vector` 来模拟动态数组的行为,用于存储每个版本的状态变化。下面是一个简单的可持久化并查集模板: ```cpp #include <bits/stdc++.h> using namespace std; struct PersistentUnionFind { struct Node { int parent; vector<int> history; // 记录parent随时间的变化 Node() : parent(-1), history({-1}) {} }; vector<Node> nodes; int version_count = 0; PersistentUnionFind(int n) : nodes(n + 1) {} // 查找根节点以及对应的版本号 pair<int, int> find_root_with_version(int u, int current_version) const { while (u >= 0 && current_version >= nodes[u].history.size()) { --current_version; } if (nodes[u].parent == -1 || current_version < nodes[u].history.size()) { return {u, current_version}; } else { return find_root_with_version(nodes[u].parent, current_version); } } void unite(int u, int v) { auto [root_u, ver_u] = find_root_with_version(u, version_count); auto [root_v, ver_v] = find_root_with_version(v, version_count); if (root_u != root_v) { ++version_count; if (-nodes[root_u].parent > -nodes[root_v].parent) { nodes[root_v].parent = root_u; nodes[root_v].history.push_back(version_count); // 更新v的父亲为u } else { nodes[root_u].parent = root_v; nodes[root_u].history.push_back(version_count); // 更新u的父亲为v } } } bool same_set(int u, int v, int query_version) const { auto [root_u, _] = find_root_with_version(u, query_version); auto [root_v, __] = find_root_with_version(v, query_version); return root_u == root_v; } }; int main() { int n = 5; // 初始化大小 PersistentUnionFind uf(n); uf.unite(1, 2); uf.unite(3, 4); uf.unite(2, 3); cout << (uf.same_set(1, 4, 3) ? "Yes" : "No") << endl; // 输出 Yes } ``` 此代码实现了带有版本控制功能的并查集,其中 `unite` 方法会更新两个集合的关系,而 `same_set` 则可以在给定的时间点检查两元素是否属于同一集合[^1]。 --- ### Python 实现 Python 的字典非常适合用来构建稀疏映射关系,因此我们可以用字典代替 C++ 中的静态数组。下面是 Python 版本的可持久化并查集实现: ```python class PersistentUnionFind: class Node: def __init__(self): self.parent = None self.rank = 0 self.history = [] # 存储历史更改 def __init__(self, size): self.nodes = [self.Node() for _ in range(size)] self.version = 0 def find(self, x, target_version=None): node = self.nodes[x] versions_to_check = list(range(len(node.history))) if not target_version else [target_version] for idx in reversed(versions_to_check): # 回退至最近的有效版本 p = node.history[idx][1] if idx < len(node.history) and node.history[idx][0] <= target_version else node.parent if p is None or (target_version is not None and idx < len(node.history)): break x = p node = self.nodes[p] return x def union(self, x, y): root_x = self.find(x) root_y = self.find(y) if root_x != root_y: rank_x = self.nodes[root_x].rank rank_y = self.nodes[root_y].rank if rank_x > rank_y: self.nodes[root_y].parent = root_x self.nodes[root_y].history.append((self.version, root_x)) elif rank_x < rank_y: self.nodes[root_x].parent = root_y self.nodes[root_x].history.append((self.version, root_y)) else: self.nodes[root_y].parent = root_x self.nodes[root_y].history.append((self.version, root_x)) self.nodes[root_x].rank += 1 self.version += 1 def connected(self, x, y, at_time=None): return self.find(x, at_time) == self.find(y, at_time) # 测试代码 if __name__ == "__main__": N = 5 uf = PersistentUnionFind(N) uf.union(1, 2) uf.union(3, 4) uf.union(2, 3) print("Are 1 and 4 connected?", uf.connected(1, 4)) # True print("Were 1 and 4 connected before last operation?", uf.connected(1, 4, uf.version - 1)) # False ``` 在这个实现中,`union` 函数负责连接两个子集,同时维护历史记录;`find` 函数则可以根据指定的时间戳返回对应版本的结果[^1]。 --- ### 总结 以上展示了如何分别用 C++ 和 Python 构建可持久化并查集的方法。这两种实现都依赖于额外的空间开销以追踪每一次变动的历史信息,从而能够在不同时间点上执行查询操作。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值