首页 > 其他分享> > LCA 相关 && 树链剖分

LCA 相关 && 树链剖分

2022-08-15 00:03:50 作者：互联网

LCA

基本定义：最近公共祖先简称 LCA（Lowest Common Ancestor）。两个结点的最近公共祖先，就是这两个点的公共祖先里面，离根最远的那个。

简单来讲，就是两个点到根的路径上，深度最深的重合点

常用的求解方法：

朴素方法

每次选择深度较深的那个结点，往上走一步，直到两个结点重合，这个重合点就是 \(LCA\)

此方法查询一次 \(LCA\) 的时间复杂度为 \(O(n)\)

const int maxn = 5e5 + 10;
vector<int>gra[maxn];
int dep[maxn], fa[maxn];

// 预处理深度
void dfs(int now, int pre, int d)
{
    dep[now] = d;
    fa[now] = pre;
    for(int i=0; i<gra[now].size(); i++)
    {
        int nex = gra[now][i];
        if(nex == pre) continue;
        dfs(nex, now, d + 1);
    }
}

// 一步步向上求 LCA
int LCA(int a, int b)
{
    while(a != b)
    {
        if(dep[a] < dep[b]) swap(a, b);
        a = fa[a];
    }
    return a;
}

倍增法

上述方法慢的地方在于，每次都只走一步，因此我们优化的时候考虑每次走向上走 \(2^i\) 步

具体实现：

如果两个点深度不一致：选取较深的点，往上跳，直到深度一致
深度相同，判断一下是不是同一个点，如果是，则说明 \(LCA\) 就是该点，否则进行 步骤 3
两个点同时往上走，从大到小枚举，判断他们的第 \(k\) 级祖先是否相等，如果不相等，则证明肯定不是 LCA，往上跳
步骤 3 结束后，得到的应该是两个 \(LCA\) 的子结点，因此直接返回其中一个结点的父结点

第三个步骤，类似于二分的过程

接下来考虑如何计算所有结点的第 \(2^k\) 级祖先

设 \(x\) 结点的第 \(2^k\) 级祖先为 \(fa[x][k]\)

\(dfs\) 可以直接求出第 \(2^0\) 级祖先（父亲），即 \(fa[x][0]\)

考虑状态转移：\(fa[j][i] = fa[fa[j][i-1]][i-1]\)

因此我们只要先计算出所有结点的第 \(2^{i-1}\) 级祖先，就可以计算出其第 \(2^i\) 级祖先

预处理时间复杂度：\(O(nlogn)\)

询问一次 LCA 的时间复杂度：\(O(logn)\)

const int maxn = 5e5 + 10;
vector<int>gra[maxn];
int fa[maxn][25], dep[maxn];

// 求深度 以及 所有结点的第 0 级祖先
void dfs(int now, int pre, int cur)
{
    if(dep[now]) return;
    dep[now] = cur;
    fa[now][0] = pre;
    for(int i=0; i<gra[now].size(); i++)
    {
        int nex = gra[now][i];
        if(nex == pre) continue;
        dfs(nex, now, cur + 1);
    }
}

// 预处理
void init()
{
    for(int i=1; i<=20; i++)
        for(int j=1; j<=n; j++)
            fa[j][i] = fa[fa[j][i-1]][i-1];
}

// 查询 LCA
int LCA(int a, int b)
{
    if(dep[a] < dep[b]) swap(a, b);
    int dif = dep[a] - dep[b];
    for(int i=20; i>=0; i--)
    {
        if(dif >= (1 << i))
        {
            a = fa[a][i];
            dif -= 1 << i;
        }
    }
    if(a == b) return a;
    for(int i=20; i>=0; i--)
    {
        if(fa[a][i] != fa[b][i])
        {
            a = fa[a][i];
            b = fa[b][i];
        }
    }
    return fa[a][0];
}

树上两点的最短路径

树上最短路径显然就是从一个结点上升到 \(LCA\) 后再下降到另一个结点的路径

考虑如果多次询问两点间的最短路径：

考虑预处理 \(2^k\) 级祖先的时候，同时加上距离来预处理
考虑利用容斥：两个点到根的距离，再减去 \(LCA\) 到根的距离

显然第二种方法更优秀：\(O(n)\)

ll query(int u, int v)
{
    int lca = LCA(u, v);
    return dis[u] - dis[lca] * 2 + dis[v];
}

树上差分

树上差分用于树上两点间路径的区间修改，能做到修改时间复杂度 \(O(logn)\)，查询的时间复杂度为 \(O(n)\)

虽然这个时间复杂度上不及树链剖分，但是好写，核心代码就几行

我们定义点 \(x\) 的值为 \(val[x]\)，并且定义一个差分数组 \(dif\)，有 \(dif[x] = val[x] - \sum_{son_x}val[x]\)

根据上述的定义，我们可以先求子节点的值，再求本身的值，所以整个查询过程就是 \(dfs\) 的过程

代码的话其实可以不考虑点原始的初始值，只用给 \(dif\) 数组进行操作就行，最终的答案就是修改后的增值 + 初始值

const int maxn = 1e5 + 10;
int dif[maxn];
void dfs(int now, int pre)
{
    for(int nex : gra[now])
    {
        if(nex == pre) continue;
        dfs(nex, now);
        dif[now] += dif[nex];
    }
}

考虑修改的过程：

如果让树上一个点的 \(dif[u] + x\)，根据查询的过程，就会将树上从 \(u\) 到根的整一条链都加上一个值，如果在这条链上的某个点 \(v\) 同样进行 \(dif[fa[v]] - x\) 的操作，我们就使链 \(u\) 到 \(v\) 区间加和了 \(x\)

将 \(4\) 号结点视为 \(u\)

将 \(3\) 号结点视为 \(v\)

无论是怎样的两点之间树上路径，我们都可以将其差分成两个直链

因此树上差分可以写成以下方式

inline void add (int u, int v, int x)
{
    int lca = LCA(u, v);
    dif[u] += x;
    dif[u] += x;
    dif[lca] -= x;
    dif[fa[lca]] -= x;
}

有的时候并不是维护树上点权，而是维护树上边权，就要考虑将边权化为点权

我们可以利用树上每个点仅有一条边是指向根的方向，将所有的边权视为它深度较深的点的点权

但是差分的时候并不用考虑 \(LCA\) 的值，因此是变成两个不相交的直链

inline void add(int u, int v, int x)
{
    int lca = LCA(u, v);
    dif[u] += x;
    dif[v] += x;
    dif[lca] -= x * 2;
}

\(dfs\) 序

\(dfs\) 序：每个结点在 \(dfs\) 深度优先遍历中的进出栈的时间序列

const int maxn = 1e5 + 10;
int dfn[maxn], tp = 0;
void dfs(int now, int pre)
{
    tp++;
    dfn[now] = tp;
    for(int i=0; i<gra[now].size(); i++)
    {
        int nex = gra[now][i];
        if(nex == pre) continue;
        dfs(nex, now);
    }
}

\(dfs\) 序，其实相当于重新给每个点进行编号，根据搜索回溯的过程，可以发现子树上的 \(dfn\) 序是连续的一段

在上述的基础上，我们可以以子树为单位维护一些信息

例如：子树上所有点都加上 \(x\)，我们可以直接套用分块、线段树、树状数组 等数据结构，将其视为连续序列，直接修改

因此我们的 \(dfs\) 序要维护两个东西，子树中，连续 \(dfn\) 的左端和右端

const int maxn = 1e5 + 10;
int dfn[maxn], bot[maxn], tp = 0;
void dfs(int now, int pre)
{
    tp++;
    dfn[now] = tp;
    for(int i=0; i<gra[now].size(); i++)
    {
        int nex = gra[now][i];
        if(nex == pre) continue;
        dfs(nex, now);
    }
    bot[now] = tp;
}

针对于 \(dfs\) 序，还有另外一种写法：每进入和回溯的时候都记录一下当时的时间戳，并让时间戳 \(+1\)

这样做的好处是，\(O(n)\) 预处理后，可以在 \(O(1)\) 的复杂度下，判断两个点之间的祖先关系

const int maxn = 1e5 + 10;
int in[maxn], out[maxn], tp = 0;
void dfs(int now, int pre)
{
    dfn[now] = ++tp;
    for(int i=0; i<gra[now].size(); i++)
    {
        int nex = gra[now][i];
        if(nex == pre) continue;
        dfs(nex, now);
    }
    out[now] = ++tp;
}

inline bool is_ance(int u, int v)
{
    return in[u] <= in[v] && out[u] >= out[v];
}

上述这种维护方式也可以引申出一个 欧拉序 的求解 \(LCA\) 的做法：将 \(LCA\) 问题在 \(O(n)\) 的复杂度下，转化为 \(RMQ\) 问题

树链剖分

树链剖分的形式有很多种：重链剖分、长链剖分、\(LCT\) 中的剖分，我们下面讲的是重链剖分

考虑在树上求解一些区间问题：

子树区间修改、查询
两点之间路径的修改、查询

上述所说的 \(dfn\) 序能够很好的处理第一个问题，但是第二个问题仍得到不到解决

思考我们现有的区间修改数据结构：差分、分块、线段树、树状数组

线段树和树状数组要求是在下标连续的区间内作修改，因此我们考虑能不能利用 \(dfn\) 序，将一棵树剖分成若干条链，然后维护每一条链上的信息，做到区间修改

构造重链剖分

给出部分定义：

重子结点：该结点的子结点中子树最大的子结点，且每个结点最多只有一个重子结点，如果有多个最大的子结点，则选取其中一个作为其重子结点
轻子结点：除了重子结点外的所有子结点
重边：结点到重子结点的边
轻边：结点到轻子结点的边

\(dfs\) 的时候，就优先按照重子结点搜，形成一条条链

图源：oi-wiki

树链剖分总共要维护以下信息：

\(fa[x]\)：\(x\) 结点的父结点
\(dep[x]\)：\(x\) 结点所在的深度
\(siz[x]\)：以 \(x\) 为根的子树大小（所含结点数）
\(hson[x]\)：\(x\) 结点的重子结点
\(dfn[x]\)：\(x\) 结点的 \(dfs\) 序
\(rnk[x]\)：\(dfs\) 序的第 \(x\) 个结点，\(rnk[dfn[x]] = x\)
\(top[x]\)：\(x\) 结点所在链的链顶结点（深度最小）
\(bot[x]\)：以 \(x\) 为根的子树中，最大的 \(dfs\) 序

上述信息建议分成两次 \(dfs\) 来解决

第一次 \(dfs\) 维护：\(fa\)、\(dep\)、\(siz\)、\(hson\) 的信息

int dep[maxn], siz[maxn], hson[maxn], fa[maxn];
void dfs1(int now, int pre, int d)
{
    dep[now] = d;
    siz[now] = 1;
    hson[now] = -1;
    fa[now] = pre;
    for(auto nex : gra[now])
    {
        if(nex == pre) continue;
        dfs1(nex, now, d + 1);
        siz[now] += siz[nex];
        if(hson[now] == -1 || siz[hson[now]] < siz[nex])
            hson[now] = nex;
    }
}

第二次 \(dfs\) 维护：\(dfn\)、\(bot\)、\(rnk\)、\(top\)

int tp = 0;
int dfn[maxn], bot[maxn], rnk[maxn], top[maxn];
void dfs2(int now, int t)
{
    tp++;
    dfn[now] = tp;
    rnk[tp] = now;
    top[now] = t;
    if(hson[now] != -1)
    {
        dfs2(hson[now], t);
        for(auto nex : gra[now])
        {
            if(nex == fa[now] || nex == hson[now]) continue;
            dfs2(nex, nex);
        }
    }
    bot[now] = tp;
}

综上，可以保证每个结点属于且仅属于一条重链，树链剖分预处理的时间复杂度为：\(O(n)\)

树链剖分后，在树上遍历任意一条路径的时间复杂度：\(O(logn)\)

与启发式合并相类似，如果当前点处于一个轻边上，则每往上走一步，整颗子树的大小必然增大至少一倍

这样每个结点最多切换 \(logn\) 次轻边

重链剖分使用

求 \(LCA\)

分割重链之后，每次都选取两个结点所在的重链中，\(top\) 较深的那个，然后往上升，直到两个结点同处于一条链中

如果同处于一条链中，则 \(LCA\) 为深度较浅的那个点

int LCA(int a, int b)
{
    while(top[a] != top[b])
    {
        if(dep[top[a]] < dep[top[b]]) swap(a, b);
        a = fa[top[a]]; // 一定要记得到了链顶还要再往上走一步，上升到另外一条重链
    }
    return dep[a] < dep[b] ? a : b;
}

路径上维护信息

例题：Aladdin and the Return Journey

大意：给出一个树，每个点有点权，有两种操作：

给一个点的点权加上 \(x\)
求两个点的最短路径上的全部点权和

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
const int maxn = 3e4 + 10;
vector<int>gra[maxn];
int dep[maxn];
int siz[maxn];
int hson[maxn];
int fa[maxn];
int top[maxn];
int dfn[maxn];
int rnk[maxn];

int tr[maxn << 2];
int w[maxn]; // 每个点的起始点权

// 建树，特别要注意的是，建树是根据 dfn 来建树的！
// 这里的 l r 是 dfn 的值，而不是点的编号
void build(int now, int l, int r)
{
    if(l == r)
    {
        // rnk[l]，返回 dfn 第 l 个点的编号，然后赋初值
        tr[now] = w[rnk[l]];
        return;
    }
    int mid = l + r >> 1;
    build(now << 1, l, mid);
    build(now << 1 | 1, mid + 1, r);
    tr[now] = tr[now << 1] + tr[now << 1 | 1];
}

// 区间查询
int query(int now, int l, int r, int L, int R)
{
    if(L <= l && r <= R)
        return tr[now];
    int mid = l + r >> 1;
    int ans = 0;
    if(L <= mid)
        ans += query(now << 1, l, mid, L, R);
    if(R > mid)
        ans += query(now << 1 | 1, mid + 1, r, L, R);
    return ans;
}

// 单点修改
void update(int now, int l, int r, int x, int val)
{
    if(l == r)
    {
        tr[now] = val;
        return;
    }
    int mid = l + r >> 1;
    if(x <= mid)
        update(now << 1, l, mid, x, val);
    else
        update(now << 1 | 1, mid + 1, r, x, val);
    tr[now] = tr[now << 1] + tr[now << 1 | 1];
}

// 第一次 dfs
void dfs1(int now, int pre, int d)
{
    siz[now] = 1;
    hson[now] = -1;
    dep[now] = d;
    fa[now] = pre;
    for(int i=0; i<gra[now].size(); i++)
    {
        int nex = gra[now][i];
        if(nex == fa[now]) continue;
        dfs1(nex, now, d + 1);
        siz[now] += siz[nex];
        if(hson[now] == -1 || siz[hson[now]] < siz[nex])
            hson[now] = nex;
    }
}

int tp = 0;
// 第二次 dfs
void dfs2(int now, int t)
{
    top[now] = t;
    tp++;
    dfn[now] = tp;
    rnk[tp] = now;
    if(hson[now] != -1)
    {
        dfs2(hson[now], t);
        for(int i=0; i<gra[now].size(); i++)
        {
            int nex = gra[now][i];
            if(nex == fa[now] || nex == hson[now]) continue;
            dfs2(nex, nex);
        }
    }
}

// 初始化
void init(int n, int rt = 1)
{
    tp = 0;
    dfs1(rt, rt, 1);
    dfs2(rt, rt);
    build(1, 1, n);
    for(int i=0; i<=n; i++) gra[i].clear();
}

int solve(int a, int b, int n)
{
    int ans = 0;
    // 在寻找 LCA 的过程中，顺便统计路径上的全部值
    while(top[a] != top[b])
    {
        if(dep[top[a]] < dep[top[b]]) swap(a, b);
        ans += query(1, 1, n, dfn[top[a]], dfn[a]);
        a = fa[top[a]];
    }
    if(dep[a] > dep[b]) swap(a, b);

    // 在同一条链上的时候统计最后一段
    ans += query(1, 1, n, dfn[a], dfn[b]);
    return ans;
}

int main()
{
    int t;
    scanf("%d", &t);
    for(int casee=1; casee<=t; casee++)
    {
        printf("Case %d:\n", casee);
        int n;
        scanf("%d", &n);
        for(int i=0; i<n; i++) scanf("%d", &w[i]);
        for(int i=1; i<n; i++)
        {
            int x, y;
            scanf("%d%d", &x, &y);
            gra[x].push_back(y);
            gra[y].push_back(x);
        }
        init(n, 0);
        int q;
        scanf("%d", &q);
        while(q--)
        {
            int x;
            scanf("%d", &x);
            if(x == 0)
            {
                int i, j;
                scanf("%d%d", &i, &j);
                // 询问
                printf("%d\n", solve(i, j, n));
            }
            else
            {
                int i, v;
                scanf("%d%d", &i, &v);
                // 单点修改
                update(1, 1, n, dfn[i], v);
            }
        }
    }
    return 0;
}

题单

题号	题目	标签	难度	题解
洛谷-P3379	【模板】最近公共祖先（LCA）	LCA	1	标签：结点,剖分,int,树链,maxn,&&,LCA,now 来源： https://www.cnblogs.com/dgsvygd/p/16586730.html 电脑版 - 返回首页 2017-2022 Icode9.COM , All Rights Reserved.