题意
给一棵树,点与点之间有边权,求这棵树上,点与点之间的最短距离。
解析
首先先学习lca-st在线算法:
在线算法:边输入边查询。
lca-st算法流程:
如下树(暂以二叉树为例,其他树类似):
此树在深度优先遍历时,记录以下几个值:
1.遍历节点的顺序(ver):
A -> B -> D -> F -> D -> G -> D -> B -> E -> H -> E -> B -> A -> C -> A
2.遍历节点时节点的深度(dep):
1 -> 2 -> 3 -> 4 -> 3 -> 4 ->3 -> 2 -> 3 -> 4 -> 3 -> 2 -> 1 -> 2 -> 1
3.最初遍历到当前这个点时的时间戳(R)如图橘色标号:
A->1, B->2, C->15, D->3, E->9, F->4, G -> 6, H->11
现在,如果我要求G和E的最近公共祖先,我只需要求dep中第6(G)个到第9(E)个数中深度最小的那个数所对应的节点是什么就行了。
以上例子中对应的是 4 ->3 -> 2 -> 3这一段,对应的节点是 G -> D -> B -> E。最小深度为2,因而所对应的lca为B。
所以在查询的时候,ST建表建的并不是最小深度,而为了将ver和dep建立起映射,ST所建之表表示的是当前最小深度所对应的index。
然后这题的话,先求出两个点的lca,然后他们之间的最短距离就是一个点走到他们的lca,然后再走向另一个点。
对应的计算方法就是根节点到lca点的disLca,然后根节点到u点的disU,到v点的disV,他们呢间的距离就是disU + disV - 2 * disLCA。
代码
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <stack>
#include <vector>
#include <queue>
#include <map>
#include <set>
#include <climits>
#include <cassert>
#define Min(a,b) ((a)<(b)?(a):(b))
#define Max(a,b) ((a)>(b)?(a):(b))
#define LL long long
#define lson lo, mi, rt << 1
#define rson mi + 1, hi, rt << 1 | 1
using namespace std;
const int maxn = 40000 + 10;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
const double ee = exp(1.0);
int head[maxn];
int edgeNum;
struct Edge
{
int fr, to, next;
int val;
} e[maxn << 1];
void initEdge()
{
memset(head, -1, sizeof(head));
edgeNum = 0;
}
void addEdge(int fr, int to, int val)
{
e[edgeNum].fr = fr;
e[edgeNum].to = to;
e[edgeNum].val = val;
e[edgeNum].next = head[fr];
head[fr] = edgeNum++;
e[edgeNum].fr = to;
e[edgeNum].to = fr;
e[edgeNum].val = val;
e[edgeNum].next = head[to];
head[to] = edgeNum++;
}
bool vis[maxn];
int dis[maxn]; //根节点到当前点的距离
int ver[maxn << 1]; //dfs遍历时节点的编号
int dep[maxn << 1]; //dfs遍历时节点的深度
int R[maxn]; //dfs遍历时第一次出现当前节点时的遍历序号
int tot; //下标计数器
void dfs(int u, int d)
{
vis[u] = true;
ver[++tot] = u;
R[u] = tot;
dep[tot] = d;
for (int i = head[u]; i != -1; i = e[i].next)
{
if (!vis[e[i].to])
{
int v = e[i].to;
int val = e[i].val;
dis[v] = dis[u] + val;
dfs(v, d + 1);
ver[++tot] = u;
dep[tot] = d;
}
}
}
//ST算法中保存的是当前段深度最小的节点的序号
int minDepVerIndex[maxn << 1][20];
void queryInit(int n)
{
for (int i = 1; i <= n; i++)
{
minDepVerIndex[i][0] = i;
}
for (int j = 1; (1 << j) <= n; j++)
{
for (int i = 1; i + (1 << j) - 1 <= n; i++)
{
int p = (1 << (j - 1));
int u = minDepVerIndex[i][j - 1];
int v = minDepVerIndex[i + p][j - 1];
minDepVerIndex[i][j] = dep[u] < dep[v] ? u : v;
}
}
}
int queryMin(int l, int r)
{
int k = log2((double)(r - l + 1));
int u = minDepVerIndex[l][k];
int v = minDepVerIndex[r - (1 << k) + 1][k];
return dep[u] < dep[v] ? u : v;
}
int lca(int u, int v)
{
int l = R[u];
int r = R[v];
if (l > r)
swap(l, r);
int index = queryMin(l, r);
return ver[index];
}
int main()
{
#ifdef LOCAL
freopen("in.txt", "r", stdin);
#endif // LOCAL
int ncase;
scanf("%d", &ncase);
while (ncase--)
{
int n, q;
scanf("%d%d", &n, &q);
initEdge();
for (int i = 1; i < n; i++)
{
int fr, to, val;
scanf("%d%d%d", &fr, &to, &val);
addEdge(fr, to, val);
}
memset(vis, false, sizeof(vis));
tot = 0;
dis[1] = 0;
dfs(1, 1);
queryInit((n << 1) - 1);
while (q--)
{
int u, v;
scanf("%d%d", &u, &v);
int rt = lca(u, v);
printf("%d\n", dis[u] + dis[v] - 2 * dis[rt]);
}
}
return 0;
}