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