【学习笔记】可持久化并查集

已于 2022-03-01 22:10:04 修改
阅读量393 收藏
点赞数
分类专栏： 学习笔记 并查集 文章标签： 动态规划 算法 c++
于 2022-03-01 22:09:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/C2022lihan/article/details/123217491
版权

1.算法

用主席树维护 f a fa fa 和 d e p t h depth depth 数组，其他的和并查集只用按秩合并一模一样。

2.模板

#define ls (Tr[p].ch[0])
#define rs (Tr[p].ch[1])
#define fap (Tr[p].fa)
#define depthp (Tr[p].depth)
#define valp (Tr[p].val)
struct Node {
    int fa, depth, ch[2]; int val;
};
struct Persistent_Tree {
    int pool;
    Node Tr[Maxtree + 5];

    Persistent_Tree () { pool = 0; }
    int New_Node (int rt) {
        int p = ++pool;
        ls = Tr[rt].ch[0];
        rs = Tr[rt].ch[1];
        fap = Tr[rt].fa;
        depthp = Tr[rt].depth;
        valp = Tr[rt].val;
        return p;
    }
    int Build (int rt, int l, int r) {
        int p = New_Node (rt);
        if (l == r) {
            fap = l; depthp = 1; valp = val[l];
            return p;
        }
        int mid = (l + r) >> 1;
        ls = Build (Tr[rt].ch[0], l, mid);
        rs = Build (Tr[rt].ch[1], mid + 1, r);
        return p;
    }
    int Update (int rt, int l, int r, int Index, int x, int op) {
        int p = New_Node (rt);
        if (l == r) {
            if (op == 0) fap = x;
            else if (op == 1) depthp = x;
            else valp = x;
            return p;
        }
        int mid = (l + r) >> 1;
        if (Index <= mid) ls = Update (Tr[rt].ch[0], l, mid, Index, x, op);
        else rs = Update (Tr[rt].ch[1], mid + 1, r, Index, x, op);
        return p;
    }
    int Query (int p, int l, int r, int Index) {
        if (l == r)
            return p;
        int mid = (l + r) >> 1;
        if (Index <= mid) return Query (ls, l, mid, Index);
        else return Query (rs, mid + 1, r, Index);
    }
};
struct Persistent_Disjoint_Set_Union {
    int n, timestamp, Fuck;
    int Root[Maxtree + 5];
    Persistent_Tree Tree;

    void Init (int x) {
        n = x; timestamp = 0; Fuck = 0; Tree.pool = 0;
        Root[timestamp] = Tree.Build (0, 1, n);
    }
    int FindSet (int x) {
        int p = Tree.Query (Root[timestamp], 1, n, x);
        if (Tree.Tr[p].fa == x) return x;
        else return FindSet (Tree.Tr[p].fa);
    }
    int Query_Depth (int x) {
        int p = Tree.Query (Root[timestamp], 1, n, x);
        return Tree.Tr[p].depth;
    }
    int Update (int Now, int Index, int x, int op) {
        return Tree.Update (Root[Now], 1, n, Index, x, op);
    }
    int Query_Val (int Now, int Index) {
        int p = Tree.Query (Root[Now], 1, n, Index);
        return Tree.Tr[p].val;
    }
    void Make_Fa (int x, int y) {
        int dep = Max (Query_Depth (x) + 1, Query_Depth (y));
        ++Fuck; Root[Fuck] = Update (timestamp, x, y, 0); timestamp = Fuck;
        ++Fuck; Root[Fuck] = Update (timestamp, y, dep, 1); timestamp = Fuck;
        ++Fuck; Root[Fuck] = Update (timestamp, y, Min (Query_Val (timestamp, x), Query_Val (timestamp, y)), 2); timestamp = Fuck;
    }
    void UnionSet (int x, int y) {
        int u = FindSet (x), v = FindSet (y);
        if (u == v) return;
        if (Query_Depth (u) < Query_Depth (v)) Make_Fa (u, v);
        else Make_Fa (v, u);
    }
    bool Same_Set (int x, int y) {
        int u = FindSet (x), v = FindSet (y);
        if (u == v) return 1;
        else return 0;
    }
}DSU;
一、可持久化并查集

板子，只是注意回到 k k k 次操作指的是操作序列中的第 k k k 次操作，而且只是把 T a Ta Ta 的所有信息全部 c o p y copy copy 过来 （我因为这个调了一个下午， 吃柠檬）。

//author : LH ????Who just can eat S??t
//worship WJC ????Who can f??k tourist up and down and loves ?????
//worship YJX ????Who can f??k WJC up and down
#include <cmath>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib> 
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define fi first
#define se second
#define db double
//#define int long long
#define LL long long
#define ULL unsigned long long
#define PII pair <int, int>
#define MP(x,y) make_pair (x, y)
#define rep(i,j,k) for (int i = (j); i <= (k); ++i)
#define per(i,j,k) for (int i = (j); i >= (k); --i)

template <typename T> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }
template <typename T>
void read (T &x) {
    x = 0; T 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 ();
    }
    x *= f;
}
template <typename T, typename... Args>
void read (T &x, Args&... args) {
    read (x); read (args...);
}
char For_Print[25];
template <typename T>
void write (T x) {
    if (x == 0) { putchar ('0'); return; }
    if (x < 0) { putchar ('-'); x = -x; }
    int poi = 0;
    while (x) {
        For_Print[++poi] = x % 10 + '0';
        x /= 10;
    }
    while (poi) putchar (For_Print[poi--]);
}
template <typename T>
void print (T x, char ch) {
    write (x); putchar (ch);
}

const LL Mod = 1e9 + 7;

LL square (LL x) { return (x * x) % Mod; }
void DEL (LL &x, LL y) { ((x -= y) < 0) && (x += Mod); }
void ADD (LL &x, LL y) { ((x += y) >= Mod) && (x -= Mod); }

const int Maxtree = 5 * 1e7;

#define ls (Tr[p].ch[0])
#define rs (Tr[p].ch[1])
#define fap (Tr[p].fa)
#define depthp (Tr[p].depth)
struct Node {
    int fa, depth, ch[2];
};
struct Persistent_Tree {
    int pool;
    Node Tr[Maxtree + 5];

    Persistent_Tree () { pool = 0; }
    int New_Node (int rt) {
        int p = ++pool;
        ls = Tr[rt].ch[0];
        rs = Tr[rt].ch[1];
        fap = Tr[rt].fa;
        depthp = Tr[rt].depth;
        return p;
    }
    int Build (int rt, int l, int r) {
        int p = New_Node (rt);
        if (l == r) {
            fap = l; depthp = 1;
            return p;
        }
        int mid = (l + r) >> 1;
        ls = Build (Tr[rt].ch[0], l, mid);
        rs = Build (Tr[rt].ch[1], mid + 1, r);
        return p;
    }
    int Update (int rt, int l, int r, int Index, int x, int op) {
        int p = New_Node (rt);
        if (l == r) {
            if (!op) fap = x;
            else depthp = x;
            return p;
        }
        int mid = (l + r) >> 1;
        if (Index <= mid) ls = Update (Tr[rt].ch[0], l, mid, Index, x, op);
        else rs = Update (Tr[rt].ch[1], mid + 1, r, Index, x, op);
        return p;
    }
    int Query (int p, int l, int r, int Index) {
        if (l == r)
            return p;
        int mid = (l + r) >> 1;
        if (Index <= mid) return Query (ls, l, mid, Index);
        else return Query (rs, mid + 1, r, Index);
    }
};
struct Persistent_Disjoint_Set_Union {
    int n, timestamp, Fuck;
    int Root[Maxtree + 5];
    Persistent_Tree Tree;

    void Init (int x) {
        n = x; timestamp = 0; Fuck = 0;
        Root[timestamp] = Tree.Build (0, 1, n);
    }
    int FindSet (int x) {
        int p = Tree.Query (Root[timestamp], 1, n, x);
        if (Tree.Tr[p].fa == x) return x;
        else return FindSet (Tree.Tr[p].fa);
    }
    int Query_Depth (int x) {
        int p = Tree.Query (Root[timestamp], 1, n, x);
        return Tree.Tr[p].depth;
    }
    int Update (int Now, int Index, int x, int op) {
        return Tree.Update (Root[Now], 1, n, Index, x, op);
    }
    void Make_Fa (int x, int y) {
        int dep = Max (Query_Depth (x) + 1, Query_Depth (y));
        ++Fuck; Root[Fuck] = Update (timestamp, x, y, 0); timestamp = Fuck;
        ++Fuck; Root[Fuck] = Update (timestamp, y, dep, 1); timestamp = Fuck;
    }
    void UnionSet (int x, int y) {
        int u = FindSet (x), v = FindSet (y);
        if (u == v) return;
        if (Query_Depth (u) < Query_Depth (v)) Make_Fa (u, v);
        else Make_Fa (v, u);
    }
    bool Same_Set (int x, int y) {
        int u = FindSet (x), v = FindSet (y);
        if (u == v) return 1;
        else return 0;
    }
}DSU;

int n, m;
int timestamp[Maxtree + 5];

signed main () {
	// freopen ("D:\\lihan\\1.in", "r", stdin);
	// freopen ("D:\\lihan\\1.out", "w", stdout);

    read (n, m);
    DSU.Init (n); timestamp[0] = DSU.timestamp;
    rep (i, 1, m) {

        // printf ("step = %d\n", i);
        // rep (j, 1, n) {
        //     printf ("   fa[%d] = %d\n", j, DSU.FindSet (j));
        // }

        int op, x, y; read (op);
        if (op == 1) {
            read (x, y);
            DSU.UnionSet (x, y);
        }
        else if (op == 2) {
            read (x);
            DSU.timestamp = timestamp[x];
        }
        else {
            read (x, y);
            print (DSU.Same_Set (x, y), '\n');
        }
        timestamp[i] = DSU.timestamp;
    }
    return 0;
}
二、归程

这道题的思路基于一个简单的想法：如果一条边 ( x , y ) (x, y) (x,y) 没有积水，那么给这两个包含 x , y x, y x,y 的连通块之间连一条边，新联通块的所有的点，走到终点的代价都是联通块中到达终点最快的点的代价（即 x , y x, y x,y 连通块代价的最小值）。

那么暴力就是枚举所有的边，高于水线就加入，否则就不加。

很快就能想到优化，按照水线从大到小排序，那么要加的边一定是类似于 [ 1 , p ] [1, p] [1,p] 这样的左端点为 1 1 1 的区间，那么从一开始插入，询问就是第 p p p 个版本的并查集。

大常数人去死

//author : LH ????Who just can eat S??t
//worship WJC ????Who can f??k tourist up and down and loves ?????
//worship YJX ????Who can f??k WJC up and down
#include <cmath>
#include <queue>
#include <vector>
#include <cstdio>
#include <cstdlib> 
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define fi first
#define se second
#define db double
#define ULL unsigned long long
#define PII pair <int, int>
#define MP(x,y) make_pair (x, y)
#define rep(i,j,k) for (int i = (j); i <= (k); ++i)
#define per(i,j,k) for (int i = (j); i >= (k); --i)

template <typename T> T Max (T x, T y) { return x > y ? x : y; }
template <typename T> T Min (T x, T y) { return x < y ? x : y; }
template <typename T> T Abs (T x) { return x > 0 ? x : -x; }
template <typename T>
void read (T &x) {
    x = 0; T 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 ();
    }
    x *= f;
}
template <typename T, typename... Args>
void read (T &x, Args&... args) {
    read (x); read (args...);
}
char For_Print[25];
template <typename T>
void write (T x) {
    if (x == 0) { putchar ('0'); return; }
    if (x < 0) { putchar ('-'); x = -x; }
    int poi = 0;
    while (x) {
        For_Print[++poi] = x % 10 + '0';
        x /= 10;
    }
    while (poi) putchar (For_Print[poi--]);
}
template <typename T>
void print (T x, char ch) {
    write (x); putchar (ch);
}

const int Maxtree = 5 * 1e7;
const int Maxn = 5 * 1e5;

int t, n, m;

struct edge {
    int x, y, l, h;
}e[Maxn + 5];
bool cmp (edge x, edge y) {
    return x.h > y.h;
}
vector <edge> g[Maxn + 5];
void add (int x, int y, int l, int h) {
    g[x].push_back ({0, y, l, h});
}

int dist[Maxn + 5];
bool vis[Maxn + 5];
void Dijkstra () {
    memset (vis, 0, sizeof vis);
    memset (dist, 0x3f, sizeof dist); dist[1] = 0;
    priority_queue <PII, vector <PII>, greater <PII> > p; p.push (MP (0, 1));
    while (p.size ()) {
        PII tmp = p.top (); p.pop ();
        int u = tmp.se;
        if (vis[u]) continue; vis[u] = 1;
        for (auto i : g[u]) {
            int v = i.y, l = i.l;
            if (vis[v]) continue;
            if (dist[v] > dist[u] + l) {
                dist[v] = dist[u] + l;
                p.push (MP (dist[v], v));
            }
        }
    }
}

#define ls (Tr[p].ch[0])
#define rs (Tr[p].ch[1])
#define fap (Tr[p].fa)
#define depthp (Tr[p].depth)
#define distp (Tr[p].dist)
struct Node {
    int fa, depth, ch[2]; int dist;
};
struct Persistent_Tree {
    int pool;
    Node Tr[Maxtree + 5];

    Persistent_Tree () { pool = 0; }
    int New_Node (int rt) {
        int p = ++pool;
        ls = Tr[rt].ch[0];
        rs = Tr[rt].ch[1];
        fap = Tr[rt].fa;
        depthp = Tr[rt].depth;
        distp = Tr[rt].dist;
        return p;
    }
    int Build (int rt, int l, int r) {
        int p = New_Node (rt);
        if (l == r) {
            fap = l; depthp = 1; distp = dist[l];
            return p;
        }
        int mid = (l + r) >> 1;
        ls = Build (Tr[rt].ch[0], l, mid);
        rs = Build (Tr[rt].ch[1], mid + 1, r);
        return p;
    }
    int Update (int rt, int l, int r, int Index, int x, int op) {
        int p = New_Node (rt);
        if (l == r) {
            if (op == 0) fap = x;
            else if (op == 1) depthp = x;
            else distp = x;
            return p;
        }
        int mid = (l + r) >> 1;
        if (Index <= mid) ls = Update (Tr[rt].ch[0], l, mid, Index, x, op);
        else rs = Update (Tr[rt].ch[1], mid + 1, r, Index, x, op);
        return p;
    }
    int Query (int p, int l, int r, int Index) {
        if (l == r)
            return p;
        int mid = (l + r) >> 1;
        if (Index <= mid) return Query (ls, l, mid, Index);
        else return Query (rs, mid + 1, r, Index);
    }
};
struct Persistent_Disjoint_Set_Union {
    int n, timestamp, Fuck;
    int Root[Maxtree + 5];
    Persistent_Tree Tree;

    void Init (int x) {
        n = x; timestamp = 0; Fuck = 0; Tree.pool = 0;
        Root[timestamp] = Tree.Build (0, 1, n);
    }
    int FindSet (int x) {
        int p = Tree.Query (Root[timestamp], 1, n, x);
        if (Tree.Tr[p].fa == x) return x;
        else return FindSet (Tree.Tr[p].fa);
    }
    int Query_Depth (int x) {
        int p = Tree.Query (Root[timestamp], 1, n, x);
        return Tree.Tr[p].depth;
    }
    int Update (int Now, int Index, int x, int op) {
        return Tree.Update (Root[Now], 1, n, Index, x, op);
    }
    int Query_Dist (int Now, int Index) {
        int p = Tree.Query (Root[Now], 1, n, Index);
        return Tree.Tr[p].dist;
    }
    void Make_Fa (int x, int y) {
        int dep = Max (Query_Depth (x) + 1, Query_Depth (y));
        ++Fuck; Root[Fuck] = Update (timestamp, x, y, 0); timestamp = Fuck;
        ++Fuck; Root[Fuck] = Update (timestamp, y, dep, 1); timestamp = Fuck;
        ++Fuck; Root[Fuck] = Update (timestamp, y, Min (Query_Dist (timestamp, x), Query_Dist (timestamp, y)), 2); timestamp = Fuck;
    }
    void UnionSet (int x, int y) {
        int u = FindSet (x), v = FindSet (y);
        if (u == v) return;
        if (Query_Depth (u) < Query_Depth (v)) Make_Fa (u, v);
        else Make_Fa (v, u);
    }
    bool Same_Set (int x, int y) {
        int u = FindSet (x), v = FindSet (y);
        if (u == v) return 1;
        else return 0;
    }
}DSU;

int q, k, s;
int timestamp[Maxn + 5];

signed main () {
	freopen ("return.in", "r", stdin);
	freopen ("return.out", "w", stdout);

    read (t);
    while (t--) {
        read (n, m);

        rep (i, 1, n) g[i].clear ();

        DSU.Init (n);
        rep (i, 1, m) {
            read (e[i].x, e[i].y, e[i].l, e[i].h);
            add (e[i].x, e[i].y, e[i].l, e[i].h); add (e[i].y, e[i].x, e[i].l, e[i].h);
        }
        sort (e + 1, e + 1 + m, cmp);
        Dijkstra ();
        DSU.Init (n);
        rep (i, 1, m) {
            // printf ("step = %d\n", i);
            // rep (j, 1, n) {
            //     printf (" dist[%d] = %intd\n", j, DSU.Query_Dist (DSU.timestamp, j));
            // }
            DSU.UnionSet (e[i].x, e[i].y);
            timestamp[i] = DSU.timestamp;
        }

        read (q, k, s);
        int lastans = 0;
        rep (i, 1, q) {
            int bgn, lne; read (bgn, lne);
            bgn = (bgn + k * lastans - 1) % n + 1;
            lne = (lne + k * lastans) % (s + 1);
            int l = 0, r = m + 1;
            while (l + 1 < r) {
                int mid = (l + r) >> 1;
                if (e[mid].h > lne) l = mid;
                else r = mid;
            }
            DSU.timestamp = timestamp[l];
            print ((lastans = DSU.Query_Dist (timestamp[l], DSU.FindSet (bgn))), '\n');
        }
    }
    return 0;
}
IDSY QAQ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redis学习笔记—Redis持久化机制
01-07
2）快照是默认的持久化方式，这种方式就是将内存中数据以快照的方式写入到二进制文件中，在我们redis底层默认存储的的文件名为 dump.rdb。 3) 优点： 快照保存数据极快，还原数据快。 适用于灾难备份 4) 缺点:
可持久化并查集
qq_45832461的博客
10-01 1661
可持久化并查集 题目描述 洛谷P3402 可持久化并查集 核心思路 可持久化并查集是建立在可持久化数组上的，在学习可持久化并查集之前，需要先学习主席树(可持久化权值线段树)，权值线段树，可持久化线段树，移步可持久化线段树1和可持久化线段树2 可持久化并查集=可持久化+并查集=可持久化数组+并查集=主席树+并查集 并查集有两种优化方式： 路径压缩 按秩合并 由于需要我们支持的只有集合的合并、查询操作，当我们需要将两个集合合二为一时，无论将哪一个集合连接到另一个集合的下面，都能得到正确的结果。但不同的连
可持久化并查集、带删并查集
cheng__yu_的博客
09-29 776
可持久化并查集P3402 可持久化并查集 P3402 可持久化并查集 链接：https://www.luogu.com.cn/problem/P3402 题意：给定 n 个集合，第 i 个集合内初始状态下只有一个数，为 i。有 m 次操作。操作分为 3 种： 1 a b 合并 a,b 所在集合 2 k 回到第 k 次操作（执行三种操作中的任意一种都记为一次操作）之后的状态 3 a b 询问 a,b 是否属于同一集合，如果是则输出 1 ，否则输出 0 思路：可持久化并查集 #include &
可持久化4--可持久化并查集
qq_35975367的博客
08-04 280
可持久化并查集 可持久化并查集 = 按秩合并并查集 + 可持久化数组 首先并查集不能采用路径压缩，这是因为一次findR操作中，fa数组的很多位置（u->ru）会发生修改，由于每次修改都需要在可持久化数组上复制产生log个新结点，空间复杂度过大。我们不希望每个版本的fa数组的差别太大，最好只有常数个位置改变。 启发式合并/按秩合并 当 merge(u,v) 时，找到ru,rv后，让 sz 小的接在sz大的下面： if(sz[ru] > sz[rv]) swap(ru,rv); fa[ru] =
学习笔记之什么是持久化和对象关系映射ORM技术
11-22
学习笔记之什么是持久化和对象关系映射ORM技术，什么是所谓的持久化，什么是ORM
php页面静态化学习笔记.doc
11-29
php页面静态化学习笔记.doc
虚拟化的学习笔记
08-14
虚拟化的学习笔记，概括了虚拟化的架构，适合对基础知识加深理解
【模板】可持久化并查集
weixin_30455067的博客
05-26 115
原题链接 #include<bits/stdc++.h> using namespace std; typedef long long LL; #define mid ((l+r)>>1) const int INF=1e9+7,MAXNODE=24e6+7,MAXN=1e6+7; int N,M,tmp[MAXN],rt[MAXN]; int fa[...
可持久化并查集（知识整理+板子总结）
Code92007的博客
05-12 1069
概念 学了可持续化数组之后，趁热打铁拿下可持久化并查集 理解之后就大致是当抄板子用，毕竟手敲还要敲很久 不得不承认，此生不如NOI爷，只愿自己能做一个努力种技能树的ACMer 可持久化并查集=可持久化数组+叶子结点维护并查集par[]关系和dep[]关系+并查集合并 dep[rt]是从rt这个节点往下搜的最大链长，其实也就是以rt为树根的树的最深的叶子的深度 dep[]数组...
P3402 可持久化并查集
羊驼的博客
02-14 256
题目链接：点击这里 题目大意： 给定 nnn 个集合，第 iii 个集合内初始状态下只有一个数，为 iii。 有 mmm 次操作。操作分为 333 种： 1 a b1\ a\ b1 a b 合并 a,ba,ba,b 所在集合； 2 k2\ k2 k 回到第 kkk 次操作（执行三种操作中的任意一种都记为一次操作）之后的状态； 3 a b3\ a\ b3 a b 询问 a,ba,ba,b 是否属于同一集合，如果
可持久化并查集加强版
cy41的博客
09-15 206
题意：中文 题目链接：AcWing270. 可持久化并查集加强版 前置知识：可持久化数组，主席树。 每个版本用一个线段树来维护节点的父亲是谁，该联通块的节点数量，线段树只有叶子节点有意义，其余都是无意义的。 最开始的时候，所有节点的父亲都是自己，每个联通块的秩都为1。 按主席树那样用root来表示第k个版本对应的线段树。 对于合并操作，按秩合并，将秩较小的合并到大的上面，相当于两次更新，第一次将x...
可持久化并查集（草稿）
weixin_30855099的博客
09-14 56
#include<bits/stdc++.h> #define fi first #define se second #define INF 0x3f3f3f3f #define LNF 0x3f3f3f3f3f3f3f3f #define fio ios::sync_with_stdio(false);cin.tie(0);cout.tie(0) #defi...
[BZOJ3674]可持久化并查集加强版
weixin_34128839的博客
02-27 100
[BZOJ3674]可持久化并查集加强版 ★★★ 输入文件：bzoj_3974.in 输出文件：bzoj_3974.out简单对比时间限制：3 s 内存限制：256 MB DescriptionDescription： 自从zkysb出了可持久化并查集后…… hzwer:乱写能AC，暴力踩标程 KuribohG：我不路径压缩就过了！ ndsf：暴力就可以轻松虐！...
BZOJ 3673 可持久化并查集 by zky 可持久化并查集
世界
10-20 2158
题目大意：给定n个集合，提供三种操作： 1.合并a,b所在集合 2.回到第k次操作之后的状态 3.询问a,b是否在同一集合 可持久化并查集0.0 实现方式是用可持久化线段树实现可持久化数组维护可持久化并查集。。。 至于可持久化数组，每条路径上只有叶节点的位置的num域是有意义的，感觉无比浪费0.0 可是不这样还真没法维护0.0 合并时本来应该按照每个节点的深度之和维护，结果手残懒得写，
【学习笔记】可持久化并查集（BZOJ3673）
最新发布
05-22
可持久化并查集是指在并查集基础上，新增了时间维度，即支持查询历史版本的并查集信息。 主要应用场景是需要记录数据变化历史的问题，比如线段树合并、动态图连通性等。 以下是实现可持久化并查集的基本思路： 1....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值