LCA（Lowest Common Ancesor)

LCA（Lowest Common Ancesor)

1.基于二分搜索算法

预处理father[v][k]表示v的2的k次方层祖先，时间复杂度是O（nlogn），每次查询的时间复杂度是O（logn），预处理2k表的技巧在LCA之外也会用到。用链式前向星存图，相对vector邻接表要快。

一次dfs预处理出全部点的父亲结点，然后用2分思想，处理出每个点的2的k次方的父亲结点，对于LCA核心算法，首先把深度较深的移动到与另外一个水平，然后两个结点一起移动，但他们的父亲结点不同时，先上移动，最后返回当前结点的父亲结点。

1.1 Nearest Common Ancestors POJ - 1330

在有根树下，求任意两个结点的LCA，首先找到根节点，以这个结点为起点dfs，预处理出所有结点的父节点。

链式前向星存

#include<iostream>
#include<cstring>
#include<cmath>
#define mem(a,x) memset(a,x,sizeof(a))
using namespace std;
const int N = 1e4 + 5;
int fa[N][15];
int head[N];
int vis[N];
int cur;
int depth[N];
bool Du[N];
int ans[N];
int n;
struct Edge {
	int to;
	int nex;
}edge[N];
void AddEdge(int u, int v) {
	edge[cur].to = v;
	edge[cur].nex = head[u];
	head[u] = cur++;
}
void init() {
	mem(head, -1);
	mem(fa, 0);
	mem(Du, 0);
	mem(depth, 0);
	cur = 0;
}
void dfs(int v, int p, int d) {
	fa[v][0] = p;
	depth[v] = d;
	for (int i = head[v]; i != -1; i = edge[i].nex) {
		dfs(edge[i].to, v, d + 1);
	}
}
int LCA(int s, int t) {
	if (depth[s] < depth[t])
		swap(s, t);
	int temp = depth[s] - depth[t];
	for (int i = 0; (1 << i) <= temp; i++)
	{
		if ((1<<i)&temp)
			s = fa[s][i];
	}
	if (s == t)return s;
	for (int i = (int)log2(n*1.0); i >= 0; i--) {
		if (fa[s][i] != fa[t][i]) {
			s = fa[s][i];
			t = fa[t][i];
		}
	}
	return fa[s][0];
}
int main()
{
	int T, s, t, root;
	cin >> T;
	while (T--)
	{
		init();
		cin >> n;
		for (int i = 0; i < n - 1; i++) {
			cin >> s >> t;
			AddEdge(s, t);
			Du[t] = 1;
		}
		for (int i = 1; i <= n; i++){
			if (Du[i] == 0){
				root = i;
				break;
			}
		}
		dfs(root, -1, 0);
		for (int j = 0; (1 << (j + 1)) < n; j++) {
			for (int i = 1; i <= n; i++) {
				if (fa[i][j] < 0)
					fa[i][j + 1] = -1;
				else fa[i][j + 1] = fa[fa[i][j]][j];
			}
		}
		cin >> s >> t;
		cout << LCA(s, t) << endl;
	}
}

连接表存

#include<iostream>
#include<cstring>
#include<cmath>
#include<vector>
#define mem(a,x) memset(a,x,sizeof(a))
using namespace std;
const int N = 1e4 + 5;
int father[N][15];
int depth[N];
int Du[N];
int max_log;
struct  Node{
	vector<int>G;
};
Node tree[N];
 void dfs(int v, int p, int d) {
	 father[v][0] = p;
	 depth[v] = d;
	 for (int i = 0; i < tree[v].G.size(); i++) {
		 if (tree[v].G[i] != p)dfs(tree[v].G[i], v, d + 1);
	 }
}
void init() {
	memset(Du, 0, sizeof(Du));
	//for (int i = 0; i < 15; i++)G[i].clear();
	memset(tree, 0, sizeof(tree));
	memset(depth, 0, sizeof(depth));
	memset(father, 0, sizeof(father));
}
int LCA(int u, int v) {
	if (depth[u]>depth[v])swap(u, v);
	int temp = depth[v] - depth[u];
	for (int i = 0; (1 << i) <= temp; i++) {
		if ((1 << i)&temp) {//如果temp是1011,1分别左移1,2,3,4位，与temp&，如果当前temp在i为1，说明可以提高i位
			v= father[v][i];//depth[v]大，先将v提高与u水平
		}
	}
	if (u == v)return u;
	for (int i = max_log; i >= 0; i--) {
		if (father[u][i] != father[v][i]) {
			u = father[u][i];
			v = father[v][i];
		}
	}
	return father[u][0];
}
int main() {
	int T, s, t, root;
	cin >> T;
	while (T--)
	{

		int n;
		cin >> n;
		init();
		max_log = int(log2(1.0*n));
		for (int i = 0; i < n - 1; i++) {
			cin >> s >> t;
			tree[s].G.push_back(t);
			Du[t] = 1;
		}
		for (int i = 1; i <= n; i++) {
			if (Du[i] == 0) {
				root = i;
				break;
			}
		}
		dfs(root, -1, 0);
		for (int j = 0; (1 << (j + 1)) < n; j++) {
			for (int i = 1; i <= n; i++) {
				if (father[i][j] < 0)
					father[i][j + 1] = -1;
				else father[i][j + 1] = father[father[i][j]][j];
			}
		}
		cin >> s >> t;
		cout << LCA(s, t) << endl;
	}
	return 0;
}

树上最短距离Factory HDU - 6115

暴力LCA

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<vector>
#define mem(a,x) memset(a,x,sizeof(a))
const int INF = 0x3f3f3f3f;
using namespace std;
const int N = 100010;
int fa[N][25];
int head[N];
int cur;
int depth[N];
int dis[N];//到根节点的距离
vector<int>vec[N];
int n,m;
struct Edge {
	int to;
	int cost;
	int nex;
}edge[2*N];
//edge[i].to表示第i条边的终点,edge[i].nex表示与第i条边同起点的下一条边的存储位置,edge[i].cost为边权值.
//head[i]保存的是以i为起点的所有边中编号最大的那个, 而把这个当作顶点i的第一条起始边的位置
void AddEdge(int u, int v, int w) {
	edge[cur].to = v;
	edge[cur].cost = w;
	edge[cur].nex = head[u];
	head[u] = cur++;
}
void init() {
	mem(head, -1);
	mem(fa, 0);
	mem(depth, 0);
	mem(dis, 0);
	cur = 0;
}
void dfs(int v, int p, int d,int cost) {
	fa[v][0] = p;
	depth[v] = d;
	dis[v] = cost;
	for (int i = head[v]; i != -1; i = edge[i].nex) {
		if(!depth[edge[i].to])//无向图
		dfs(edge[i].to, v, d + 1,dis[v]+edge[i].cost);
	}
}
/*
void dfs(int v, int f, int cost)
{
	dis[v] = cost;
	for (int i = head[v]; i != -1; i = edge[i].nex)
	{
		int u = edge[i].to;
		if (u == f) continue;
		if (!depth[u])
			depth[u] = depth[v] + 1, fa[u][0] = v, dfs(u, v, dis[v] + edge[i].cost);
	}
}
*/
int LCA(int s, int t) {
	if (depth[s] < depth[t])
		swap(s, t);
	int temp = depth[s] - depth[t];
	for (int i = 0; (1 << i) <= temp; i++)
	{
		if ((1 << i)&temp)
			s = fa[s][i];
	}
	if (s == t)return s;
	for (int i = (int)log2(n*1.0); i >= 0; i--) {
		if (fa[s][i] != fa[t][i]) {
			s = fa[s][i];
			t = fa[t][i];
		}
	}
	return fa[s][0];
}
int main()
{
	int T, s, t,w, root;
	scanf("%d", &T);
	while (T--)
	{
		init();
		scanf("%d%d", &n, &m);
		for (int i = 0; i < n - 1; i++) {
			scanf("%d%d%d", &s, &t, &w);
			AddEdge(s, t,w);
			AddEdge(t, s, w);
			//Du[t] = 1;
		}
		//找到根节点

		for (int i = 1; i <= m; i++)
		{
			int num, v;
			scanf("%d", &num);
			for (int j = 1; j <= num; j++)
			{
				scanf("%d", &v);
				vec[i].push_back(v);
			}
		}
		//选择1为根
		dfs(1, -1,0,0);
		for (int j = 0; (1 << (j + 1)) < n; j++) {
			for (int i = 1; i <= n; i++) {
				if (fa[i][j] < 0)
					fa[i][j + 1] = -1;
				else fa[i][j + 1] = fa[fa[i][j]][j];
			}
		}
		int q;
		scanf("%d",&q);
		for (int i = 1; i <= q; i++)
		{
			int v, u, ans = INF;
			scanf("%d%d", &v, &u);
			for (int j = 0; j < vec[v].size(); j++)
				for (int  k = 0; k < vec[u].size(); k++)
					ans = min(ans, dis[vec[v][j]] + dis[vec[u][k]] - dis[LCA(vec[v][j], vec[u][k])] * 2);
			printf("%d\n", ans);
		}
		for (int i = 1; i <= m; i++) vec[i].clear();
	}
	return 0;
}