P3690 【模板】Link Cut Tree （动态树lct）

最新推荐文章于 2021-12-07 22:33:24 发布
最新推荐文章于 2021-12-07 22:33:24 发布
阅读量166 收藏
点赞数
分类专栏： 板子 洛谷
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Yubing792289314/article/details/108685397
版权

学习资源

https://www.cnblogs.com/flashhu/p/8324551.html

中序遍历Splay得到的每个点的深度序列严格递增

时间复杂度 O ( ( n + m ) log ⁡ n ) O((n+m)\log n) O((n+m)logn)

那些年我用lct做过的题目：

数组版代码

namespace LCT { // lct板子
    const ll mod = 51061;
    ll sum[N];
    ll w[N];// w[x]表示x的点权

	int h[N];// 缩点后x所在的点 类似 并查集里的father[]

    int sz[N];//sz[x] 表示以x为根的splay树的大小
    int rev[N];//rev为区间翻转懒标记数组
    int f[N];// 父节点
    int st[N];//栈
    int c[N][2];// 每个节点的两个儿子

    // 判断节点x是否为一个splay的根 如果不是根 返回true
    inline bool nRoot(register int x) {
        // 如果节点x是根 则其与其父亲节点之间连的是轻边
        // 如果连的是轻边 他的父亲的儿子里没有它
        return c[f[x]][0] == x || c[f[x]][1] == x;
    }

#define lc c[x][0]
#define rc c[x][1]

    // splay区间翻转操作
    inline void reverse(register int x) {
        swap(lc, rc);
        rev[x] ^= 1;
    }

    // 判断并释放懒标记
    inline void pushDown(register int x) {
        if (rev[x]) {
            swap(lc, rc);
            rev[lc] ^= 1, rev[rc] ^= 1;
            rev[x] = 0;
        }
    }

    // 更新信息
    inline void pushUp(register int x) {
        sum[x] = (sum[lc] + sum[rc] + w[x]) % mod;
        sz[x] = sz[lc] + sz[rc] + 1;
    }

    // 一次旋转
    inline void rotate(register int x) {
        register int y = f[x], z = f[y], k = (c[y][1] == x), w = c[x][!k];
        if (nRoot(y))
            c[z][c[z][1] == y] = x;
        c[x][!k] = y;
        c[y][k] = w;

        if (w)
            f[w] = y;
        f[y] = x;
        f[x] = z;
        pushUp(y);//原来的父亲现在是儿子了 更新新儿子的信息 而新父亲的信息不是在这里更新的
    }

    // 旋转一颗splay树 改为以x为根节点
    inline void splay(register int x) {
        register int y = x, z = 0;
        st[++z] = y;//暂存当前点到根的整条路径 pushdown时一定要从上往下放标记
        while (nRoot(y)) st[++z] = y = f[y];
        while (z) pushDown(st[z--]);
        //然后再从下往上旋转 splay的基本操作
        while (nRoot(x)) {
            y = f[x];
            z = f[y];
            if (nRoot(y))
                rotate((c[y][0] == x) ^ (c[z][0] == y) ? x : y);
            rotate(x);
        }
        pushUp(x);//更新最终新父亲x的信息
    }
	
	// 并查集find
	inline int geth(register int x) {
        return x == h[x] ? x : h[x] = geth(h[x]);
    }

    // 打通当前根节点到指定节点的树链
    // 使得一条中序遍历以根开始、以指定点结束的splay出现
    inline void access(register int x) {
    	//for (int y = 0; x; y = x, x = f[x] = geth(f[x])) { // merge时使用
        for (int y = 0; x; x = f[y = x]) {
            splay(x);
            rc = y;
            pushUp(x);
        }
    }

    //换根
    inline void makeRoot(register int x) {
        access(x);
        splay(x);
        reverse(x);
    }

    //提取路径 拉出x->y的路径成为一个splay 然后以y为splay的根
    inline void split(register int x, register int y) {
        makeRoot(x);
        access(y);
        splay(y);
    }

    // 查找在树的根
    // 因为lct要求满足中序遍历Splay得到的每个点的深度序列严格递增 根的深度最小
    // 一直往左儿子就是了
    int findRoot(register int x) {
        access(x);
        splay(x);
        while (lc) {
            pushDown(x);
            x = lc;
        }
        // 现在x是root
        splay(x);
        return x;
    }

    // 连边
    inline void link(register int x, register int y) {
        makeRoot(x);
        if (findRoot(y) != x)
            f[x] = y;
    }

    // 断边
    inline void cut(register int x, register int y) {
        makeRoot(x);
        if (findRoot(y) == x && f[y] == x && !c[y][0]) {
            f[y] = c[x][1] = 0;
            pushUp(x);
        }
    }

    // 判断 x 和 y 是否连通
    bool isConnected(int x, int y) {
        return findRoot(x) == findRoot(y);
    }

	// 缩点
    inline void del(register int x, register int y) {
        if (x) { // 如果点存在
            h[x] = y;
            del(lc, y);
            del(rc, y);
        }
    }


    //双连通分量存在时 连接x和y
    inline void merge(register int x, register int y) {
        if (x == y) return;
        makeRoot(x);
        if (findRoot(y) != x) {
            f[x] = y;// 等于 link(x,y)
            return;
        }
        // 双连通分量 暴力缩点
        del(rc, x);// 将以x为根的splay树缩成一个点 都用x来表示
        rc = 0;
        pushUp(x);//缩点 删点
    }

    void init(int n) {
        for (int i = 0; i <= n; i++) {
            f[i] = c[i][0] = c[i][1] = 0;
            w[i] = 1;
            h[i] = i;
        }
    }
}
using namespace LCT;

P3690 【模板】Link Cut Tree （动态树）

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, m, k;

namespace LCT { // lct板子
    int v[N];// 点权
    int f[N];// 父节点
    int st[N];//栈
    int c[N][2];// 每个节点的两个儿子

    // 判断节点x是否为一个splay的根 如果不是根 返回true
    inline bool nRoot(register int x) {
        // 如果节点x是根 则其与其父亲节点之间连的是轻边
        // 如果连的是轻边 他的父亲的儿子里没有它
        return c[f[x]][0] == x || c[f[x]][1] == x;
    }

    int rev[N];//rev为区间翻转懒标记数组
    
#define lc c[x][0]
#define rc c[x][1]

    // splay区间翻转操作
    inline void reverse(register int x) {
        swap(lc,rc);
        rev[x] ^= 1;
    }

    // 判断并释放懒标记
    inline void pushDown(register int x) {
        if (rev[x]) {
            if (lc) reverse(lc);
            if (rc) reverse(rc);
            rev[x] = 0;
        }
    }

    int a[N];// a[x]表示 以x为根的splay树在中序遍历下形成的区间 的异或总和

    // 更新信息
    inline void pushUp(register int x) {
        a[x] = a[lc] ^ a[rc] ^ v[x];
    }

    // 一次旋转
    inline void rotate(register int x) {
        register int y = f[x], z = f[y], k = (c[y][1] == x), w = c[x][!k];
        if (nRoot(y))
            c[z][c[z][1] == y] = x;
        c[x][!k] = y;
        c[y][k] = w;

        if (w)
            f[w] = y;
        f[y] = x;
        f[x] = z;
        pushUp(y);//原来的父亲现在是儿子了 更新新儿子的信息 而新父亲的信息不是在这里更新的
    }

    // 旋转一颗splay树 改为以x为根节点
    inline void splay(register int x) {
        register int y = x, z = 0;
        st[++z] = y;//暂存当前点到根的整条路径 pushdown时一定要从上往下放标记
        while (nRoot(y)) st[++z] = y = f[y];
        while (z) pushDown(st[z--]);
        //然后再从下往上旋转 splay的基本操作
        while (nRoot(x)) {
            y = f[x];
            z = f[y];
            if (nRoot(y))
                rotate((c[y][0] == x) ^ (c[z][0] == y) ? x : y);
            rotate(x);
        }
        pushUp(x);//更新最终新父亲x的信息
    }

    // 打通当前根节点到指定节点的树链
    // 使得一条中序遍历以根开始、以指定点结束的splay出现
    inline void access(register int x) {
        for (int y = 0; x; y = x, x = f[x]) {
            splay(x);
            rc = y;
            pushUp(x);
        }
    }

    //换根
    inline void makeRoot(register int x) {
        access(x);
        splay(x);
        reverse(x);
    }

    //提取路径 拉出x->y的路径成为一个splay 然后以y为splay的根
    inline void split(register int x, register int y) {
        makeRoot(x);
        access(y);
        splay(y);
    }

    // 查找在树的根
    // 因为lct要求满足中序遍历Splay得到的每个点的深度序列严格递增 根的深度最小
    // 一直往左儿子就是了
    int findRoot(register int x) {
        access(x);
        splay(x);
        while (lc) {
            pushDown(x);
            x = lc;
        }
        // 现在x是root
        splay(x);
        return x;
    }

    // 连边
    inline void link(register int x, register int y) {
        makeRoot(x);
        if (findRoot(y) != x) {
            f[x] = y;
        };
    }

    // 断边
    inline void cut(register int x, register int y) {
        makeRoot(x);
        if (findRoot(y) == x && f[y] == x && !c[y][0]) {
            f[y] = c[x][1] = 0;
            pushUp(x);
        }
    }
}
using namespace LCT;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    cin >> n >> m; // n个点 m个操作
    for (int i = 1; i <= n; i++) {
        cin >> v[i]; // 每个点的点权
    }
    int op, x, y;
    while (m--) {
        cin >> op >> x >> y;
        if (op == 0) { // 询问 (x->y)所有点权xor和
            split(x, y);
            //此时y为splay树的根 y是树中中序遍历到的第一个点 x是中序遍历到的最后一个点
            printf("%d\n", a[y]);

        } else if (op == 1) { //连通x->y
            link(x, y);

        } else if (op == 2) { // 删除x->y这条边
            cut(x, y);

        } else {//op=3 将x点权变为y
            // 每次修改值的时候 需要将x转上来
            splay(x);
            v[x] = y;
        }
    }
    return 0;
}

P1501 [国家集训队]Tree II

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, m, k;
typedef long long ll ;
namespace LCT { // lct板子
    const int mod = 51061;
    ll sum[N];// sum[x] 表示x所表示的区间的和
    ll add[N], mul[N];// 区间懒标记 表示还未下放的数
    ll w[N];// w[x]表示x的点权

    int sz[N];//sz[x] 表示以x为根的splay树的大小
    int rev[N];//rev为区间翻转懒标记数组
    int f[N];// 父节点
    int st[N];//栈
    int c[N][2];// 每个节点的两个儿子

    // 判断节点x是否为一个splay的根 如果不是根 返回true
    inline bool nRoot(register int x) {
        // 如果节点x是根 则其与其父亲节点之间连的是轻边
        // 如果连的是轻边 他的父亲的儿子里没有它
        return c[f[x]][0] == x || c[f[x]][1] == x;
    }

#define lc c[x][0]
#define rc c[x][1]

    // splay区间翻转操作
    inline void reverse(register int x) {
        swap(lc,rc);
        rev[x] ^= 1;
    }

    // 给x所代表的区间都加上一个值ad
    void Add(int x, int ad) {
        add[x] = (add[x] + ad) % mod;
        sum[x] = (sum[x] + sz[x] * ad % mod) % mod;
        w[x] = (w[x] + ad) % mod;
    }

    // 给x所代表的区间都乘上一个值mu
    void Mul(int x, int mu) {
        mul[x] = mul[x] * mu % mod;
        add[x] = add[x] * mu % mod;
        sum[x] = sum[x] * mu % mod;
        w[x] = w[x] * mu % mod;
    }

    // 判断并释放懒标记
    inline void pushDown(register int x) {
        if (rev[x]) {
            if (lc) reverse(lc);
            if (rc) reverse(rc);
            rev[x] = 0;
        }

        if (mul[x] != 1) {
            if (lc) Mul(lc, mul[x]);
            if (rc) Mul(rc, mul[x]);
            mul[x] = 1;
        }
        if (add[x]) {
            if (lc) Add(lc, add[x]);
            if (rc) Add(rc, add[x]);
            add[x] = 0;
        }
    }

    // 更新信息
    inline void pushUp(register int x) {
        sum[x] = (sum[lc] + sum[rc] + w[x]) % mod;
        sz[x] = sz[lc] + sz[rc] + 1;
    }

    // 一次旋转
    inline void rotate(register int x) {
        register int y = f[x], z = f[y], k = (c[y][1] == x), w = c[x][!k];
        if (nRoot(y))
            c[z][c[z][1] == y] = x;
        c[x][!k] = y;
        c[y][k] = w;

        if (w)
            f[w] = y;
        f[y] = x;
        f[x] = z;
        pushUp(y);//原来的父亲现在是儿子了 更新新儿子的信息 而新父亲的信息不是在这里更新的
    }

    // 旋转一颗splay树 改为以x为根节点
    inline void splay(register int x) {
        register int y = x, z = 0;
        st[++z] = y;//暂存当前点到根的整条路径 pushdown时一定要从上往下放标记
        while (nRoot(y)) st[++z] = y = f[y];
        while (z) pushDown(st[z--]);
        //然后再从下往上旋转 splay的基本操作
        while (nRoot(x)) {
            y = f[x];
            z = f[y];
            if (nRoot(y))
                rotate((c[y][0] == x) ^ (c[z][0] == y) ? x : y);
            rotate(x);
        }
        pushUp(x);//更新最终新父亲x的信息
    }


    // 打通当前根节点到指定节点的树链
    // 使得一条中序遍历以根开始、以指定点结束的splay出现
    inline void access(register int x) {
        for (int y = 0; x; x = f[y = x]) {
            splay(x);
            rc = y;
            pushUp(x);
        }
    }

    //换根
    inline void makeRoot(register int x) {
        access(x);
        splay(x);
        reverse(x);
    }

    //提取路径 拉出x->y的路径成为一个splay 然后以y为splay的根
    inline void split(register int x, register int y) {
        makeRoot(x);
        access(y);
        splay(y);
    }

    // 查找在树的根
    // 因为lct要求满足中序遍历Splay得到的每个点的深度序列严格递增 根的深度最小
    // 一直往左儿子就是了
    int findRoot(register int x) {
        access(x);
        splay(x);
        while (lc) {
            pushDown(x);
            x = lc;
        }
        // 现在x是root
        splay(x);
        return x;
    }

    // 连边
    inline void link(register int x, register int y) {
        makeRoot(x);
        if (findRoot(y) != x)
            f[x] = y;
    }

    // 断边
    inline void cut(register int x, register int y) {
        makeRoot(x);
        if (findRoot(y) == x && f[y] == x && !c[y][0]) {
            f[y] = c[x][1] = 0;
            pushUp(x);
        }
    }
}
using namespace LCT;


int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int u, v, c, q;
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
        w[i] = mul[i] = 1;
    }
    for (int i = 1; i < n; i++) {
        cin >> u >> v;
        link(u, v);

    }
    string op;
    while (q--) {
        cin >> op;
        if (op == "+") { // 将 u 到 v 的路径上的点的权值都加上自然数 c
            cin >> u >> v >> c;
            split(u, v);
            Add(v, c);

        } else if (op == "-") { //将树中原有边(u1,v1)删除 加入新的边(u2,v2)
            cin >> u >> v;
            cut(u, v);

            cin >> u >> v;
            link(u, v);

        } else if (op == "*") {//将 u 到 v 的路径上的点的权值都乘上自然数 c
            cin >> u >> v >> c;
            split(u, v);
            Mul(v, c);

        } else { //询问 u 到 v 的路径上的点的权值和 将答案对 51061 取模
            cin >> u >> v;
            split(u, v);
            cout << sum[v] << endl;

        }
    }
    return 0;
}

P2542 [AHOI2005] 航线规划

#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int n, m;
namespace LCT { // lct板子
    int h[N];// 缩点后x所在的点
    int w[N];// w[x]表示x的点权

    int rev[N];//rev为区间翻转懒标记数组
    int f[N];// 父节点
    int st[N];//栈
    int c[N][2];// 每个节点的两个儿子

    // 判断节点x是否为一个splay的根 如果不是根 返回true
    inline bool nRoot(register int x) {
        // 如果节点x是根 则其与其父亲节点之间连的是轻边
        // 如果连的是轻边 他的父亲的儿子里没有它
        return c[f[x]][0] == x || c[f[x]][1] == x;
    }

#define lc c[x][0]
#define rc c[x][1]

    // splay区间翻转操作
    inline void reverse(register int x) {
        swap(lc, rc);
        rev[x] ^= 1;
    }


    // 判断并释放懒标记
    inline void pushDown(register int x) {
        if (rev[x]) {
            swap(lc, rc);
            rev[lc] ^= 1, rev[rc] ^= 1;
            rev[x] = 0;
        }
    }

    // 更新信息
    inline void pushUp(register int x) {
        w[x] = w[lc] + w[rc] + 1;
    }

    // 一次旋转
    inline void rotate(register int x) {
        register int y = f[x], z = f[y], k = (c[y][1] == x), w = c[x][!k];
        if (nRoot(y))
            c[z][c[z][1] == y] = x;
        c[x][!k] = y;
        c[y][k] = w;

        if (w)
            f[w] = y;
        f[y] = x;
        f[x] = z;
        pushUp(y);//原来的父亲现在是儿子了 更新新儿子的信息 而新父亲的信息不是在这里更新的
    }

    // 旋转一颗splay树 改为以x为根节点
    inline void splay(register int x) {
        register int y = x, z = 0;
        st[++z] = y;//暂存当前点到根的整条路径 pushdown时一定要从上往下放标记
        while (nRoot(y)) st[++z] = y = f[y];
        while (z) pushDown(st[z--]);
        //然后再从下往上旋转 splay的基本操作
        while (nRoot(x)) {
            y = f[x];
            z = f[y];
            if (nRoot(y))
                rotate((c[y][0] == x) ^ (c[z][0] == y) ? x : y);
            rotate(x);
        }
        pushUp(x);//更新最终新父亲x的信息
    }

    inline int geth(register int x) {
        return x == h[x] ? x : h[x] = geth(h[x]);
    }

    // 打通当前根节点到指定节点的树链
    // 使得一条中序遍历以根开始、以指定点结束的splay出现
    inline void access(register int x) {
        for (int y = 0; x; y = x, x = f[x] = geth(f[x])) {
            splay(x);
            rc = y;
            pushUp(x);
        }
    }

    //换根
    inline void makeRoot(register int x) {
        access(x);
        splay(x);
        //reverse(x);
        rev[x] ^= 1;
    }

    //提取路径 拉出x->y的路径成为一个splay 然后以y为splay的根
    inline void split(register int x, register int y) {
        makeRoot(x);
        access(y);
        splay(y);
    }

    // 查找在树的根
    // 因为lct要求满足中序遍历Splay得到的每个点的深度序列严格递增 根的深度最小
    // 一直往左儿子就是了
    int findRoot(register int x) {
        access(x);
        splay(x);
        while (lc) {
            pushDown(x);
            x = lc;
        }
        // 现在x是root
        splay(x);
        return x;
    }

    // 连边
    inline void link(register int x, register int y) {
        makeRoot(x);
        if (findRoot(y) != x) {
            f[x] = y;
        }
    }

    // 断边
    inline void cut(register int x, register int y) {
        makeRoot(x);
        if (findRoot(y) == x && f[y] == x && !c[y][0]) {
            f[y] = c[x][1] = 0;
            pushUp(x);
        }
    }

    inline void del(register int x, register int y) {
        if (x) {
            h[x] = y;
            del(lc, y);
            del(rc, y);
        }
    }

    //双连通分量存在时 连接x和y
    inline void merge(register int x, register int y) {
        if (x == y) return;
        makeRoot(x);
        if (findRoot(y) != x) {
            f[x] = y;// 等于 link(x,y)
            return;
        }
        // 双连通分量 暴力缩点
        del(rc, x);// 将以x为根的splay树缩成一个点 都用x来表示
        rc = 0;
        pushUp(x);//缩点 删点
    }

}
using namespace LCT;

struct Edge {
    int u, v;

    bool operator<(const Edge b) const {
        return u < b.u || (u == b.u && v < b.v);
    }
} e[N];

struct Operation {
    int u, v, op;
} a[N];

int vis[N], res[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int u, v;
    cin >> n >> m;
    for (int i = 1; i <= n; i++) {
        w[i] = 1;// 点权
        h[i] = i;// 类似并查集里的f[]
    }
    for (int i = 1; i <= m; i++) {
        cin >> u >> v;
        if (u > v) swap(u, v);
        e[i] = {u, v};
    }
    sort(e + 1, e + 1 + m);

    int op, id = 0;
    while (cin >> op && op != -1) {
        cin >> u >> v;
        // op=1 询问 u->v的关键路线
        // op=0 断边
        if (!op) {
            if (u > v) swap(u, v);
            vis[lower_bound(e + 1, e + 1 + m, (Edge) {u, v}) - e] = 1;
        }
        a[++id] = {u, v, op};
    }

    // 把没有断边的点 全部连起来
    for (int i = 1; i <= m; i++) {
        if (!vis[i]) {
            merge(geth(e[i].u), geth(e[i].v));
        }
    }
    
    int cnt = 0;
    for (int i = id; i; i--) {
        u = geth(a[i].u);
        v = geth(a[i].v);
        if (a[i].op) {
            split(u, v);
            res[++cnt] = w[v] - 1;
        } else {
            merge(u, v);
        }
    }

    for (int i = cnt; i; i--) {
        cout << res[i] << endl;
    }
    return 0;
}
Zaller
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态树LCT BySemiWaker
03-05
动态树LCT
动态树课件
03-26
洛谷 P3690 【模板】Link Cut Tree （动态树）LCT
liangzihao1的博客
03-13 250
题目描述给定n个点以及每个点的权值，要你处理接下来的m个操作。操作有4种。操作从0到3编号。点从1到n编号。0：后接两个整数(x，y)，代表询问从x到y的路径上的点的权值的xor和。保证x到y是联通的。1：后接两个整数(x，y)，代表连接x到y，若x到y已经联通则无需连接。2：后接两个整数(x，y)，代表删除边(x，y)，不保证边(x，y)存在。3：后接两个整数(x，y)，代表将点x上的权值变成y。
luoguP3690 【模板】Link Cut Tree （动态树）
Coco_T的博客
09-17 342
题目背景动态树题目描述给定Ｎ个点以及每个点的权值，要你处理接下来的Ｍ个操作。操作有４种。操作从０到３编号。点从１到Ｎ编号。０：后接两个整数（ｘ，ｙ），代表询问从ｘ到ｙ的路径上的点的权值的ｘｏｒ和。保证ｘ到ｙ是联通的。１：后接两个整数（ｘ，ｙ），代表连接ｘ到ｙ，若ｘ到Ｙ已经联通则无需连接。２：后接两个整数（ｘ，ｙ），代表删除边（ｘ，ｙ），不保证边（ｘ，ｙ）存在。３：后接两个整数（ｘ，ｙ），代表将点Ｘ上
【用皇宫三十六计生存法则带你走进LCT(动态树)】LCT概念+模板+例题【洛谷P3690 Link Cut Tree（动态树）】
01-11 768
这样学知识那可太好玩了
P3690 【模板】Link Cut Tree （动态树）
二次元的coding生活
04-18 118
题目给出N个点和m个查询，每次查询对n个点添加或者删除边，但是要保证在联通的情况下，因此无论怎么操作，他都保证是一棵树。 LCT 处理一棵树上的边的添加和删除。 LCT把一棵树分成很多条链，每一条链使用splay来维护，splay之间相关连接。 splay使用这条链上的节点的深度来维护。 每当需要查询x到y的路径时，通过access操作，把x和y这条路径组成一棵新的splay，其他点则变成自己独立的splay。这个splay就可以做树dp来统计路径上的信息。 Access(x) 将x变..
【Link Cut Tree 模板】洛谷P3690 动态树 LCT 模板
KIKO_caoyue的博客
08-20 183
题目戳这里 本模板是从网上复制来的。 操作如下： access(x,y)，将x到y的路径连上实边，其他儿子都变成虚边。 link(x,y)，将x和y连起来。 cut(x,y)，将x和y断开。 对于修改操作，若将点x的权值修改成y，只需splay(x)然后v[x] = y即可。 findroot(x)==findroot(y)表示连通。 makeroot(x)表示将x选为跟。 split(x,y)，...
动态树 之 Link-Cut Tree (LCT)
拾月冰海的小书屋
11-01 318
原理啥的实在不想写(太枯燥了) 主要讲各个操作的代码实现 感谢@Harry_bh钦自为本人弄了篇题解 于是本人就学会了 现在想想为了个LCT我学的东西还挺多的 前置知识Splay(力推我的) + 树链剖分(最好理解) 我当诸君都很熟练了啊QAQ 原理概念之类的戳这里他讲的挺不错的 然后我主要记记操作&程序上 话说LCT里相关操作的子程序好多 讲起来比较乱 首先规定...
【luogu P3690】【模板】Link Cut Tree （动态树）
欢迎您的光顾awa
02-22 142
LCT 模板题。 要你实现树上的一些操作。 询问树上两点之间路径上点权的异或和。 连接两点，如果本来已经连通就不用。 删除两点之间的边，没有就不管。 更改某个点的权值。
【洛谷P3690】【模板】Link Cut Tree
wang_sj的博客
04-21 597
题目背景动态树题目描述给定Ｎ个点以及每个点的权值，要你处理接下来的Ｍ个操作。操作有４种。操作从０到３编号。点从１到Ｎ编号。０：后接两个整数（ｘ，ｙ），代表询问从ｘ到ｙ的路径上的点的权值的ｘｏｒ和。保证ｘ到ｙ是联通的。１：后接两个整数（ｘ，ｙ），代表连接ｘ到ｙ，若ｘ到Ｙ已经联通则无需连接。２：后接两个整数（ｘ，ｙ），代表删除边（ｘ，ｙ），不保证边（ｘ，ｙ）存在。３：后接两个整数（ｘ，ｙ），代表将点Ｘ上
模板：Link Cut Tree（LCT）
BUG_Creater_jie的博客
12-07 407
动态树是一种支持森林删边、加边、换根的强大数据结构
lct_LCT_
09-29
Link-Cut Tree（链接切割树）是一种自顶向下的动态树数据结构，主要用于解决与树相关的操作，如查询、修改和维护树的状态。这个数据结构特别适用于处理那些需要快速响应树形结构变化的问题，例如在图的生成树中进行...
lct.zip_LCT
09-19
【标题】"lct.zip_LCT" 涉及到的是一个名为 "lct.zip" 的压缩文件，其中包含了与"LCT"相关的资料。LCT通常代表“逻辑控制技术”（Logical Control Technology）或者“线性电流变换器”（Linear Current Transformer...
lct.zip_lct文件
最新发布
09-24
标题中的“lct.zip_lct文件”指的是一个压缩包，其中包含了名为“lct”的文件。这个“lct”文件可能是一个库文件，用于在特定的编程环境或项目中提供预定义的功能，使得开发者能够更方便地进行软件开发，而无需从零...
【模板】整数分块
Yubing792289314的博客
08-02 558
图片来源 -> 整数分块基础 那些年我用整数分块做过的题 宁波市多校训练（二）· 最大限定倍数(Normal Version) 2020牛客暑期多校训练营（第七场）· H Dividing 板子 for (ll l = 2, r; l <= lim; l = r + 1) { r = n / (n / l); if (r > lim) r = lim; res = (res + ((((r - l + 1) * 2) % mod)
P5367 【模板】康托展开 / 计算数列在全排列中的排名
Yubing792289314的博客
03-26 513
百度百科 - 康托展开 康拓展开 X=a1∗(n−1)!+a2∗(n−2)!+...+an∗0!X=a_{1}*(n-1)!+a_{2}*(n-2)!+...+a_{n}*0!X=a1​∗(n−1)!+a2​∗(n−2)!+...+an​∗0! 其中，aia_iai​ 表示给定整数序列的第i位在当前还未出现的元素中是排在第几个 可用于求当前序列在全排列中的排名 =X+1=X+1=X+1 逆康拓展开...
P3369 【模板】普通平衡树 stl / treap / splay / AVL
Yubing792289314的博客
02-27 412
STL #include <bits/stdc++.h> using namespace std; int n, m, k; vector<int>v; int main() { ios::sync_with_stdio(0); cin>>n; for (int i = 1,op,x; i <= n; ++i) { ...
【模板】支配树
Yubing792289314的博客
06-28 396
学习博客 支配树学习笔记 与图论的邂逅03：Lengauer-Tarjan ← 原理介绍的不错 一些相关的定义 搜索树：有向无环图从根节点dfs时最先经过的边形成的树 在搜索树上的边：任意(u→v)，均存在 dfnu<dfnvdfn_u<dfn_vdfnu​<dfnv​ 不在搜索树上的边：任意(u→v)，均存在 dfnu>dfnvdfn_u>dfn_vdfnu​>dfnv​ 支配点，也叫必经点： domdomdom domxdom_xdomx​ ：可以到达x的所有必经点
Link-Cut-Tree：动态树数据结构解析与应用
Link-Cut-Tree（LCT）是一种用于解决动态树问题的数据结构，由著名算法大师Robert Tarjan提出。动态树问题是指那些需要在树结构上进行一系列操作，如添加、删除边，查询或修改节点属性等问题。LCT并非动态树本身，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值