动态树 Link-Cut Trees

最新推荐文章于 2024-01-22 22:38:12 发布
最新推荐文章于 2024-01-22 22:38:12 发布
阅读量959 收藏
点赞数
分类专栏： 学习资料
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyendra/article/details/38468143
版权

动态树

动态树问题, 即要求我们维护一个由若干棵子结点无序的有根树组成的森林。

要求这个数据结构支持对树的分割、合并，对某个点到它的根的路径的某些操作，以及对某个点的子树进行的某些操作。

在这里我们考虑一个简化的动态树问题，它只包含对树的形态的操作和对某个点到根的路径的操作：

维护一个数据结构，支持以下操作:

• MAKE TREE() — 新建一棵只有一个结点的树。

• CUT(v) — 删除 v 与它的父亲结点 parent(v) 的边，相当于将点 v 的子树分离了出来。

• JOIN(v,w) — 让 v 成为 w 的新的儿子。其中 v 是一棵树的根结点，并且 v 和 w 是不同的两棵树中的结点。

• FIND ROOT(v) — 返回 v 所在的树的根结点。搞清了这个问题，我们也容易扩充这个数据结构，维护每个点到它所属的树的根结点的路径的一些信息，例如权和、边权的最大值、路径长度等。

 

Link-Cut Trees

Link-Cut Trees 是由 Sleator 和 Tarjan 发明的解决这类动态树问题的一种数据结构。

这个数据结构可以在均摊 O(logn) 的时间内实现上述动态树问题的每个操作。

如果没有用对树的形态的改变的话，我们可以用树链剖分，把树剖分成许多条链并维护上面的权值信息。

然而对于树的形态的改变，树链的剖分方案也要改变，我们借助 Splay 的思想来动态维护许多树链（称为 Link-Cut Trees）。

 

Link-Cut Trees 的定义

称一个点被访问过，如果刚刚执行了对这个点的 ACCESS 操作。如果结点 v 的子树中，最后被访问的结点在子树 w 中，这里 w 是 v 的儿子, 那么就称 w 是 v 的 Preferred Child。如果最后被访问过的结点就是 v 本身，那么它没有 Preferred Child。每个点到它的 Preferred Child 的边称作 Preferred Edge。由 Preferred Edge 连接成的不可再延伸的路径称为 Preferred Path。这样，整棵树就被划分成了若干条 Preferred Path。对每条 Preferred Path，用这条路上的点的深度作为关键字，用一棵平衡树来维护它(在这棵平衡树中，每个点的左子树中的点，都在 Preferred Path 中这个点的上方；右子树中的点，都在 Preferred Path 中这个点的下方)。需要注意的是，这种平衡树必须支持分离与 合并。这里，我们选择 Splay Tree 作为这个平衡树的数据结构。我们把这棵平衡树称为一棵 Auxiliary Tree。知道了树 T 分解成的这若干条 Preferred Path，我们只需要再知道这些路径之间的连接关系，就可以表示出这棵树 T。用 Path Parent 来记录每棵 Auxiliary Tree 对应的 Preferred Path 中的最高点的父亲结点，如果这个 Preferred Path 的最高点就是根结点，那么令这棵 Auxiliary Tree 的 Path Parent 为 null。Link-Cut Trees 就是将要维护的森林中的每棵树 T 表示为若干个 Auxiliary Tree。并通过 Path Parent 将这些 Auxiliary Tree 连接起来的数据结构。

 

实际上，对于定义要从两方面去理解：

首先是逻辑结构，存在着一棵或多棵树，这是在逻辑上存在的，我们要做的就是对这个森林进行操作与维护；

其次是物理结构，我们并没有直接储存这些树，而是把树剖分成了多条链，每条链作为一棵 Splay。Splay 中的最小结点就是链的头结点。

 

回顾一下定义：

ACCESS(访问)：又叫 Expose，对结点的访问操作。

Preferred Child(最佳孩子)：最近一次访问过的儿子。最近一次被访问过的结点没有 Preferred Child。

Preferred Edge(最佳边)：每个结点到 Preferred Child 的边。

Preferred Path(最佳路径)：连续的 Preferred Edge 组成的边。

Auxiliary Tree(辅助树)：在 Splay 上维护一条链，对于 Splay 上的每个结点，它的左子树上的点都在链的上方，右子树的点都在链的下方。

Path Parent(路径的父亲)：记录链上最高结点的父亲，也就是 Splay 最左边结点的父亲，用于表示链与链之间的关系。

 

Link-Cut Trees 的操作

Access

ACCESS 操作是 Link-Cut Trees 的所有操作的基础。假设调用了过程 ACCESS(v)，那么从点 v 到根结点的路径就成为一条新的 Preferred Path。如果路径上经过的某个结点 u 并不是它的父亲 parent(u) 的 Preferred Child，那么由于 parent(u) 的 Preferred Child 会变为 u，原本包含 parent(u) 的 Preferred Path 将不再包含结点 parent(u) 及其之上的部分。

也就是说，过程 ACCESS 会改变逻辑上的树上的链剖分，它将结点 v 到根结点的路径作为一条新的链。而这条链会把旧的链切割开。

在物理上的 Splay 的表现就是，Splay 中的一些树被断开与重组。

下图为 Link-Cut Trees 的一个结构示意图，及一次 ACCESS 操作的前后对比图。


首先，由于访问了点 v，那么它的 Preferred Child 应当消失。先将点 v 旋转到它所属的 Auxiliary Tree 的根，如果 v 在 v 所属的 Auxiliary Tree 中有右儿子(也就是 v 原来的 Preferred Child), 那么应该将 v 在 v 所属的 Auxiliary Tree 中的右子树(对应着它的原来的 Preferred Child 之下的 Preferred Path)从 v 所属的 Auxiliary Tree 中分离，并设置这个新的 Auxiliary Tree 的 Path Parent 为 v。然后，如果点 v 所属的 Preferred Path 并不包含根结点，设它的 Path Parent 为 u，那么需要将 u 旋转 到 u 所属的 Auxiliary Tree 的根，并用点 v 所属的 Auxiliary Tree 替换到点 u 所属的 Auxiliary Tree 中 点 u 的右子树，再将原来点 u 所属的 Auxiliary Tree 中点 u 的右子树的 Path Parent 设置为 u。如此操作，直到到达包含根结点的 Preferred Path。

这里说的是对 Splay 的具体操作，对于访问的结点 v，伸展它到根，这样左子树的点在链的上方，右子树的点在链的下方。断开右子树即断开 v 在原树上与下方链的连接。

之后在 Splay 上将链的父结点 u 伸展到根，用 v 替换 u 的右子树，表现在逻辑树上就是将 u 下方的旧链替换成我们新的链。

在具体实现的时候，Splay 上的父亲与 Path Parent 可以在同一个数组上存储，当一个结点是它父结点的某个儿子时，它的父结点是 Splay 上的父结点，否则是 Path Parent。

 

Find Root

在 ACCESS(v) 之后，根结点一定是 v 所属的 Auxiliary Tree 的最小结点，我们先把 v 旋转到它所属 的 Auxiliary Tree 的根。再从 v 开始, 沿着 Auxiliary Tree 向左走，直到不能再向左，这个点就是我们要找的根结点。由于使用的是 Splay Tree 数据结构保存 Auxiliary Tree，我们还需要对根结点进行 Splay 操作。

在访问过 v 之后，v 与树的根就在同一个链上了，在 Splay 中就是属于同一棵平衡树。这样 v 所在的平衡树的最左结点就是链的头结点即根结点。

对根结点伸展是为了保证 Splay 的平衡。其实不做也没关系？

 

Cut

先访问 v，然后把 v 旋转到它所属的 Auxiliary Tree 的根，然后再断开 v 在它的所属 Auxiliary Tree 中 与它的左子树的连接，并设置。

显然，v 到根的路径属于同一条链，保存在 Splay 上的同一棵平衡树中，此时 v 为平衡树的根，左子树在链的上方，右子树在链的下方，断开左子树就是断开逻辑树上的父边。

 

Join

先访问 v，然后修改 v 所属的 Auxiliary Tree 的 Path Parent 为 w，然后再次访问 v。

实际上似乎有一种方法可以直接合并两棵无根树？具体写法见模板。

大致思路是，对于要连接的两点 v、w，先访问 v，再访问 w，之后伸展 v 到根，此时 v 只有左子树没有右子树，因为 v 是剖分出的链的最底端，然后给 v 打一个延迟翻转标记，设他的父亲为 w。之后在每次伸展操作之前，找到要伸展的点的所有的父结点，然后从上到下维护翻转操作。

这样做的原理是，访问 v 剖分出 v 到根的路径，然后将这个路径翻转，也就是树的其它结构不变，而这个把 v 提升到路径的最顶端，而原来的根成为了路径的最底短。

 

算法模板

SPOJ OTOCI

3种操作，将不属于同一棵树的两点间建一条边，查询两点路径上的点权和，修改某点的权值。

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MaxNode=31000;

int Lch[MaxNode];
int Rch[MaxNode];
int Pnt[MaxNode];
int Data[MaxNode];
int Sum[MaxNode];
int Rev[MaxNode];
int List[MaxNode];
int Total;

inline bool isRoot(int t){
    return (!Pnt[t]||(Lch[Pnt[t]]!=t&&Rch[Pnt[t]]!=t));
}
inline void Update(int cur){
    Sum[cur]=Sum[Lch[cur]]+Sum[Rch[cur]]+Data[cur];
}
void Reverse(int cur){
    if (!Rev[cur]) return;
    swap(Lch[cur],Rch[cur]);
    Rev[Lch[cur]]^=1;
    Rev[Rch[cur]]^=1;
    Rev[cur]=0;
}
void LeftRotate(int cur){
    if (isRoot(cur)) return;
    int pnt=Pnt[cur],anc=Pnt[pnt];
    Lch[pnt]=Rch[cur];
    if (Rch[cur]) Pnt[Rch[cur]]=pnt;
    Rch[cur]=pnt;
    Pnt[pnt]=cur;
    Pnt[cur]=anc;
    if (anc){
        if (Lch[anc]==pnt) Lch[anc]=cur;
        else if (Rch[anc]==pnt) Rch[anc]=cur;
    }
    Update(pnt);
    Update(cur);
}
void RightRotate(int cur){
    if (isRoot(cur)) return;
    int pnt=Pnt[cur],anc=Pnt[pnt];
    Rch[pnt]=Lch[cur];
    if (Lch[cur]) Pnt[Lch[cur]]=pnt;
    Lch[cur]=pnt;
    Pnt[pnt]=cur;
    Pnt[cur]=anc;
    if (anc){
        if (Rch[anc]==pnt) Rch[anc]=cur;
        else if (Lch[anc]==pnt) Lch[anc]=cur;
    }
    Update(pnt);
    Update(cur);
}
void Splay(int cur){
    int pnt,anc;
    List[++Total]=cur;
    for (int i=cur;!isRoot(i);i=Pnt[i]) List[++Total]=Pnt[i];
    for (;Total;--Total)
        if (Rev[List[Total]]) Reverse(List[Total]);
    while (!isRoot(cur)){
        pnt=Pnt[cur];
        if (isRoot(pnt)){// 父亲是根结点，做一次旋转
            if (Lch[pnt]==cur) LeftRotate(cur);
            else RightRotate(cur);
        }
        else{
            anc=Pnt[pnt];
            if (Lch[anc]==pnt){
                if (Lch[pnt]==cur) LeftRotate(pnt),LeftRotate(cur);// 一条线
                else RightRotate(cur),LeftRotate(cur);// 相反两次
            }
            else{
                if (Rch[pnt]==cur) RightRotate(pnt),RightRotate(cur);// 一条线
                else LeftRotate(cur),RightRotate(cur);// 相反两次
            }
        }
    }
}
int Expose(int u){
    int v=0;
    for (;u;u=Pnt[u]) Splay(u),Rch[u]=v,v=u,Update(u);
    for (;Lch[v];v=Lch[v]);
    return v;
}
void Modify(int x,int d){
    Splay(x);
    Data[x]=d;
    Update(x);
}
int Query(int x,int y){
    int rx=Expose(x),ry=Expose(y);
    if (rx==ry){
        for (int u=x,v=0;u;u=Pnt[u]){
            Splay(u);
            if (!Pnt[u]) return Sum[Rch[u]]+Data[u]+Sum[v];
            Rch[u]=v;
            Update(u);
            v=u;
        }
    }
    return -1;
}
bool Join(int x,int y){
    int rx=Expose(x),ry=Expose(y);
    if (rx==ry) return false;
    else{
        Splay(x);
        Rch[x]=0;
        Rev[x]=1;
        Pnt[x]=y;
        Update(x);
        return true;
    }
}
void Cut(int x){
    if (Pnt[x]){
        Expose(x);
        Pnt[Lch[x]]=0;
        Lch[x]=0;
        Update(x);
    }
}
int n,Q;

void init(){
    Total=0;
    memset(Rev,0,sizeof(Rev));
    memset(Pnt,0,sizeof(Pnt));
    memset(Lch,0,sizeof(Lch));
    memset(Rch,0,sizeof(Rch));
    memset(Sum,0,sizeof(Sum));
}
char cmd[22];
int main()
{
    init();
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",&Data[i]);
    scanf("%d",&Q);
    while (Q--){
        int x,y;
        scanf("%s%d%d",cmd,&x,&y);
        if (cmd[0]=='p'){
            Modify(x,y);
        }
        if (cmd[0]=='b'){
            if (Join(x,y)) printf("yes\n");
            else printf("no\n");
        }
        if (cmd[0]=='e'){
            int ans=Query(x,y);
            if (ans==-1) printf("impossible\n");
            else printf("%d\n",ans);
        }
    }
    return 0;
}


SPOJ QTREE

一棵树，两种操作，询问路径上的边权最大值，修改边权。

由于LCT常数太大，我实在是搞不定这题。

kuangbin巨巨的代码能卡着过去，在这里贴一下。

http://www.cnblogs.com/kuangbin/p/3300217.html

/* ***********************************************
Author        :kuangbin
Created Time  :2013-9-3 21:06:05
File Name     :F:\2013ACM练习\专题学习\动态树-LCT\SPOJQTREE.cpp
************************************************ */

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <time.h>
using namespace std;

//对一颗树，进行两个操作：
//1.修改边权
//2.查询u->v路径上边权的最大值
const int MAXN = 10010;
int ch[MAXN][2],pre[MAXN];
int Max[MAXN],key[MAXN];
bool rt[MAXN];
void push_down(int r)
{
    
}
void push_up(int r)
{
    Max[r] = max(max(Max[ch[r][0]],Max[ch[r][1]]),key[r]);
}
void Rotate(int x)
{
    int y = pre[x], kind = ch[y][1]==x;
    ch[y][kind] = ch[x][!kind];
    pre[ch[y][kind]] = y;
    pre[x] = pre[y];
    pre[y] = x;
    ch[x][!kind] = y;
    if(rt[y])
        rt[y] = false, rt[x] = true;
    else 
        ch[pre[x]][ch[pre[x]][1]==y] = x;
    push_up(y);
}
void P(int r)
{
    if(!rt[r])P(pre[r]);
    push_down(r);
}
void Splay(int r)
{
    //P(r);
    while( !rt[r] )
    {
        int f = pre[r], ff = pre[f];
        if(rt[f])
            Rotate(r);
        else if( (ch[ff][1]==f)==(ch[f][1]==r) )
            Rotate(f), Rotate(r);
        else
            Rotate(r), Rotate(r);
    }
    push_up(r);
}
int Access(int x)
{
    int y = 0;
    do
    {
        Splay(x);
        rt[ch[x][1]] = true, rt[ch[x][1]=y] = false;
        push_up(x);
        x = pre[y=x];
    }
    while(x);
    return y;
}
//调用后u是原来u和v的lca,v和ch[u][1]分别存着lca的2个儿子
//(原来u和v所在的2颗子树)
void lca(int &u,int &v)
{
    Access(v), v = 0;
    while(u)
    {
        Splay(u);
        if(!pre[u])return;
        rt[ch[u][1]] = true;
        rt[ch[u][1]=v] = false;
        push_up(u);
        u = pre[v = u];
    }
}

void change(int u,int k)
{
    Access(u);
    key[u] = k;
    push_up(u);
}
void query(int u,int v)
{
    lca(u,v);
    printf("%d\n",max(Max[v],Max[ch[u][1]]));
}

struct Edge
{
    int to,next;
    int val;
    int index;
}edge[MAXN*2];
int head[MAXN],tot;
int id[MAXN];

void addedge(int u,int v,int val,int index)
{
    edge[tot].to = v;
    edge[tot].next = head[u];
    edge[tot].val = val;
    edge[tot].index = index;
    head[u] = tot++;
}
void dfs(int u)
{
    for(int i = head[u];i != -1;i = edge[i].next)
    {
        int v = edge[i].to;
        if(pre[v] != 0)continue;
        pre[v] = u;
        id[edge[i].index] = v;
        key[v] = edge[i].val;
        dfs(v);
    }
}
void init()
{
    tot = 0;
    memset(head,-1,sizeof(head));
}
int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int T;
    int n;
    int u,v,w;
    char op[20];
    scanf("%d",&T);
    while(T--)
    {
        init();
        scanf("%d",&n);
        for(int i = 0;i <= n;i++)
        {
            pre[i] = 0;
            ch[i][0] = ch[i][1] = 0;
            rt[i] = true;
        }
        Max[0] = -2000000000;
        for(int i = 1;i < n;i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            addedge(u,v,w,i);
            addedge(v,u,w,i);
        }
        pre[1] = -1;
        dfs(1);
        pre[1] = 0;
        while(scanf("%s",&op) == 1)
        {
            if(op[0] == 'D')break;
            scanf("%d%d",&u,&v);
            if(op[0] == 'C')
                change(id[u],v);
            else query(u,v);
        }
    }
    return 0;
}



cyendra
关注
专栏目录
「数据结构」Link-Cut Tree(LCT)
qq_45562973的博客
01-28 1208
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 #1.0 简述 #1.1 动态树问题 维护一个森林，支持删除某条边，加入某条边，并保证加边、删边之后仍然是森林。我们需要维护这个森林的一些信息。 一般的操作有两点连通性，两点路径权值和等等。 #1.2 实链剖分 先来回顾一下树链剖分，我们可以按照子树大小进行剖分（重链剖分），也
浅谈Link-Cut Tree(LCT)
dingzongdu1901的博客
01-01 389
0XFF 前言&概念 Link-Cut Tree 是一种用来维护动态森林连通性的数据结构，适用于动态树问题。它采用类似树链剖分的轻重边路径剖分，把树边分为实边和虚边，并用 Splay 来维护每一条实路径。Link-Cut Tree 的基本操作复杂度为均摊O(logn），但常数因子较大，一般效率会低于树链剖分。但是却可以解决树链剖分解决不了的问题(或者优化码量) -----M...
学习笔记-动态树Link-Cut-Tree
weixin_30443747的博客
03-09 144
--少年你有梦想吗？ --少年你听说过安利吗？ 安利一个集训队讲解：http://wenku.baidu.com/view/75906f160b4e767f5acfcedb 关于动态树问题，有多种方法。。LCT是其中比较常用的方法； LCT这种东西根本没用----by ShallWe ----你真的确定吗（charge） 我之前非常确定。 。。。。。。。。。 LCT...
link-cut tree
Tgop_Knight的专栏
03-22 4234
自己简单研究了下动态树，就先来一发博客吧 动态树问题 link cut tree 实现的技巧
QTREE解法优化研究：动态树问题与全局平衡二叉树
本文主要探讨的是SPOJ375QTREE问题的高效解法，作者Yang Zhe深入研究了动态树问题（Dynamic Tree Problems）并提出了多种解决方案，包括Link-Cut Trees、Splay Trees以及一种静态的“全局平衡二叉树”数据结构。...
QTREE解法的一些研究 - Yang Zhe1
08-03
QTREE解法的研究主要集中在动态树问题(Dynamic Tree Problems)上，这是一类在数据结构和算法领域中具有挑战性的题目。动态树问题通常涉及到树结构的不断改变，包括节点的添加、删除以及查询等操作，需要高效地处理...
QTREE解法优化研究：动态树问题与高效算法
Link-Cut Trees是一种强大的数据结构，适用于处理动态树问题，但它的性能在处理QTREE问题时并不理想，因为它没有充分利用问题的特性。 作者随后引入了一个利用问题特性的新解法，该方法的时间复杂度为O(n+qlog2n)，...
QTREE解法优化研究：动态树问题与高效算法探讨
文章首先介绍了Link-Cut Trees，这是一种支持多种操作且具有O((n+q)logn)时间复杂度的数据结构，但因其未充分利用问题特性，实际效率并不高。 Link-Cut Trees由以下几个核心操作组成： 1. Access：找到树中的一个...
动态树问题与新Rake&Compress方法
"现有结果-动态树问题及其应用" 在图论中，动态树问题（Dynamic Trees Problem）是一个核心的挑战，它涉及到处理一个不断变化的树形结构，并且需要支持对树的形态和权值信息的操作。这个问题具有重要的理论和实际...
Link-Cut-Tree
呆头呆脑没有烦恼
06-07 392
What is Link-Cut-Tree？动态树（Link-Cut-Tree），也称LCT，是一种可以维护一个有根树森林改变形态、合并、分离、查询等操作的数据结构。由Robert Tarjan（他可以说是算法大师了，前面的文章中我是提过他的）为首的团队提出。在学习动态树前，要先明白splay的原理。在下面的一段中，会详细介绍splay的rotate与splay两个操作，请大家暂时忘掉有根树森林之...
Link Cut Tree
sky123博客
01-28 449
Link Cut Tree LCT用来解决动态树问题，即带修改边的树剖。 类似于树剖，LCT也会把树的每条边分为实边和虚边。若干个实边相连构成实链，每一条实链的深度是严格递增且任意两条实链之间相隔一条虚边。 重要性质： 每一个 Splay 通过其中序遍历维护一条从上到下在原树中的深度严格递增的实链。 虚边总是由一棵Splay指向该Splay中中序遍历最靠前的点在原树中的父亲。 关键操作： access§ 把从原树的根到 ppp 的路径上的点拉成一条实链放到一个splay中，完成后会有一条从根节点到 pp
Link-Cut Tree
Virgil's Blog
06-20 469
Link-Cut Tree 由于本文涉及的许多专有名词并没有统一的中文译名，所以本文译名与其他资料不尽相同，尽请谅解。 概念 动态树问题, 即要求我们维护一个由若干棵子结点无序的有根树组成的森林. 要求这个数据结构支持对树的分割, 合并, 对某个点到它的根的路径的某些操作, 以及对某个点的子树进行的某些操作. Link-Cut Tree, LCT 是一种能快速解决动态树问题的数据结
Link-Cut Tree(动态树)
ICEEBBING的博客
01-10 476
前言 好像没什么。（湘妹好乖！！！） 进入正题： 动态树 动态树问题 ** 若无特殊说明，文中的树指的大多是原树，而非辅助树 定义 维护一个包含N个点的森林,并且支持形态和权值信息的操作。 形态信息 Link(u,v)Link(u, v)Link(u,v) // 添加边(u,v)(u, v)(u,v) Cut(u,v)Cut(u, v)Cut(u,v) // 删除边(u,v)(u, v)(u,v...
Link/Cut Tree
最新发布
Video_game的博客
01-22 973
从辅助树根出发，只要有实边就向左走，最终到达的点即为根。LCT(Link/Cut-Tree)，又名实链剖分。像这类问题，存在加边和删边操作，被称为动态树问题。由于辅助树上的节点按中序遍历标记深度，那么。中存在一个细节：所有路径上的点都为右儿子。不多说，但有一点不一样，已在代码中标注。构成的，多个辅助树结构就构成了森林。有了前面的函数，这两个函数很好解决。前置知识：Splay，树链剖分。原树的根位于辅助树根节点所在。到根节点的所有边都变为实边。想要成为根，就要反转这颗。如图，现在我们有一棵原树。
Link_Cut_Tree
青烟绕指柔的博客
12-10 178
LCT就是动态树的一种，但是相比Top_Tree来说，处理子树能力不足（但是简单）。 LCT利用轻重路径的划分，也就是实边和虚边来实现边的删除和合并。 现在来说说LCT的几个重要操作：（默认会splay） access(x) : 让x连到根上面，也就是让根到x的边全部变为实边。所以我们每次让当前节点splay到根，改变儿子，向上pushup传递信息即可。 makeroot(x) : 让x为根，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值