【洛谷P4193】变化的道路——LCT+线段树

最新推荐文章于 2022-09-05 10:26:34 发布
最新推荐文章于 2022-09-05 10:26:34 发布
阅读量302 收藏 1
点赞数 1
分类专栏： LCT 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40903174/article/details/79807891
版权

前置技能点：LCT，线段树

如果你不知道上面的东西，请先行了解

start_of_题面

传送门

end_of_题面

正式写题解之前，先吐槽一句，为什么这题在洛谷上标签会是普及-啊！！！直接写了两个小时+调了不知道多长时间。不过看讨论好像之前的标签是入门，大佬们还真是调皮(汗)。

第一眼看到这题发现是动态维护最小生成树，支持加边删边，立刻想到LCT，因为前段时间刚刚做了NOI2014魔法森林。然后想了想觉得可以 O(N) O ( N ) 扫一遍，利用一个类似ZJOI2016大森林的做法怎么搞一搞。于是就开始敲，敲到一半发现不对，有很大问题。因为这道题是动态维护最小生成树，所以不知道在每次操作的左右区间都该干什么。我们每次加边可以很轻松维护最小生成树，但是删边就没法做了，因为我们不知道删了这条边应该重新加进去哪一条边。

于是就想换方法，想了想可持久化LCT，发现我简直在做梦，然后突然想起之前听tty大神讲课的时候讲到的一个方法——时间线段树。

我们对时间建一颗线段树，然后把出现过的边按照存在的时间区间挂在线段树上，比如样例

这里写图片描述

图中的三元组 (u,v,w) ( u , v , w ) 代表一条端点为 u u 和v且边权为 w w 的边。

由于样例过大，这里只展示前六天的情况

一开始的边一直存在，所以挂在区间[1,rmost]上，中间出现的边会挂在下面的区间，有可能是整个的，也有可能被分在线段树的多个节点，比如图中的 (1,2,1) ( 1 , 2 , 1 ) 就因为出现时间是 [1,2] [ 1 , 2 ] 所以被放在一个点上，而 (2,3,8) ( 2 , 3 , 8 ) 因为出现的时间是 [2,3] [ 2 , 3 ] 所以被分在了两个点上。

这样的话，我们从这颗线段树的根走到一个叶子节点，就对应了一天内的情况，这天内所有存在的边都会在我们路上经过的线段树的节点内存着，我们只需要在这个过程中用LCT动态地维护最小生成树，然后到了线段树的叶子节点就输出答案就可以了。

出于时间和空间的考虑，我们在每一个线段树的节点上开一个 vector v e c t o r 保存边，另外为了不浪费时间，我们可以在线段树的每个节点动态维护最小生成树的同时用另一个 vector v e c t o r 记下我们做过的操作，离开这个节点的时候，我们倒序处理这些操作，是断开边的就连回去，是连边的就断开，这样回到它的父亲节点时可以直接继续访问父亲节点的另一个儿子。

粗略计算一下，一个区间在线段树上最多被分为 logN l o g N 个区间，也就是说在这个过程中每条输入的边最多被加入删除 logN l o g N 次，线段树的节点数级别是 O(N) O ( N ) ，LCT的复杂度是均摊 O(logN) O ( l o g N ) ，题目给了7s时间，应该可过。

实测在洛谷开O2的情况下12个点跑了25320ms。

start_of_code

#include <map>
#include <cmath>
#include <vector>
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

#define LL long long

const int rmost = 32766;
const int N = 350000 + 5000;

int n, m, l, r;
struct Edge{
    int x, y, tp;
    LL w;
}us[N];
struct Opt{
    int fc, x, y;
}ff[N], pus;

inline LL read()
{
    LL a = 0;
    char ch;
    LL f = 1;
    while(!((((ch = getchar()) >= '0') && (ch <= '9')) || (ch == '-')));
    if(ch == '-')
        f = -1;
    else
    {
        a = a * 10;
        a += ch - '0';
    }
    while((((ch = getchar()) >= '0') && (ch <= '9')) || (ch == '-'))
    {
        a = a * 10;
        a += ch - '0';
    }
    return a * f;
}

namespace LCT{
    int son[N][2], big[N], fa[N], rev[N];
    LL val[N];
    inline int which(int x)
    {
        return x == son[fa[x]][1];
    }

    inline bool isroot(int x)
    {
        return x != son[fa[x]][1] && x != son[fa[x]][0];
    }

    inline void update(int x)
    {
        big[x] = x;
        if(son[x][1] && val[big[son[x][1]]] > val[big[x]])
            big[x] = big[son[x][1]];
        if(son[x][0] && val[big[son[x][0]]] > val[big[x]])
            big[x] = big[son[x][0]];
    }

    inline void pushdown(int x)
    {
        if(rev[x])
        {
            rev[son[x][1]] ^= 1;
            rev[son[x][0]] ^= 1;
            swap(son[x][1], son[x][0]);
            rev[x] = 0;
        }
    }

    inline void rotate(int x)
    {
        int f = fa[x], g = fa[f], d = which(x);
        if(!isroot(f))
            son[g][which(f)] = x;
        fa[x] = g;
        son[f][d] = son[x][d ^ 1];
        fa[son[f][d]] = f;
        son[x][d ^ 1] = f;
        fa[f] = x;
        update(f);
        update(x);
    }

    int stk[N], top = 0;

    inline void splay(int x)
    {
        top = 0;
        stk[++top] = x;
        for(int i = x;!isroot(i);i = fa[i])
            stk[++top] = fa[i];
        for(int i = top;i >= 1;--i)
            pushdown(stk[i]);
        for(;!isroot(x);rotate(x))
            if(!isroot(fa[x]))
                rotate(which(x) == which(fa[x]) ? fa[x] : x);
        update(x);
    }

    inline void access(int x)
    {
        int y = 0;
        for(;x;y = x, x = fa[x])
            splay(x), son[x][1] = y, update(x);
    }

    inline void makeroot(int x)
    {
        access(x);
        splay(x);
        rev[x] ^= 1;
    }

    inline int findroot(int x)
    {
        access(x);
        splay(x);
        while(son[x][0])
            x = son[x][0];
        return x;
    }

    inline void link(int u, int v)
    {
        makeroot(u);
        fa[u] = v;
        splay(u);
    }

    inline void cut(int x, int y)
    {
        makeroot(x);
        access(y);
        splay(y);
        fa[x] = son[y][0] = 0;
        update(y);
    }

    inline int query(int u, int v)
    {
        makeroot(u);
        access(v);
        splay(v);
        return big[v];
    }
}
using namespace LCT;

inline void debug()
{
    for(int i = 1;i < 2 * n + m;++i)
    {
        cout << fa[i] << " " << val[i];
        if(i > n)
            cout << " " << us[i - n].x << " " << us[i - n].y;
        cout << endl;
    }
}

namespace Seg{
    vector<Edge> g[N];
    vector<Opt> op[N];
    int lc[N], rc[N];

    inline void build(int p, int l, int r)
    {
        g[p].clear();
        lc[p] = l, rc[p] = r;
        if(l == r)
            return;
        int mid = (l + r) >> 1;
        build(p << 1, l, mid);
        build(p << 1 | 1, mid + 1, r);
    }

    inline void add(int p, int l, int r, Edge in)
    {
        if(l == lc[p] && r == rc[p])
        {
            g[p].push_back(in);
            return;
        }
        int mid = (lc[p] + rc[p]) >> 1;
        if(r <= mid)
            add(p << 1, l, r, in);
        else if(l > mid)
            add(p << 1 | 1, l, r, in);
        else
            add(p << 1, l, mid, in), add(p << 1 | 1, mid + 1, r, in);
    }

    inline void solve(int p, LL ans)
    {
        LL down = ans;
        int s = g[p].size();
        for(int i = 0;i < s;++i)
        {
            Edge o = g[p][i];
            int u = o.x, v = o.y;
            bool f = 1;
            if(findroot(u) == findroot(v))
            {
                int I = query(u, v);
                if(val[I] > o.w)
                {
                    down -= val[I];
                    cut(us[I - n].x, I);
                    cut(I, us[I - n].y);
                    pus.fc = 1, pus.x = us[I - n].x, pus.y = I;
                    op[p].push_back(pus);
                    pus.fc = 1, pus.x = I, pus.y = us[I - n].y;
                    op[p].push_back(pus);
                }
                else
                    f = 0;
            }
            if(f)
            {
                link(u, o.tp);
                link(o.tp, v);
                pus.fc = 0, pus.x = u, pus.y = o.tp;
                op[p].push_back(pus);
                pus.fc = 0, pus.x = o.tp, pus.y = v;
                op[p].push_back(pus);
                down += o.w;
            }
        }
        if(lc[p] != rc[p])
        {
            solve(p << 1, down);
            solve(p << 1 | 1, down);
        }
        else
            printf("%lld\n", down + 1);
        if(p == 1)
            return;
        s = op[p].size();
        for(int i = s - 1;i >= 0;--i)
        {
            Opt o = op[p][i];
            if(o.fc == 1)
                link(o.x, o.y);
            else
                cut(o.x, o.y);
        }
    }
}
using namespace Seg;

int main()
{
    build(1, 1, rmost);
    n = read();
    for(int i = 1;i < n;++i)
    {
        us[i].x = read(), us[i].y = read(), us[i].w = read(), us[i].tp = n + i;
        val[us[i].tp] = us[i].w;
        add(1, 1, rmost, us[i]);
    }
    m = read();
    for(int i = n;i < n + m;++i)
    {
        us[i].x = read(), us[i].y = read(), us[i].w = read(), us[i].tp = 2 * n - 1 + (i - n + 1);
        l = read(), r = read();
        val[us[i].tp] = us[i].w;
        add(1, l, r, us[i]);
    }
    solve(1, 0);
    return 0;
}

end_of_code

_herofox
关注
专栏目录
动态树LCT BySemiWaker
03-05
动态树LCT
天下第一 txdy (LCT+双指针+线段树）
10-05 1485
woc码农题，好久没(被)整了
【SDOI2017】树点涂色（LCT）（线段树）
zxyoi_dreamer的博客（不定期诈尸）
09-29 105
传送门 题解： 这个操作非常LCT。。。 显然操作111就是access。。。 考虑怎么对操作222和操作333进行维护。 如果没有操作3那就是LCTxjb维护的SB题 注意到Splay维护的链一定是一条连续的祖先后代链。不会产生拐弯的情况。 那么可以考虑差分，注意到一个点到根节点的答案就是它到根节点经过的Splay个数，记为dis[u]dis[u]dis[u]。 操作222的答案就是dis[u...
【Foreign】染色 [LCT][线段树]
weixin_33692284的博客
03-03 128
染色 Time Limit: 20 SecMemory Limit: 256 MB Description 　　 Input 　　 Output 　　 Sample Input 　　13　　0 1　　0 2　　1 11　　1 10　　1 9　　9 12　　2 5　　5 8　　2 4　　2 3　　4 6　　4 7　　7　　q 0　　O 4　　q 6　　q 2　　O 9　　q...
【LCT+线段树】BZOJ4817(Sdoi2017)[树点涂色]题解
ZigZagK的博客
01-05 413
题目概述 有一棵 nn 个点的有根树，其中 11 号点是根节点。每个点有颜色且刚开始颜色不同。定义一条路径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。可能会进行 mm 次这几种操作： 1 x：把点x到根节点的路径上所有的点染上一种没有用过的新颜色。 2 x y：求x到y的路径的权值。 3 x y：在以x为根的子树中选择一个点，使得这个点到根节点的路径权值最大，求最大权值
BZOJ 4817 [LCT][线段树][树链剖分]
Vectorxj的博客
09-15 402
DescriptionDescriptionBob有一棵nn个点的有根树，其中11号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。 定义一条路径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。 Bob可能会进行这几种操作： 1 x1~x：把点xx到根节点的路径上所有的点染上一种没有用过的新颜色。 2 x y2~x~y：求x到y的路径的权值。 3 x3~x：在以x为
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”文件可能是一个库文件，用于在特定的编程环境或项目中提供预定义的功能，使得开发者能够更方便地进行软件开发，而无需从零...
lct_LCT_
09-29
这个数据结构特别适用于处理那些需要快速响应树形结构变化的问题，例如在图的生成树中进行插入、删除和旋转等操作。 在描述中提到的“高级的动态树实现实例”，暗示了这是一个用以教学或实践Link-Cut Tree算法的...
LCT的定义和应用场景
最新发布
07-26
lct
LCT（Link-Cut Tree）详解（蒟蒻自留地）
热门推荐
Saramanda的博客
02-16 2万+
最近自学了LCT，发现网上的资料讲解不是很全面，像我这样的蒟蒻一时半会根本理解不了。我弄了很久总算是理解了LCT，打算总结一下LCT的基本操作，还请诸位神牛来找找茬。   如果你还没有接触过LCT，你可以先看一看这里： （看不懂没关系，先留个大概的印像）http://www.cnblogs.com/BLADEVIL/p/3510997.html 看完之后我们知道，LCT和静态的树链剖分很像
BZOJ 3779 重组病毒 LCT+线段树维护DFS序
世界
05-22 2491
题目大意：给定一棵树，初始每个点都有一个颜色，支持三种操作： 1.将某个点到根的路径上所有点染上一种新的颜色 2.将某个点到根的路径上所有点染上一种新的颜色，然后把根设为这个点 3.定义一个点的代价为这个点到根路径上颜色的种类数，求某个点子树中所有点代价的平均值我真是炖了狗了…… 容易发现这玩应就是个LCT，操作1就是Access，操作2就是Move_To_Root，代价就是一个点到根路径上
【BZOJ2816】【洛谷】【ZJOI2012】—网络（LCT）
Stargazer的博客
03-20 144
BZOJ传送门 洛咕传送门 tmtmtm注意最后要加一个“...” 没注意就奇怪的挂了…… 发现C&lt;10C&lt;10C<10,直接对于每一个颜色暴力维护一颗LCTLCTLCT就可以了 判断的话应该比较简单，反正连边个人喜欢用一个mapmapmap来记录 注意queryqueryquery及时下传信息否则会出错 #include<bits/stdc++.h>...
首都 洛谷4299 LCT
forever_shi的博客
05-27 178
题目链接这题是bzoj权限题，我没权限号，所以没法交，只好在洛谷上做。题解：我们发现，对于A操作，支持连接，首先就会想到LCT，然后还可能是离线并查集之类的东西，但是我们发现似乎并查集并不容易维护这个要求是树的重心的首都，所以考虑用LCT。网上大多数的做法是启发式合并，每次从size小的树找一个点合并到size大的树上，这样每次合并重心最多移动一次，这样复杂度应该是nlog^2n(n*logn*l...
LCT模板（学习笔记）（洛谷3690）（加边，删边，修改点权）
y_immortal的博客 QwQ(qdez_ymh)
11-24 329
题目链接 最近学习了一波LCT qwq 强势安利Flashhu的博客！！！！！ 真的特别详细（可惜我不会弄链接） 如果有想要学习LCTLCTLCT的同学，可以直接看他的博客 我这里就简单写一点自己的体会啊。 LCTLCTLCT大致上就是一个支持加边，删边，维护子树信息，路径修改，维护路径信息的一个数据结构 本质上LCT是一个实虚链划分 代码的话，主要是分为几个部分 首先是判断这个点是不是根 和 其...
SDOI2017 树点涂色（LCT+线段树）
WAautomaton的博客
02-12 279
题目链接 题目大意 给定一棵每个点颜色不同的树，支持三种操作： 1.把点x到根节点的路径上的所有的点染上一种没有用过的新颜色； 2.求x到y有多少种颜色； 3.求x的子树中的点使该点到根的不同颜色数最大。 n,m≤105n,m\le 10^5n,m≤105 题解 如果我们能够动态维护某个点到根的不同颜色数，就做完了。考虑1操作实际上是LCT的access操作，于是我们可以用LCT来维护。 acce...
[bzoj4817][LCT][线段树]树点涂色
Rose_max的博客
09-15 153
Description Bob有一棵n个点的有根树，其中1号点是根节点。Bob在每个点上涂了颜色，并且每个点上的颜色不同。定义一条路 径的权值是：这条路径上的点（包括起点和终点）共有多少种不同的颜色。Bob可能会进行这几种操作： 1 x: 把点x到根节点的路径上所有的点染上一种没有用过的新颜色。 2 x y: 求x到y的路径的权值。 3 x 在以x为根的子树中选择一个点，...
洛谷P2486 lct做法
stdforces的博客
09-05 310
LCT
【洛谷P4319】 变化的道路 线段树分治+LCT
EM LGH
11-27 142
最近学了一下线段树分治，感觉还蛮好用... 如果正常动态维护最大生成树的话用 LCT 就行，但是这里还有时间这一维的限制. 所以，我们就把每条边放到以时间为轴的线段树的节点上，然后写一个可撤销 LCT 就好了 ~ code: #include <bits/stdc++.h> #define RM 32766 #define N 2000005 #define...
LCT与Splay：动态树操作的神器——区间操作、链上求值与换根
3. 动态树处理：当树结构是动态变化时，不能像树链剖分那样重标记，但可以利用LCT的轻重链的概念，并结合Splay技术来动态维护树结构。其中，PreferredChild、PreferredEdge和PreferredPath等概念在LCT中起着关键作用...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值