【模板】静态仙人掌

题目大意

给你一个无向仙人掌图（保证每条边至多出现在一个简单回路中的无向图），问你两个点之间的最短路距离

输入样例#1

9 10 2
1 2 1
1 4 1
3 4 1
2 3 1
3 7 1
7 8 2
7 9 2
1 5 3
1 6 4
5 6 1
1 9
5 7

输出样例#1

5
6

输入样例#2

9 10 3
1 2 1
2 3 1
2 4 4
3 4 2
4 5 1
5 6 1
6 7 2
7 8 2
8 9 4
5 9 2
1 9
5 8
3 4

输出样例#2

7
5
2

样例解释：

样例1中的仙人掌是这个样子的：

询问有两个，分别是询问 1$\to$ 9和 5$\to$ 7的最短路
显然答案分别为 5 和 6。

数据范围：

$1\le n,q\le 10000$
$1\le m\le 20000$
$1\le w\le 10^5$
请注意时限为 $300\text{ms}$

解题思路

我们把该图转化为圆方树
建树规则：
1：对于不在环里面的边，我们保留不变
2：对于环，我们建一个方点（黄色的点），连接这个该环上所有点，边权为为所有点到$dfs$序最小的点的距离（如图）
搜索的时候，我们记录下某个点的$dfs$序，以及从这个点出发走到的点中$dfs$序最小的点的$dfs$序（父亲边除外）
当我们搜到某个点时，枚举到某条边（如图红色的边），若该边指向的点已经搜过，且父亲节点不是该点，且dfs序大于该点，那么我们搜到了一个环，且这个环中$dfs$序最小的点就是该点
$dfs$序大于该点，很显然是该点出发搜索到的点
且与该点相连，那么肯定是一个环了
从该点出发，一边是从该点搜索到的点，且dfs序逐渐变大，$dfs$序大于该点，另一边是红色边的点，$dfs$序也大于该点
那么该点就是该环所有点中$dfs$序最小的点

我们像这样建树
然后得到了一棵圆方数
对于树上两点的最短距离
就是两点到$lca$的距离
若$lca$不是方点，但经过方点，那经过该环的距离就是走到$dfs$序最小的点最短的距离，也就是从该环中某个圆点到方点再到$dfs$序最小的点的距离，所以没有影响

对于$lca$是方点的，我们先计算到该环某个圆点的距离，然后求到对方点的最小距离即可（就是两个方向距离的$min$）

代码

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
using namespace std;
ll n, m, w, x, y, z, q, X, Y, ex, ans, tot, tott, b[100010], fa[200010], dep[200010], dis[200010], sum[200010], dfn[200010], low[200010], h[200010], head[200010], f[200010][20];
struct rec
{ll to, l, next;
}e[2000010], a[2000010];
int read()//快读
{char x=getchar();int d=1,l=0;while (x<'0'||x>'9') {if (x=='-') d=-1;x=getchar();}while (x>='0'&&x<='9') l=(l<<3)+(l<<1)+x-48,x=getchar();return l*d;
}
void writ(int c) {if (c>9) writ(c/10); putchar(c%10+48); return;}
void write(int s) {s<0?putchar(45),writ(-s):writ(s); putchar(10); return;}
void add(ll x, ll y, ll z)//加圆方树的边
{a[++tot].to = y;a[tot].l = z;a[tot].next = head[x];head[x] = tot;a[++tot].to = x;a[tot].l = z;a[tot].next = head[y];head[y] = tot;
}
void addd(ll x, ll y, ll z)//加原图的边
{e[++tott].to = y;e[tott].l = z;e[tott].next = h[x];h[x] = tott;e[++tott].to = x;e[tott].l = z;e[tott].next = h[y];h[y] = tott;
}
void jh(ll x, ll y, ll z)//对于环，建圆方树
{++ex;ll pt = y, ss = z;while(pt != fa[x])//求从x到所有点走反边的距离（红色边的方向）{sum[pt] = ss;ss += b[pt];//求和pt = fa[pt];}sum[ex] = sum[x];sum[x] = 0;pt = y;ss = 0;while(pt != fa[x]){ss = min(sum[pt], sum[ex] - sum[pt]);//走两条边中最短的add(pt, ex, ss);//加边pt = fa[pt];}
}
void dfs(ll x)
{dfn[x] = low[x] = ++w;for (int i = h[x]; i; i = e[i].next)if (e[i].to != fa[x]) {ll v = e[i].to;if (!dfn[v])//没走过{fa[v] = x;b[v] = e[i].l;//记录dfs(v);low[x] = min(low[x], low[v]);//记录由该点走出去的点中dfs序最小的}else low[x] = min(low[x], dfn[v]);//到过了，要不就是走回了变if (low[v] > dfn[x]) add(x, v, e[i].l);}for (int i = h[x]; i; i = e[i].next)if ( dfn[e[i].to] > dfn[x] && fa[e[i].to] != x)jh(x, e[i].to, e[i].l);
}
void dfs1(int x)
{dep[x] = dep[f[x][0]] + 1;for (int j = 1; j <= 16; ++j)f[x][j] = f[f[x][j - 1]][j - 1];//倍增for (int i = head[x]; i; i = a[i].next)if (a[i].to != f[x][0]){f[a[i].to][0] = x;if (dis[a[i].to]) dis[a[i].to] = min(dis[a[i].to], dis[x] + a[i].l);else dis[a[i].to] = dis[x] + a[i].l;dfs1(a[i].to);}
}
ll lca(ll x, ll y)
{if (dep[x] < dep[y]) swap(x, y);//求lcafor (int i = 16; i >= 0; --i)if (dep[f[x][i]] >= dep[y]) x = f[x][i];for (int i = 16; i >= 0; --i)if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];X = x;//若两点不是祖先关系，那会停留在前一个点Y = y;return x == y?x:f[x][0];
}
int main()
{n = read();m = read();q = read();ex = n;for (int i = 1; i <= m; ++i){x = read();y = read();z = read();addd(x, y, z);}dfs(1);f[1][0] = 1;dfs1(1);for (int i = 1; i <= q; ++i){x = read();y = read();z = lca(x, y);if (z <= n) ans = dis[x] + dis[y] - dis[z] - dis[z];//lca是圆点else{ans = dis[x] - dis[X] + dis[y] - dis[Y]; //到环上两圆点的距离if (sum[X] > sum[Y]) swap(X, Y);ans += min(sum[Y] - sum[X], sum[z] - sum[Y] + sum[X]);//环的两个方向}write(ans);}return 0;
}