Link Cut Tree（LCT )学习笔记

最新推荐文章于 2024-01-22 22:38:12 发布

置顶 YxuanwKeith

最新推荐文章于 2024-01-22 22:38:12 发布

阅读量3k

点赞数 9

分类专栏：算法-动态树算法-数据结构

本文链接：https://blog.csdn.net/YxuanwKeith/article/details/50991326

版权

算法-数据结构同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

算法-动态树

4 篇文章 0 订阅

订阅专栏

先来说一说什么是Link Cut Tree

在数据结构中有一类问题叫做动态树问题 $（Dynamic Tree）$ ，它会要求你对一颗树进行切割和拼接，然后再在上面维护传统的数据结构能维护的值，为了完成这一类问题，就有了很多相应的算法来解决这类问题，Link Cut Tree就是其中一种比较方便实用的算法。

Link Cut Tree的实现

由于本文主要写的是有关操作，所以具体的算法内容只作简单说明，详细的介绍可以参考《QTREE解法的一些研究》中对LCT的解释。

简单的讲一讲，其实 $LCT$ 的核心就是 $Access$ 操作，取出一个点到根的链。再用一种可合并的平衡树来维护这条链的信息，平衡树中一个点的做左儿子就是在原树中这个点上方的节点，相应的右节点就是下方的节点，而我们选择用 $Splay$ 来作为实现他的数据结构。其实差不多就是拿 $Splay$ 维护重链的树链剖分
接下来解就是本文的关键。

有关Link Cut Tree的基础操作

如果需要维护一些值时，可以用Splay直接维护。
注意：这里给的模板都是把LCT和原树一起记录的。(在IsRoot中会有所说明)

Update / Push（上传和下传标记）

根据题目的需要来维护，跟线段树维护差不多。

IsRoot（判断当前点是否是所在平衡树的根）

设当前节点为 $Now$ 。当它不是根时， $Pre[Now]$ 就表示平衡树中的父亲，而真正的父亲根据平衡树的定义在当前平衡树中找到。当它是根时， $Pre[Now]$ 就表示原树中它所在 $Splay$ 中深度最小的点的父亲。
而 $Son$ 表示的是平衡树中的儿子，那么显然 $Now$ 只要不是 $Pre[Now]$ 的其中一个儿子，那么它就是根。

//IsRoot
bool IsRoot(int Now) { 
    return Son[Pre[Now]][0] != Now && Son[Pre[Now]][1] != Now;
}

Reverse（翻转）

通过交换两个儿子来改变位置关系，再把标记下传实现序列翻转。

//Reverse
void Reverse(int Now) {
    if (Rev[Now]) {
        Rev[Son[Now][0]] ^= 1, Rev[Son[Now][1]] ^= 1;
        swap(Son[Now][0], Son[Now][1]);
        Rev[Now] = 0;
    }
}

Splay

把一个节点 $Splay$ 后就可以对整颗平衡树进行操作，询问或是进行一些别的处理。
这是学会 $LCT$ 的基础，不做详细解释。
给出一种简洁的打法。

//Splay
void Rotate(int Now) {
    int Fa = Pre[Now], Gran = Pre[Fa], Side = (Son[Fa][1] == Now);
    if (!IsRoot(Fa)) Son[Gran][Son[Gran][1] == Fa] = Now;
    Pre[Fa] = Now, Pre[Now] = Gran;
    Son[Fa][Side] = Son[Now][!Side], Pre[Son[Fa][Side]] = Fa;
    Son[Now][!Side] = Fa;
    Update(Fa), Update(Now);
}

void Splay(int Now) {
    static int D[MAXN], top;
    D[top = 1] = Now;
    for (int p = Now; !IsRoot(p); p = Pre[p]) D[++ top] = Pre[p];
    for (; top; top --) Reverse(D[top]);
    for (; !IsRoot(Now); Rotate(Now)) {
        int Fa = Pre[Now], Gran = Pre[Fa];
        if (IsRoot(Fa)) continue;
        (Son[Fa][0] == Now) ^ (Son[Gran][0] == Fa) ? Rotate(Now) : Rotate(Fa);
    }
    Update(Now);
}

Access

其实 $Access$ 就是把原树中的一个点到根的路径上的点放到同一颗平衡树中（这颗平衡树中没有其他点）。
$LCT$ 的和核心操作，这里只是最基础的版本，如要实现其他更能可以自行添加。
$Now$ 表示当前 $Access$ 跳到的节点， $t$ 表示已经构造完的节点组成的平衡树。现在考虑怎么把t和 $Now$ 合并起来。

由于一颗平衡树中的节点构成的都是一条指向根的链（不一定包括根），在 $Now$ 所在平衡树中 $Now$ 上方的点（原树）都是我们会跳到的，这些节点对我们是有用的，而没用的就是 $Now$ 所在的平衡树中在 $Now$ 下方的点（原树），只需删去就好了。

可以把 $Now$ 转到平衡树的根（ $Splay$ ），那么它的右儿子就是在原树中在它下方的点构成的平衡树，只要把这棵树换成t就可以把两条链所在的平衡树和并起来。

代码比较简洁。

//Access
void Access(int Now) {
    for (int t = 0; Now; Son[Now][1] = t, t = Now, Now = Pre[Now]) Splay(Now);
}

GetFa（找原树中的父亲节点）

假设是要求 $Now$ 的父亲。当然，首先就是把 $Now$ 和 $Now$ 的父亲放到一颗平衡树中（ $Access$ ），把 $Now$ 旋到当前平衡树的根后，就是要找在我上面的最下面的点。那么根据 $Son$ 的定义跑一遍就行了。

//GetFa
int GetFa(int Now) {
    Access(Now), Splay(Now);
    Now = Son[Now][0];
    while (Son[Now][1]) Now = Son[Now][1];
    return Now;
}

MakeRoot（换根操作）

顾名思义，把一个节点变成当前LCT根节点，假设这个节点是Now。
我们发现，当把 $Now$ 作为新的根时，只有 $Now$ 到根路径上的从属关系发生了改变（就是儿子和父亲），而且更优美的是， $Now$ 变成新的根后，这种从属关系刚好翻转了。举个例子，设Pre[i]为i节点的父亲节点，那么假如原来的关系是
$Pre[a1] = a2, Pre[a2] = a3, Root = a3$
$a1$ 作为根后就变成了
$Pre[a3] = a2, Pre[a2] = a1, Root = a1$
这就对应了Reverse操作。

所以我们可以把 $Now$ 到根路径上的点找出来（ $Access$ ），再把 $Now$ 旋到对应平衡树的根（ $Splay$ ），再对这可平衡树打一个翻转标记，就玩成了还根操作。

//MakeRoot
void MakeRoot(int Now) {
    Access(Now); Splay(Now); Rev[Now] ^= 1;
}

Link（连接两棵树）

很简单，直接把一棵树变为它所在树的根，在把这整颗树接到另一棵树上。

//Link
void Link(int u, int v) {
    MakeRoot(u), Pre[u] = v;
}

Cut（切断一条边）

假设我们要切断 $u$ 和 $v$ 的边。由于它们所在的不是一颗普通的树，所以不能简单的表示它们之间的边。我们先要把它们丢进同一颗平衡树里面。显然的，可以 $u$ 先 $MakeRoot$ ，那么现在 $u$ 必定是v的父亲（原来不确定），再把 $v$ 进行 $Access$ 。现在可以保证的是，在当前的平衡树中只有 $u， v$ 两个点，把 v <script type="math/tex" id="MathJax-Element-51">v</script>旋转到所在平衡树的根确定平衡树中的位置后，直接断开即可。

//Cut
void Cut(int u, int v) {
    MakeRoot(u), Access(v), Splay(v);
    Pre[u] = Son[v][0] = 0; 
}

模板题

NOI2005 维护数列

splay模板题
题目（BZOJ）：http://www.lydsy.com/JudgeOnline/problem.php?id=1500
代码：

//NOI2005 维护数列 YxuanwKeith
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

const int MAXN = 1e6, Inf = -1e6;

int N, M, Root, top, D[MAXN], A[MAXN];
int tot, Pre[MAXN], Son[MAXN][2], MaxL[MAXN], MaxR[MAXN], MaxM[MAXN], Val[MAXN], Size[MAXN], Same[MAXN], Sum[MAXN];
bool Rev[MAXN];
char S[20];

void Push(int Now) {
    if (!Now) return;
    if (Same[Now] != Inf) {
        Val[Now] = Same[Now], Sum[Now] = Size[Now] * Val[Now];
        if (Same[Now] >= 0) MaxL[Now] = MaxR[Now] = MaxM[Now] = Sum[Now]; else
            MaxL[Now] = MaxR[Now] = 0, MaxM[Now] = Val[Now];
        Same[Son[Now][0]] = Same[Son[Now][1]] = Same[Now];
        Same[Now] = Inf;
    }
    if (Rev[Now]) {
        Rev[Son[Now][0]] ^= 1, Rev[Son[Now][1]] ^= 1;
        swap(Son[Now][0], Son[Now][1]), swap(MaxL[Now], MaxR[Now]);
        Rev[Now] = 0;
    }
}

void Updata(int Now) {
    int l = Son[Now][0], r = Son[Now][1];
    Push(l), Push(r);
    Size[Now] = Size[l] + Size[r] + 1, Sum[Now] = Val[Now] + Sum[l] + Sum[r];
    MaxR[Now] = max(MaxR[r], Sum[r] + MaxR[l] + Val[Now]);
    MaxL[Now] = max(MaxL[l], Sum[l] + MaxL[r] + Val[Now]);
    MaxM[Now] = max(max(MaxM[l], MaxM[r]), MaxR[l] + MaxL[r] + Val[Now]);
}

int Get(int Goal) {
    int Now = Root;
    for (; ;) {
        Push(Now);
        int Num = Size[Son[Now][0]] + 1;
        if (Num == Goal) return Now;
        if (Num < Goal) Goal -= Num, Now = Son[Now][1]; else Now = Son[Now][0];
    }
}

void Rotate(int Now) {
    int Fa = Pre[Now], Gran = Pre[Fa];
    int Side = (Son[Fa][1] == Now);
    Pre[Now] = Gran, Pre[Fa] = Now;
    Son[Fa][Side] = Son[Now][!Side], Pre[Son[Fa][Side]] = Fa;
    Son[Now][!Side] = Fa;
    Son[Gran][Son[Gran][1] == Fa] = Now;
    Updata(Fa); Updata(Now);
}

void Splay(int Now, int Goal) {
    for (Push(Now); Pre[Now] != Goal; Rotate(Now)) {
        int Fa = Pre[Now], Gran = Pre[Fa];
        if (Pre[Fa] == Goal) continue;
        (Son[Gran][0] == Fa) ^ (Son[Fa][0] == Now) ? Rotate(Now) : Rotate(Fa); 
    }
    Updata(Now);
    if (!Goal) Root = Now;
}

int Build(int L, int R, int fa) {
    if (L > R) return 0;
    int nt = top ? D[top --] : ++ tot, Mid = (L + R) >> 1;
    Pre[nt] = fa, Val[nt] = A[Mid], Rev[nt] = 0, Same[nt] = Inf;
    Son[nt][0] = Build(L, Mid - 1, nt);
    Son[nt][1] = Build(Mid + 1, R, nt);
    Updata(nt);
    return nt;
}

void Merge(int l, int r) {
    Splay(Get(l), 0); Splay(Get(r), Root);
}

void Insert(int post, int num) {
    Merge(post + 1, post + 2);  
    int Now = Son[Root][1], Rt = Build(1, num, Now);
    Son[Now][0] = Rt;
    Updata(Now), Updata(Root);
}

void Del(int Now) {
    if (!Now) return;
    D[++ top] = Now;
    Del(Son[Now][0]), Del(Son[Now][1]);
}

void Delete(int post, int num) {
    Merge(post, post + num + 1);
    int Now = Son[Root][1];
    Del(Son[Now][0]);
    Son[Now][0] = 0;
    Updata(Now), Updata(Root);
}

void MakeSame(int post, int num, int same) {
    Merge(post, post + num + 1);
    int Now = Son[Root][1];
    Push(Now);
    Same[Son[Now][0]] = same;
    Updata(Now), Updata(Root);
}

void Reverse(int post, int num) {
    Merge(post, post + num + 1);
    int Now = Son[Root][1];
    Push(Now);
    Rev[Son[Now][0]] ^= 1;
    Updata(Now), Updata(Root);
}

void GetSum(int post, int num) {
    Merge(post, post + num + 1);    
    int Now = Son[Son[Root][1]][0];
    Push(Now);
    printf("%d\n", Sum[Now]);
}

void MaxSum() {
    Push(Root);
    printf("%d\n", MaxM[Root]);
}

int main() {
    scanf("%d%d", &N, &M);
    for (int i = 2; i <= N + 1; i ++) scanf("%d", &A[i]);  
    MaxM[0] = A[1] = A[N + 2] = Inf;
    Root = Build(1, N + 2, 0);
    for (int i = 1; i <= M; i ++) {
        scanf("%s", S);
        int post, num, same;
        if (S[2] != 'X') scanf("%d%d", &post, &num);
        if (S[0] == 'I') {
            for (int i = 1; i <= num; i ++) scanf("%d", &A[i]);
            Insert(post, num);
        } 
        if (S[2] == 'K') {
            scanf("%d", &same);
            MakeSame(post, num, same);
        }
        if (S[0] == 'D') Delete(post, num);
        if (S[0] == 'R') Reverse(post, num);
        if (S[0] == 'G') GetSum(post, num);
        if (S[2] == 'X') MaxSum();
    }
}

NOI2014 魔法森林

LCT模板题
题目（BZOJ）：http://www.lydsy.com/JudgeOnline/problem.php?id=3669
代码：

//NOI2014 魔法森林 YxuanwKeith
#include <cstring>
#include <cstdio>
#include <algorithm>

using namespace std;

const int MAXN = 300005, Inf = 1e9 + 7;

struct Node { int u, v, a, b;} Line[MAXN];

int N, M, Ans, Fa[MAXN];
int Max[MAXN], Pre[MAXN], Val[MAXN], Son[MAXN][2];
bool Rev[MAXN];

bool cmp(Node u, Node v) { return u.a < v.a;}

int Find(int x) { return Fa[x] == x ? x : Fa[x] = Find(Fa[x]);}

void Updata(int Now) {
    Max[Now] = Now;
    if (Val[Max[Now]] < Val[Max[Son[Now][0]]]) Max[Now] = Max[Son[Now][0]];
    if (Val[Max[Now]] < Val[Max[Son[Now][1]]]) Max[Now] = Max[Son[Now][1]];
}

bool IsRoot(int Now) { return Son[Pre[Now]][0] != Now && Son[Pre[Now]][1] != Now;}

void Reverse(int Now) {
    if (Rev[Now]) {
        Rev[Son[Now][0]] ^= 1, Rev[Son[Now][1]] ^= 1;
        swap(Son[Now][0], Son[Now][1]);
        Rev[Now] = 0;
    }
}

void Rotate(int Now) {
    int Fa = Pre[Now], Gran = Pre[Fa], Side = (Son[Fa][1] == Now);
    if (!IsRoot(Fa)) Son[Gran][Son[Gran][1] == Fa] = Now;
    Pre[Fa] = Now, Pre[Now] = Gran;
    Son[Fa][Side] = Son[Now][!Side], Pre[Son[Fa][Side]] = Fa;
    Son[Now][!Side] = Fa;
    Updata(Fa), Updata(Now);
}

void Splay(int Now) {
    static int D[MAXN], top;
    D[top = 1] = Now;
    for (int p = Now; !IsRoot(p); p = Pre[p]) D[++ top] = Pre[p];
    for (; top; top --) Reverse(D[top]);
    for (; !IsRoot(Now); Rotate(Now)) {
        int Fa = Pre[Now], Gran = Pre[Fa];
        if (IsRoot(Fa)) continue;
        (Son[Fa][0] == Now) ^ (Son[Gran][0] == Fa) ? Rotate(Now) : Rotate(Fa);
    }
    Updata(Now);
}

void Access(int Now) {
    for (int t = 0; Now; Son[Now][1] = t, t = Now, Now = Pre[Now]) Splay(Now);
}

void MakeRoot(int Now) {
    Access(Now); Splay(Now); Rev[Now] ^= 1;
}

void Link(int u, int v) {
    MakeRoot(u), Pre[u] = v;
}

void Query(int u, int v) {
    MakeRoot(u), Access(v), Splay(v);
}

void Cut(int u, int v) {
    Query(u, v);
    Pre[u] = Son[v][0] = 0; 
}


int main() {
    scanf("%d%d", &N, &M);
    for (int i = 1; i <= M; i ++) scanf("%d%d%d%d", &Line[i].u, &Line[i].v, &Line[i].a, &Line[i].b);
    for (int i = 1; i <= N; i ++) Fa[i] = i;
    sort(Line + 1, Line + 1 + M, cmp);

    Ans = Inf;
    for (int i = 1; i <= M; i ++) {
        int u = Line[i].u, v = Line[i].v, a = Line[i].a, b = Line[i].b;
        Val[i + N] = b;
        if (Find(u) == Find(v)) {
            Query(u, v);
            int Side = Max[v];
            if (Val[i + N] <= Val[Side]) {
                Cut(Side, Line[Side - N].u), Cut(Side, Line[Side - N].v);
                Link(i + N, u), Link(i + N, v);
            }
        } else {
            Fa[Fa[u]] = v; 
            Link(i + N, u), Link(i + N, v);
        }
        if (Find(1) == Find(N)) {
            Query(1, N);
            Ans = min(Ans, Val[Max[N]] + a);
        }
    }
    printf("%d", (Ans == Inf) ? -1 : Ans);
}