以典题How far away（hdoj 2586）为例，小结LCA之倍增算法(2752字)

链接
传送门
题目大意
给一棵有n个点的树，问询m次，每次给出两个点x,y求出两者间边权的最短路径。
n 4e4,m 400
分析
在树这种结构上最短路径就是，要么直接直线抵达，要么经过最近公共祖先(least common ancestor)LCA，走一个V字形。
算法分析
0、初始化

	for (int i = 1; i <= n; i++) {
		d[i] = 0;
		g[i].clear();
		for (int j = 0; j < 31; j++) {
			f[i][j] = cost[i][j] = 0;
		}
	}

1、建图，这里w指的是的边权，利用vector记录邻接表

	struct eg {
		int to, w;
	};
	vector<eg> g[N];
	for (int i = 1; i < n; i++) {
		int u, v, w;
		cin >> u >> v >> w;
		g[u].push_back({v, w});
		g[v].push_back({u, w});
	} 

2、DFS初始化。
这是LCA算法的一个核心之一，这部分利用标记父节点的DFS，O（n）的时间复杂来预处理f[i][j]数组，这个数组的含义是，从节点i出发，向上追溯2^j个祖先的祖先是谁，如果说j=0零，那么就是这个节点的父节点。我们可以发现一个关键的转移方程f[u][i] = f[f[u][i - 1]][i - 1]，这局话的含义是什么呢，对于节点u，走一遍2^j-1次的节点再走2^j-1就是u节点走2^j次的父节点。由于标记父节点的树上DFS，深度由浅至深的层次遍历的，对根节点我们处理好了f[u][j],对于新的部分，首先j=0的时候是其父节点，如果是第二层的点，就是根节点，这些点都是已经处理完的，所有的可能的j。对于某个崭新的v点，首先j=0的时候是可以确定的，当j=1的时候，j=0的点已经存在，也就是对应的u点，对于u点我们所有的j都已经处理完了。对于j=x的时候，j=x-1的点已经处理完了，可以得到某个祖先，f[某个祖先][x-1]也是处理完了，可以得到正确的f[v][j]。完毕。DFS还有一个功效是求深度。对于边权我们记录在父节点上，cost[v][0]就是走一格祖先，同样地，原理我们求u节点出发2^i次距离的cost，注意这里我们需要加上跳过路程的边权，更新成新的u走2^i的边权，加号左半部分已经知道了。

int f[N][31], d[N], cost[N][31];
void dfs(int u, int fa) {
	f[u][0] = fa;
	d[u] = d[fa] + 1;
	for (int i = 1; i < 31; i++) {
		f[u][i] = f[f[u][i - 1]][i - 1];
		cost[u][i] = cost[f[u][i - 1]][i - 1] + cost[u][i - 1];
	}
	for (auto i : g[u]) {
		int v = i.to, w = i.w;
		if (v == fa) continue;
		cost[v][0] = w;
		dfs(v, u);
	}
}

3、倍增跳跃。

int lca(int x, int y) {
	if (d[x] > d[y]) swap(x, y);//dy更深
	int tmp = d[y] - d[x], ans = 0;//两点之差
	for (int j = 0; tmp; j++, tmp >>= 1) {//从最低位开始逐个遍历，拆分成若干2的幂
		if (tmp & 1) ans += cost[y][j], y = f[y][j];//这些数值都处理过了
	}
	if (x == y) return ans;//这就是在同一条支路上
	for (int j = 30; j >= 0 && y != x; j--) {//从最高位开始
		if (f[x][j] != f[y][j]) {//如果说这位没有跳出头，我们就更新
			ans += cost[x][j] + cost[y][j];//我们要找的是LCA的最近的子节点
			x = f[x][j], y = f[y][j];
		}
	}
	ans += cost[x][0] + cost[y][0];//统计
	return ans;
} 

4、main函数杂项

	dfs(1, 0);
	for (int i = 0; i < m; i++) {
		int x, y;
		cin >> x >> y;
		cout << lca(x, y) << '\n';
	}

实现

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 4e4 + 5;
struct eg {
	int to, w;
};
vector<eg> g[N];
int f[N][31], d[N], cost[N][31];
void dfs(int u, int fa) {
	f[u][0] = fa;
	d[u] = d[fa] + 1;
	for (int i = 1; i < 31; i++) {
		f[u][i] = f[f[u][i - 1]][i - 1];
		cost[u][i] = cost[f[u][i - 1]][i - 1] + cost[u][i - 1];
	}
	for (auto i : g[u]) {
		int v = i.to, w = i.w;
		if (v == fa) continue;
		cost[v][0] = w;
		dfs(v, u);
	}
}
int lca(int x, int y) {
	if (d[x] > d[y]) swap(x, y);
	int tmp = d[y] - d[x], ans = 0;
	for (int j = 0; tmp; j++, tmp >>= 1) {
		if (tmp & 1) ans += cost[y][j], y = f[y][j];
	}
	if (x == y) return ans;
	for (int j = 30; j >= 0 && y != x; j--) {
		if (f[x][j] != f[y][j]) {
			ans += cost[x][j] + cost[y][j];
			x = f[x][j], y = f[y][j];
		}
	}
	ans += cost[x][0] + cost[y][0];
	return ans;
} 
void solve() {
	int n, m;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		d[i] = 0;
		g[i].clear();
		for (int j = 0; j < 31; j++) {
			f[i][j] = cost[i][j] = 0;
		}
	}
	for (int i = 1; i < n; i++) {
		int u, v, w;
		cin >> u >> v >> w;
		g[u].push_back({v, w});
		g[v].push_back({u, w});
	} 
	dfs(1, 0);
	for (int i = 0; i < m; i++) {
		int x, y;
		cin >> x >> y;
		cout << lca(x, y) << '\n';
	}
}
int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);
	int T = 1;
	cin >> T; 
	while (T--) {
		solve();
	}
	return 0;
}