倍增法——解决LCA求树上两点最近公共祖先问题

在我们学过RMQ之后，我们知道了倍增法的原理，利用一个二的幂次来维护了每个以2为底数的区间长度。其实简单的说，就是一个合并问题，一个2可以有两个1组成，而一个4可以由两个2组成，以此类推。所以叫做倍增。倍增法通常能用以解决线性问题，譬如区间的最大值，当我们固定左端点的时候，当右端点不断向右移动的时候，不难发现，该区间的最大值也是单调不减的。

好了，一通乱讲之后该回归主题了。

现在，我们提出这样一个问题，我们是不是可以用倍增的方式来求得树上两个点的公共祖先呢？

譬如说，如图，有X和Y两个结点，我们想知道他俩的最近公共祖先呢？

给每个结点打上序号标记，方便之后的讲解：

于是乎，我们想知道X和Y的最近公共祖先，我们可以每次让X上升一格，让Y也上升一格，看看他俩的祖先是不是相同的。

【第一步】X会走到2，Y会走到3号结点，发现他两不相同，继续走；

【第二步】X走到1，Y走到1，他俩相同，退出，找到了最近公共祖先。

很容易发现一点，这样的做法是O(N)的。但是能保证其正确性（当X和Y的深度不相同的时候，肯定是要先将深度深的结点移动到深度浅的结点的深度上去）

其中，我们可以做出优化。因为我们可以知道，当向上走的步数越多，那么肯定就越会相同，我们类似就可以使用倍增的方法来进行维护了。

譬如说是这样的一棵树。

当我们先把X升高到和Y同深度的点，也就是X会转到点4上去（现在X在4号点的位置了），我们会发现，当X和Y向上4步的时候都是空，向上两步的时候都是2，向上1步的时候都是3号结点。

但是对于之前的那幅图，X和Y向上一步是不相同的，我们可以让他俩同时向上一步（这样做是有深意的）。我们自此引入倍增法求LCA（最近公共祖先）。

倍增法求LCA：

我们可以用RMQ初始的方法，先跑一遍dfs()，知道了每个结点的父亲是谁，记录给root[x][0]，“x”是当前的结点，“root[x][0]”是x结点向上一步得到的点（也被称之为父亲结点）。

然后，我们知道父亲的父亲，就是爷爷，爷爷的爷爷就是曾爷爷（？曾曾？），然后呢，以此类推。我们可以维护出来每个结点的向上

步会走到哪个结点，如果已经超出了树的范围，我们令root[x][k] = 0。（前提是树上结点的序号是1～N，如果是0～N-1可不能这样）

以上的这些做法，在代码上是怎样维护的呢？

我们随便写写：

首先，因为会使用到倍增，然后我就先预处理一下log2()函数：

inline void Pre()
{
    for(int i=0, j=0, nex = 2; i<maxN; i++)
    {
        if(i == nex) { nex <<= 1; j++; }
        LOG[i] = j;
    }
}

再者往下，我们想知道每个点往上

会抵达哪个结点，于是有root[x][k]表示x号结点往上

步会走到哪个结点。

void dfs(int u, int fa)
{
    root[u][0] = fa;
    deep[u] = deep[fa] + 1;
    for(int i=0; (1 << (i + 1)) < N; i++)   //预处理的部分
    {
        root[u][i + 1] = root[root[u][i]][i];
    }
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(v == fa) continue;
        dfs(v, u);
    }
}

其中的deep数组，是用来记录深度的，因为我们要保证深度的统一性。

现在，就是到了我们的求LCA的过程了：

inline int _LCA(int x, int y)
{
    if(deep[x] < deep[y]) swap(x, y);
    int det = deep[x] - deep[y];    //将深度差转换成二进制的形式
    for(int i=LOG[det]; i>=0; i--)
    {
        if((det >> i) & 1) x = root[x][i];
    }
    if(x == y) return x;    //有些时候，它们实则是一条链上不同深度的两个点
    for(int i=LOG[N]; i>=0; i--)
    {
        if(root[x][i] ^ root[y][i]) //遇到不相同的时候，我们就往上走，不断的逼近真实答案，但一定不会是真实相同，只是无限逼近
        {
            x = root[x][i];
            y = root[y][i];
        }
    }
    return root[x][0];
}

它是一个无限逼近，但永远不会相同的过程，所以最后return的是root[x][0]，因为最小逼近单位是1了，我们仅要求是逼近，所以这个时候，X和Y的最近公共祖先，一定是它们往上一个单位了的。但是，我们首先要排除，把它们放到深度相同的位置的时候，就已经是重叠的情况。

完整的过程呢：

dfs(gen, 0);    //根结点
int x, y;
scanf("%d%d", &x, &y);
printf("%d\n", _LCA(x, y));

是这样的一个顺序。

放一道模板题：

Nearest Common Ancestors

POJ - 1330

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
//#include <unordered_map>
//#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f3f3f3f3f
//#define INF 10000007.
#define eps 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e4 + 7;
int N, head[maxN], cnt, du[maxN], gen, root[maxN][20], deep[maxN], LOG[maxN];
struct Eddge
{
    int nex, to;
    Eddge(int a=-1, int b=0):nex(a), to(b) {}
}edge[maxN << 1];
inline void addEddge(int u, int v)
{
    edge[cnt] = Eddge(head[u], v);
    head[u] = cnt++;
}
inline void _add(int u, int v) { addEddge(u, v); addEddge(v, u); }
void dfs(int u, int fa)
{
    root[u][0] = fa;
    deep[u] = deep[fa] + 1;
    for(int i=0; (1 << (i + 1)) < N; i++)   //预处理的部分
    {
        root[u][i + 1] = root[root[u][i]][i];
    }
    for(int i=head[u], v; ~i; i=edge[i].nex)
    {
        v = edge[i].to;
        if(v == fa) continue;
        dfs(v, u);
    }
}
inline int _LCA(int x, int y)
{
    if(deep[x] < deep[y]) swap(x, y);
    int det = deep[x] - deep[y];    //将深度差转换成二进制的形式
    for(int i=LOG[det]; i>=0; i--)
    {
        if((det >> i) & 1) x = root[x][i];
    }
    if(x == y) return x;    //有些时候，它们实则是一条链上不同深度的两个点
    for(int i=LOG[N]; i>=0; i--)
    {
        if(root[x][i] ^ root[y][i]) //遇到不相同的时候，我们就往上走，不断的逼近真实答案，但一定不会是真实相同，只是无限逼近
        {
            x = root[x][i];
            y = root[y][i];
        }
    }
    return root[x][0];
}
inline void init()
{
    cnt = 0;
    for(int i=1; i<=N; i++)
    {
        du[i] = 0;
        head[i] = -1;
    }
}
inline void Pre()
{
    for(int i=0, j=0, nex = 2; i<maxN; i++)
    {
        if(i == nex) { nex <<= 1; j++; }
        LOG[i] = j;
    }
}
int main()
{
    Pre();
    int T; scanf("%d", &T); deep[0] = 0;
    while(T--)
    {
        scanf("%d", &N);
        init();
        for(int i=1, u, v; i<N; i++)
        {
            scanf("%d%d", &u, &v);
            addEddge(u, v); du[v]++;
        }
        for(int i=1; i<=N; i++) if(!du[i]) { gen = i; break; }
        dfs(gen, 0);    //根结点
        int x, y;
        scanf("%d%d", &x, &y);
        printf("%d\n", _LCA(x, y));
    }
    return 0;
}

写在最后

我们学完倍增法求LCA之后，要知道的是，倍增不是一种模板，而是一种思维的方式，它在维护线性关系的时候，能起到一个很有效的优化作用。

来源：CSDN

作者：Andres_Lionel

链接：https://blog.csdn.net/qq_41730082/article/details/104087500

标签

lca

int函数

deep