LCA(最近公共祖先) 算法笔记

早上的菜饼

已于 2022-02-24 09:28:28 修改

阅读量279

点赞数

分类专栏：算法笔记文章标签：算法树结构

于 2022-02-24 09:23:22 首次发布

本文链接：https://blog.csdn.net/Ssinon/article/details/123085587

版权

算法笔记专栏收录该内容

1 篇文章 0 订阅

订阅专栏

0x00 前置知识

建图，倍增，DFS

0x10 引入

我们可以考虑这样一个问题，在一个确定根节点的树形结构中，如何求任意两个结点的最近公共祖先(Lowest Common Ancestor)。

本文使用LCA简称最近公共祖先
使用(a,b)表示节点对

以下是一个树形结构的示意图，我们试求每个节点的LCA：
在这里插入图片描述

问题a.求(5，6)的LCA
很显然，节点5和节点6的父节点为3，是他们的 $L C A$ ，而节点1虽然是他们的共同祖先节点，但不为最近的祖先节点。
问题b.求(4，2)的LCA
节点4的父亲节点即为结点2，所以节点2是他们的 $L C A$ 。
问题c.求(4，5)的LCA
由图上易看出 $L C A$ 为节点2，为了不找到他们 $L C A$ 的祖先节点，比如节点1。我们的想法是先查找深度更大的节点(如节点5)。直到查找位置与另一节点(如节点4)深度一致时，再将问题转换为问题a即可。这也是我们求 $L C A$ 的基本方法。

对于一般的问题，可以用 $D F S$ 实现查找。如果该树形结构只有两条链，那么该方法最坏时间复杂度为 $O (n)$ 。如果有 $q$ 次查询,时间复杂度为 $O (q n)$ 。在 $n\ge 100000,q\ge 100000$ 即会超时。

0x20 倍增优化

很容易分析出问题的关键在如何快速使得查询节点的深度一致，我们想到的方法是倍增。我们假设有节点对(x,y)（其中x深度更大）。我们可以每次给查找位置缩小1，2，4，8，16…的深度，快速使得两者相等。

0x30 代码实现

0x31 声明

const int MAXN=300005;
int Log2[MAXN], fa[MAXN][20], dep[MAXN];
bool vis[MAXN];

vis[MAXN]作为dfs的标记数组，防止重复遍历节点。
Log2[MAXN]存储所需要的 $log_2x$ 的值，相较于log2()函数要快。
fa[x][y]存储该节点的祖先节点。包括它深度减 $2^0，2^1，2^2...$ 的节点，其中,x为该节点的标号，y为上述2的指数。特别的，该节点的父亲节点被记作f[cur][0]。
dep[MAXN]记录该节点的深度。
fa的第二维大小不应小于log2(MAXN)

0x32 建图

struct Edge
{
    int to, w, next;
}edges[MAXM<<1];
int head[MAXN], cnt;
inline void add(int from, int to, int w=1)
{
    edges[++cnt].w = w;
    edges[cnt].to = to;
    edges[cnt].next = head[from];
    head[from] = cnt;
}

我们使用图结构可以更简单的实现题设，这一个比较标准的链式向前星建图。
需要注意的是，需要建一个无向图，边的空间要乘以2(如edges[MAXM<<1])。

以后应该会补一下图的笔记，这里先不赘述了

0x33 预处理父亲节点

void dfs(int cur, int fath = 0)
{
    if (vis[cur])
        return;
    vis[cur] = true;
    // sign
    dep[cur] = dep[fath] + 1;
    fa[cur][0] = fath;
    for (int i = 1; i <= Log2[dep[cur]]; ++i)
        fa[cur][i] = fa[fa[cur][i - 1]][i - 1];
    for (int eg = head[cur]; eg != 0; eg = edges[eg].next)
        dfs(edges[eg].to, cur);
}

先用一个dfs遍历整张图，dep[cur] = dep[fath] + 1标记每个节点的深度,孩子节点比父亲节点深度加1。标记父亲节点。
其中核心的思想是：

for (int i = 1; i <= Log2[dep[cur]]; ++i)
        fa[cur][i] = fa[fa[cur][i - 1]][i - 1];

由于 $2^{n-1}·2^{n-1}=2^n$ ,我们求出当前节点 $v$ 的深度减 $2^{i-1}$ 的节点 $v^{'}$ ,再去求节点 $v^{'}$ 的深度减 $2^{i-1}$ 的节点，就能求出当前节点 $v$ 的深度减 $2^{i}$ 的节点。

最后dfs继续遍历整张图即可。
预处理的时间复杂度为 $O (n l o g n)$

LCA核心

int lca(int a, int b)
{
    if (dep[a] > dep[b])
        swap(a, b);
    while (dep[a] != dep[b])
        b = fa[b][Log2[dep[b] - dep[a]]];
    if (a == b)
        return a;
    for (int k = Log2[dep[a]]; k >= 0; k--)
        if (fa[a][k] != fa[b][k])
            a = fa[a][k], b = fa[b][k];
    return fa[a][0];
}

我们默认a节点的深度大，否则就交换。每当节点a，节点b的深度不等时，取出当前节点与b节点的深度差值，对其取log2，即得最大倍增的指数 $i$ ，求该节点深度减 $2^{i}$ 的节点。反复操作，使得深度相等。

当a，b相等时，返回其中之一即可。

否则，对当前深度取log2，求该节点深度减 $2^{i}$ 的节点，如果两节点符合问题a(见上文)的最简情况，即可返回。
查询的时间复杂度为 $O (l o g n)$

在这里插入图片描述

如求(5,4)的LCA，深度差为1， $log_21=0$ ，所以取到5的父亲节点3。现在两者深度相等，发现符合最简情况，返回节点2。

记得初始化Log2数组

for (int i = 2; i <= n; ++i)
        Log2[i] = Log2[i / 2] + 1;

dfs从根节点开始搜

0x40 模板

P3379【模板】最近公共祖先

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
const ll INF = 0x3f3f3f3f;
// <------------------------------->
#define endl "\n"
#define space " "
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define HACK freopen("test.in", "r", stdin);freopen("test.out", "w", stdout);
#define RT double rtime = 1.0 * clock() / CLOCKS_PER_SEC;cout<<"\nRuntime: "<<rtime<< " s.\n";
#define debug(x) cout<<"target is "<<x<<endl
#define debug_arr(arr) for(auto x:arr) cout<<x<<" "; cout<<"\n";
// <------------------------------->
const int MAXN=500005;
const int MAXM=500005;

int Log2[MAXN], fa[MAXN][20], dep[MAXN];
bool vis[MAXN];
// <------------------------------->
struct Edge
{
    int to, w, next;
}edges[MAXM<<1];
int head[MAXN], cnt;
inline void add(int from, int to, int w=1)
{
    edges[++cnt].w = w;
    edges[cnt].to = to;
    edges[cnt].next = head[from];
    head[from] = cnt;
}
// <------------------------------->
void dfs(int cur, int fath = 0)
{
    if (vis[cur])
        return;
    vis[cur] = true;
    dep[cur] = dep[fath] + 1;
    fa[cur][0] = fath;
    for (int i = 1; i <= Log2[dep[cur]]; ++i)
        fa[cur][i] = fa[fa[cur][i - 1]][i - 1];
    for (int eg = head[cur]; eg != 0; eg = edges[eg].next)
        dfs(edges[eg].to, cur);
}
int lca(int a, int b)
{
    if (dep[a] > dep[b])
        swap(a, b);
    while (dep[a] != dep[b])
        b = fa[b][Log2[dep[b] - dep[a]]];
    if (a == b)
        return a;
    for (int k = Log2[dep[a]]; k >= 0; k--)
        if (fa[a][k] != fa[b][k])
            a = fa[a][k], b = fa[b][k];
    return fa[a][0];
}

int main()
{
    IOS;
    #ifdef LOCAL_JUDGE
    HACK;
    #endif

    int n,m,root;
    cin>>n>>m>>root;
    for(int i=0;i<n-1;++i)
    {
        int a,b;
        cin>>a>>b;
        add(a,b);
        add(b,a);
    }

    for (int i = 2; i <= n; ++i)
        Log2[i] = Log2[i / 2] + 1;
    dfs(root);

    for(int i=0;i<m;++i)
    {
        int a,b;
        cin>>a>>b;
        cout<<lca(a,b)<<endl;
    }

    #ifdef LOCAL_JUDGE
    RT;
    #endif
    return 0;
}