LCA就是求树上两个节点的最近公共祖先。
LCA的在线算法最好的就是ST算法,这是一种基于RMQ(区间最小值)的算法,总的来说,就是利用dfs搜索得到一个序列,然后在这个序列中确定一个区间内,找到最小值的编号就是对应两点的LCA。
举例说明,如图所示一棵树:
通过深搜可以得到这样一个序列:
节点ver: 1 3 1 2 4 2 5 6 5 7(左到右)
深度 R :1 2 1 2 3 2 3 4 3 4
首位first:1 2 4 5 7 8 10 (即这个数第一次出现的位置)
利用一次dfs求出上面三个数组,之后如果想要求解两个节点的LCA,比如要求解4,7两个节点的LCA,只要通过first数组找4和7第一次出现的下标分别是5和10,也就是在深度R数组中找到下标5到8这一段,也就是3 2 3 4 3 4,可以发现最小深度是2,而所对应的节点编号就是2,所以4和7的LCA就是2。
ST算法需要用到RMQ,也就是通过dp的思想求解一段区间内的最小值的下标,这样每次查询的复杂度就是O(logn)。
最后附上HDU 2586(LCA模板题)的代码:
#include
using namespace std;
const int MAXN = 4e4 + 10;
struct node {
int v, w;
};
int dfs_cnt;
int dp[2 * MAXN][25];
int R[2 * MAXN], ver[2 * MAXN], dis[MAXN], fir[MAXN];
vector tree[MAXN];
void dfs(int u, int pre, int deep) {
fir[u] = ++dfs_cnt;
ver[dfs_cnt] = u; R[dfs_cnt] = deep;
int cnt = tree[u].size();
for (int i = 0; i < cnt; i++) {
int v = tree[u][i].v, w = tree[u][i].w;
if (v == pre) continue;
dis[v] = dis[u] + w;
dfs(v, u, deep + 1);
ver[++dfs_cnt] = u; R[dfs_cnt] = deep;
}
}
void ST(int n) {
for (int i = 1; i <= n; i++) dp[i][0] = i;
for (int j = 1; (1 << j) <= n; j++) {
for (int i = 1; i + (1 << j) - 1 <= n; i++) {
int x = dp[i][j - 1], y = dp[i + (1 << (j - 1))][j - 1];
dp[i][j] = R[x] < R[y] ? x : y;
}
}
}
int RMQ(int l, int r) {
int k = 0;
while ((1 << (k + 1)) <= r - l + 1) ++k;
int x = dp[l][k], y = dp[r - (1 << k) + 1][k];
return R[x] < R[y] ? x : y;
}
int LCA(int u, int v) {
int x = fir[u], y = fir[v];
if (x > y) swap(x, y);
return ver[RMQ(x, y)];
}
int main() {
//freopen("in.txt", "r", stdin);
int T;
cin >> T;
while (T--) {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i <= n; i++) tree[i].clear();
for (int i = 1; i < n; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
tree[u].push_back((node){v, w});
tree[v].push_back((node){u, w});
}
dfs_cnt = 0;
dis[1] = 0;
dfs(1, -1, 1);
ST(2 * n - 1);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
int pa = LCA(u, v);
printf("%d\n", dis[u] + dis[v] - 2 * dis[pa]);
}
}
return 0;
}