求树上两点间最短距离
给出 nn 个点的一棵树，多次询问两点之间的最短距离。
注意：
- 边是无向的。
- 所有节点的编号是 1,2,…,n1,2,…,n。
输入格式
第一行为两个整数 nn 和 mm。nn 表示点数，mm 表示询问次数；
下来 n−1n−1 行，每行三个整数 x,y,kx,y,k，表示点 xx 和点 yy 之间存在一条边长度为 kk；
再接下来 mm 行，每行两个整数 x,yx,y，表示询问点 xx 到点 yy 的最短距离。
树中结点编号从 11 到 nn。
输出格式
共 mm 行，对于每次询问，输出一行询问结果。
数据范围
2≤n≤1042≤n≤104,
1≤m≤2×1041≤m≤2×104,
0<k≤1000<k≤100,
1≤x,y≤n
分析：本题需要先开一个dist数组存每个点到根节点的距离，跑一遍dfs/bfs预处理出dist数组。
树上a,b两点间距离=dist[a]+dist[b]-2*dist[lca(a,b)];
求树上三点间最短距离：
YY 岛风景美丽宜人，气候温和，物产丰富。
YY 岛上有 NN 个城市（编号 1,2,…,N1,2,…,N），有 N−1N−1 条城市间的道路连接着它们。
每一条道路都连接某两个城市。
幸运的是，小可可通过这些道路可以走遍 YY 岛的所有城市。
神奇的是，乘车经过每条道路所需要的费用都是一样的。
小可可，小卡卡和小 YYYY 经常想聚会，每次聚会，他们都会选择一个城市，使得 33 个人到达这个城市的总费用最小。
由于他们计划中还会有很多次聚会，每次都选择一个地点是很烦人的事情，所以他们决定把这件事情交给你来完成。
他们会提供给你地图以及若干次聚会前他们所处的位置，希望你为他们的每一次聚会选择一个合适的地点。
输入格式
第一行两个正整数，NN 和 MM，分别表示城市个数和聚会次数。
后面有 N−1N−1 行，每行用两个正整数 AA 和 BB 表示编号为 AA 和编号为 BB 的城市之间有一条路。
再后面有 MM 行，每行用三个正整数表示一次聚会的情况：小可可所在的城市编号，小卡卡所在的城市编号以及小 YYYY 所在的城市编号。
输出格式
一共有 MM 行，每行两个数 PosPos 和 CostCost，用一个空格隔开，表示第 ii 次聚会的地点选择在编号为 PosPos 的城市，总共的费用是经过 CostCost 条道路所花费的费用。
数据范围
N≤500000,M≤500000
思路分析：三点的距离应该分三种情况分析。
1.pos=lca(a,b)
2.pos=lca(a,c)
3.pos=lca(b,c)
下面以pos=lca(a,b)为例讲一下怎么求三点到聚会的距离（也就是题目中求的费用）
因为a和b的最近公共祖先是聚会pos的地点，所以a和b到pos的距离=depth[a]+depth[b]-2depth[lca(a,b)]
而c到pos的距离应该是depth[c]+depth[pos]-2depth[lca(c,pos)]
综合起来费用就是depth[a]+depth[b]-depth[lca(a,b)]+depth[c]+depth[pos]-2depth[lca(c,pos)]
上面两个式子也告诉了我们，求树中两点的距离，用lca求。
即先任取两点，把他们的公共祖先当作一个点，与第三个点再求一遍公共祖先。
从三种情况中取一个Min;
注意：本题无边权，所以其实答案就是经过边数的条数的多少，也就是深度，所以不用像上一题一样开一个dist，直接用depth就能代表dist了。
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<map>
#include<vector>
#include<malloc.h>
#include<numeric>
#include<cmath>
#include<iomanip>
#include<queue>
using namespace std;
typedef long long ll;
typedef pair<int, int>PII;
const int N = 500010, M = 2 * N;
int n, m;
int h[N], e[M], ne[M], idx;
int depth[N], fa[N][19];//500000的log2下取整是18所以开19
int q[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
void bfs(int root)//bfs预处理depth和fa数组
{
memset(depth, 0x3f, sizeof depth);
depth[0] = 0, depth[root] = 1;
int hh = 0, tt = 0;
q[0] = root;
while (hh <= tt)
{
int t = q[hh++];
for (int i = h[t]; ~i; i = ne[i])
{
int j = e[i];
if (depth[j] > depth[t])//代表在向下遍历，若向上遍历就不是符合这个if了。
{
depth[j] = depth[t]+1;
q[++tt] = j;
fa[j][0] = t;
for (int k = 1; k <= 18; k++)
fa[j][k] = fa[fa[j][k - 1]][k - 1];
}
}
}
}
int lca(int a, int b)
{
if (depth[a] < depth[b])swap(a, b);
for (int k = 18; k >= 0; k--)
if (depth[fa[a][k]] >= depth[b])
a = fa[a][k];
if (a == b)return a;
for (int k = 18; k >= 0; k--)
if (fa[a][k] != fa[b][k])
{
a = fa[a][k];
b = fa[b][k];
}
return fa[a][0];
}
int main()
{
memset(h, -1, sizeof h);//图论超时的原因很大概率是因为忘记打这一行初始化表头
scanf("%d%d", &n, &m);
for (int i = 0; i < n-1; i++)//读入n-1条边
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b); add(b, a);
}
int root = 1;
bfs(root);//由于是无向图，所以可以任选一个点作为根节点开始遍历即可
while (m--)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
int p1 = lca(a, b), co1 = depth[a] + depth[b] - 2 * depth[p1] + depth[c] + depth[p1] - 2 * depth[lca(p1, c)];
int p2 = lca(a, c), co2 = depth[a] + depth[c] - 2 * depth[p2] + depth[b] + depth[p2] - 2 * depth[lca(p2, b)];
int p3 = lca(b, c), co3 = depth[b] + depth[c] - 2 * depth[p3] + depth[a] + depth[p3] - 2 * depth[lca(p3, a)];
int pos, co;//取最短的co作为答案
if (co1 <= co2 && co1 <= co3)pos = p1, co = co1;
else if (co2 <= co1 && co2 <= co3)pos = p2, co = co2;
else if (co3 <= co2 && co3 <= co1)pos = p3, co = co3;
printf("%d %d\n", pos, co);
}
return 0;
}
Query on a tree II
题意：给一棵树每次询问两个节点间的距离or两个节点路径上从a->b的第k个节点是谁；
第一问简单，就是dist[a]+dist[b]-2*dist[lca(a,b)]
第二问需要先判断这第k个节点属于a->lca(a,b)的路上还是b->lca(a,b)的路上，如果是前者，则先利用k值进而得到这第k个节点所在的层数，定为ans,然后让a向上跳（倍增）到这个ans位置就知道是哪个节点了，后者同理，让b跳到ans即可；
const int N = 100010;
int h[N], e[2 * N], w[2 * N], ne[2 * N], idx;//无向图
int depth[N], dist[N], fa[N][17];
int q[N], d[N];
int n, m, root, t;
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx++;
}
void bfs(int x)
{ //注意不是最短路，不要把dist置正无穷；
memset(depth, 0x3f, sizeof depth);
depth[0] = 0, depth[x] = 1;
int dt = 0, dw = 0;
q[0] = x;
dist[x] = 0;
while (dt <= dw)
{
int t = q[dt++];
for (int i = h[t]; ~i; i = ne[i])
{
int j = e[i];
if (depth[j] > depth[t] + 1)
{
q[++dw] = j;
depth[j] = depth[t] + 1;
dist[j] = dist[t] + w[i];//更新距离
fa[j][0] = t;
for (int k = 1; k <= 16; k++)
fa[j][k] = fa[fa[j][k - 1]][k - 1];
}
}
}
}
int lca(int a, int b)
{
if (depth[a] < depth[b])swap(a, b);
for (int k = 16; k >= 0; k--)
if (depth[fa[a][k]] >= depth[b])
a = fa[a][k];
if (a == b)return a;
for (int k = 16; k >= 0; k--)
if (fa[a][k] != fa[b][k])
{
a = fa[a][k];
b = fa[b][k];
}
return fa[a][0];
}
int query(int a, int b, int k)//查询a->b路径上第k个节点是谁；
{
int x = lca(a, b);
if (depth[a] - depth[x] + 1 >= k)//第k个节点在a->x上（包括a和x,这个if=k的时候遍意味着第k个节点就是x)
{
int ans = depth[a] - k + 1;//ans为第k个节点所在的层数
for (int k = 16; k >= 0; k--)
if (depth[fa[a][k]] >=ans)//a一直向上跳到ans;
a = fa[a][k];
return a;
}
else//第k个节点在b->x上，不包括x
{
int ans = depth[x] * 2 + k - depth[a] - 1;//ans为第k个节点所在的层数
for (int k = 16; k >= 0; k--)
if (depth[fa[b][k]] >= ans)//b一直向上跳到ans;
b = fa[b][k];
return b;
}
}
int main()
{
int cnt = 1;
cin >> t;
while (t--)
{
memset(h, -1, sizeof h); idx = 0;
memset(d, 0, sizeof d);
memset(fa, 0, sizeof fa);
cin >> n;
for (int i = 0; i < n - 1; i++)
{
int a, b, c; scanf("%d%d%d", &a, &b, &c);
add(a, b, c); add(b, a, c);
d[b]++;
}
for (int i = 1; i <= n; i++)
if (!d[i])
{
root = i;
break;
}
bfs(root);
string s;
while (cin>>s)
{
if (s[1] == 'O')break;
if (s[0] == 'D')
{
int a, b; scanf("%d%d", &a, &b);
printf("%d\n", dist[a] + dist[b] - 2 * dist[lca(a, b)]);
}
else
{
int a, b, k; cin >> a >> b >> k;
cout<<query(a, b, k)<<endl;
}
}
}
}
Min Max road
题意：要求维护一颗树上两点路径间的最大值和最小值；
做法：类似于最小生成树的写法，只不过最小生成树维护的是最大值和次大值，更繁杂一些，本题只需要在倍增的时候维护一个最大值和最小值数组
const int N = 100010;
int h[N], e[2 * N], w[2 * N], ne[2 * N], idx;
int depth[N],fa[N][17];
int dmin[N][17], dmax[N][17];
int q[N],d[N];
int n,m,root, t;
void add(int a, int b, int c)
{
e[idx] = b,w[idx]=c, ne[idx] = h[a], h[a] = idx++;
}
void bfs(int x)
{
memset(depth, 0x3f, sizeof depth);
depth[0] = 0, depth[x] = 1;
int dt = 0, dw = 0;
q[0] = x;
while (dt <= dw)
{
int t = q[dt++];
for (int i = h[t]; ~i; i = ne[i])
{
int j = e[i];
if (depth[j] > depth[t] + 1)
{
q[++dw] = j;
depth[j] = depth[t] + 1;
fa[j][0] = t;
dmin[j][0] = w[i], dmax[j][0] = w[i];//只有一条边的路径显然这条路径上的最大值和最小值都是这条边
for (int k = 1; k <= 16; k++)
{
int x = fa[j][k - 1];//由于在跳中维护一些信息所以分两次跳要单独写开来
fa[j][k] = fa[x][k - 1];
dmax[j][k] = max(dmax[j][k - 1], dmax[x][k - 1]);//跳的时候更新一下最大值
dmin[j][k] = min(dmin[j][k - 1], dmin[x][k - 1]);//更新最小值
}
}
}
}
}
PII lca(int a, int b)
{
int dminn=1e9, dmaxx=0;//要返回的答案
if (depth[a] < depth[b])swap(a, b);
for (int k = 16; k >= 0; k--)
if (depth[fa[a][k]] >= depth[b])
{
dminn = min(dminn, dmin[a][k]);//跳的时候更新最小值答案
dmaxx = max(dmaxx, dmax[a][k]);//跳的时候更新最大值答案
a = fa[a][k];//仅是a往b上跳
}
if (a != b)
{
for (int k = 16; k >= 0; k--)
if (fa[a][k] != fa[b][k])
{
dminn = min(dminn, dmin[a][k]);
dmaxx = max(dmaxx, dmax[a][k]);
dminn = min(dminn, dmin[b][k]);
dmaxx = max(dmaxx, dmax[b][k]);
a = fa[a][k];//a和b一起往上跳
b = fa[b][k];
}
//不要忘记一起往上跳后还要再走一条边才能到两者的lca,所以这条边自然也在答案要考虑的范围内，也要拿这条边来更新答案；
dminn = min(dminn, dmin[a][0]);
dmaxx = max(dmaxx, dmax[a][0]);
dminn = min(dminn, dmin[b][0]);
dmaxx = max(dmaxx, dmax[b][0]);
}
PII ans = { dminn,dmaxx };
return ans;
}
int main()
{
int cnt = 1;
cin >> t;
while (t--)
{
printf("Case %d:\n", cnt++);
memset(h, -1, sizeof h); idx = 0;
memset(d, 0, sizeof d);
memset(fa, 0, sizeof fa);
cin >> n;
for (int i = 0; i < n - 1; i++)
{
int a, b, c; scanf("%d%d%d", &a, &b, &c);
add(a, b, c); add(b, a, c);
d[b]++;
}
for(int i=1;i<=n;i++)
if (!d[i])
{
root = i;
break;
}
bfs(root);
cin >> m;
while (m--)
{
int a, b; scanf("%d%d", &a, &b);
cout << lca(a, b).first <<" "<<lca(a,b).second << endl;
}
}
}
169
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
