LCA转换成RMQ

LCA(Lowest Common Ancestor 最近公共祖先)定义如下：在一棵树中两个节点的LCA为这两个节点所有的公共祖先中深度最大的节点。 

比如这棵树

结点5和6的LCA是2,12和7的LCA是1,8和14的LCA是4。

这里讲一下将LCA转化成RMQ问题，进而用st表求解。

首先我们跑一遍dfs，并记录经过的每一个结点（包括回溯的时候），存到一个数组中，这样我就将树的问题转化成线性问题。

等下上图的树好像有些大

这就好多了。

然后就是dfs序列和深度序列

dfs序   1  2  5  2  6  2  1  3  1  4  1

dep序  1  2  3  2  3  2  1  2  1  2  1

根据dfs的性质，从node[u]遍历到node[v]的过程中，经过LCA(u, v)有且仅有一次，而且它的深度一定是区间[u, v]中是最小的，那么这就是一个显而易见的RMQ（静态区间最小值）问题了。

我们就以洛谷的板子为例，传送门：https://www.luogu.org/problemnew/show/P3379

这里的vis数组是用来处理无向图存两次边的

先写一个dfs序

vector<int>v[maxn];
//node存的dfs序，dep深度序列，firs[s]指s第一次出现在dfs序中的位置 
int dep[2 * maxn], node[2 * maxn], firs[maxn], vis[maxn]; 
int p = 1;
void dfs(int s, int d)    //s用来构造dfs序，d用来构造深度序列 
{
    vis[s] = 1;
    dep[p] = d; node[p] = s; firs[s] = p++;
    for(int i = 0; i < v[s].size(); ++i)
    {
        if(!vis[v[s][i]])
        {
            dfs(v[s][i], d + 1);    //孩子的深度肯定是父亲的深度+1 
            dep[p] = d; node[p++] = s;
        }
    }
}

然后考一个RMQ板子就行了

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;
const int maxn = 5e5 + 5;
int n, m, s;
vector<int>v[maxn];
//node存的dfs序，dep深度序列，firs[s]指s第一次出现在dfs序中的位置 
int dep[2 * maxn], node[2 * maxn], firs[maxn], vis[maxn]; 
int p = 1;
void dfs(int s, int d)    //s用来构造dfs序，d用来构造深度序列 
{
    vis[s] = 1;
    dep[p] = d; node[p] = s; firs[s] = p++;
    for(int i = 0; i < v[s].size(); ++i)
    {
        if(!vis[v[s][i]])
        {
            dfs(v[s][i], d + 1);    //孩子的深度肯定是父亲的深度+1 
            dep[p] = d; node[p++] = s;
        }
    }
}
//pos[L][R]表示的是区间[L, R]中最小值在dfs序中的位置 
int dp[2 * maxn][25], pos[2 * maxn][25], que[2 * maxn];
void init()
{
    int n = p - 1;
    for(int i = 1; i <= n; ++i) {dp[i][0] = dep[i]; pos[i][0] = i;}
    for(int j = 1; (1 << j) <= n; ++j)
        for(int i = 1; i + (1 << j) - 1 <= n; ++i)
        {
            if(dp[i][j - 1] < dp[i + (1 << (j - 1))][j - 1])
            {
                dp[i][j] = dp[i][j - 1]; pos[i][j] = pos[i][j - 1];
            }
            else
            {
                dp[i][j] = dp[i + (1 << (j - 1))][j - 1]; pos[i][j] = pos[i + (1 << (j - 1))][j - 1];
            }
        }
    int k = 0;
    for(int i = 1; i <= n; ++i) 
    {
        if ((1 << k) <= i) k++; 
        que[i] = k - 1;
    }
}
void query(int L, int R)
{
    if (R < L) swap(L, R);
    int k = que[R - L + 1];
    if(dp[L][k] <  dp[R - (1 << k) + 1][k]) printf("%d
", node[pos[L][k]]);
    else printf("%d
", node[pos[R - (1 << k) + 1][k]]);
    return;
}
int main()
{
    scanf("%d%d%d", &n, &m, &s);
    for(int i = 1; i < n; ++i)
    {
        int a, b; scanf("%d%d", &a, &b);
        v[a].push_back(b); v[b].push_back(a);
    }
    dfs(s, 1);
    init();
    while(m--)
    {
        int a, b; scanf("%d%d", &a, &b);
        query(firs[a], firs[b]);
    }
    return 0;
}