Solution -「洛谷 P5236」「模板」静态仙人掌

$\mathcal{Description}$

  Link.

  给定一个 $n$ 个点 $m$ 条边的仙人掌，$q$ 组询问两点最短路。

  $n,q\le10^4$，$m\le2\times10^4$。

$\mathcal{Solution}$

  提出一个环来考虑，从环上一点 $u$ 到 $v$，无非两条路径。可以按顺序处理一个前缀和。如图：

  令 $sum_2$ 为结点 $1$ 到 $2$ 的顺时针距离，$sum_3$ 为结点 $1$ 到 $3$ 的顺时针距离……特别地，$sum_1$ 记录整个环的大小。那么环上 $u$ 和 $v$ 的最短距离就是 $\min\{|sum_u-sum_v|,sum_1-|sum_u-sum_v|\}$。这样就能 $\mathcal O(1)$ 求到了。

  接下来建圆方树（很多题解说建树的细节与普通图不一样，其实正常建也没有任何问题 qwq），发现一个圆点走进方点（点双），在走到父亲圆点的最短距离可以在 $\text{Tarjan}$ 算法中预处理出来。考虑圆方树上的边权：圆点到父亲方点的边权为上述最短距离，否则为 $0$。对于询问 $(u,v)$，找到其 $\text{LCA}$（设为 $w$），分 $w$ 的情况讨论：

• $w$ 是圆点，那么 $\text{LCA}$ 时求出的树上距离就是答案。
• $w$ 是方点，此时树上距离实际上是 $u$ 和 $v$ 走到 $w$ 的父亲圆点的距离之和，明显时错误的——$u$ 和 $v$ 走进同一个点双后，需要求一次最短距离而非直接在父亲会和。所以可以倍增求到 $u$ 走进点双的第一个点（即方点向 $u$ 点方向的儿子圆点）$u'$，同理求出 $v'$，利用处理的前缀和求到 $u'$ 到 $v'$ 的最短距离。那么答案就是 $\operatorname{dist}(u,u')+\operatorname{dist}(u',v')+\operatorname{dist}(v',v)$。

  复杂度 $\mathcal O(n\log n)$。不过这里作者偷懒用 std::map 记录了每个环的 $sum$，写得好看一点是可以在这一部分做到 $\mathcal O(n)$。但求走进点双的第一个点似乎必须用带 $\log$ 的算法 owo？

$\mathcal{Code}$

#include <map>
#include <cstdio>
#include <algorithm>

#define adj( g, u, v, c ) \
	for ( int eid = g.head[u], v, c; v = g.to[eid], c = g.cst[eid], eid; eid = g.nxt[eid] )

const int MAXN = 2e4, MAXM = 4e4;
int n, m, q, snode, fa[MAXN + 5][15];
int dfc, top, dfn[MAXN + 5], low[MAXN + 5], stk[MAXN + 5];
int dep[MAXN + 5], dis[MAXN + 5], root[MAXN + 5];
std::map<int, int> sum[MAXN + 5];

struct Graph {
	int ecnt, head[MAXN + 5], to[MAXM + 5], cst[MAXM + 5], nxt[MAXM + 5];
	inline void link ( const int s, const int t, const int c ) {
		to[++ ecnt] = t, cst[ecnt] = c, nxt[ecnt] = head[s];
		head[s] = ecnt;
	}
	inline void add ( const int u, const int v, const int c ) {
		link ( u, v, c ), link ( v, u, c );
	}
} src, tre;

inline char fgc () {
	static char buf[1 << 17], *p = buf, *q = buf;
	return p == q && ( q = buf + fread ( p = buf, 1, 1 << 17, stdin ), p == q ) ? EOF : *p ++;
}

inline int rint () {
	int x = 0; char s = fgc ();
	for ( ; s < '0' || '9' < s; s = fgc () );
	for ( ; '0' <= s && s <= '9'; s = fgc () ) x = x * 10 + ( s ^ '0' );
	return x;
}

inline void wint ( const int x ) {
	if ( 9 < x ) wint ( x / 10 );
	putchar ( x % 10 ^ '0' );
}

inline int min_ ( const int a, const int b ) { return a < b ? a : b; }

inline bool chkmin ( int& a, const int b ) { return b < a ? a = b, true : false; }

inline bool chkmax ( int& a, const int b ) { return a < b ? a = b, true : false; }

inline int cost ( const Graph& g, const int s, const int t ) {
	adj ( g, s, u, c ) if ( u == t ) return c;
	return -1;
}

inline int mncost ( const int id, int u, int v ) {
	int t1 = sum[id][u], t2 = sum[id][v];
	if ( t1 > t2 ) t1 ^= t2 ^= t1 ^= t2;
	return min_ ( t2 - t1, sum[id][root[id]] - ( t2 - t1 ) );
}

inline void buildSquare ( const int rt, const int p, const int sid ) {
	int beg = top; for ( ; stk[beg] ^ p; -- beg );
	root[sid] = rt;
	// loop: rt - stk[beg] - stk[beg + 1] - ... - stk[top] - rt.
	for ( int i = beg, cur = p, pre = rt; i <= top; pre = cur, cur = stk[++ i] ) {
		sum[sid][cur] = sum[sid][pre] + cost ( src, pre, cur );
	}
	sum[sid][rt] = sum[sid][stk[top]] + cost ( src, stk[top], rt );
	int u;
	do {
		u = stk[top --];
		tre.add ( sid, u, mncost ( sid, rt, u ) );
	} while ( u ^ p );
}

inline void Tarjan ( const int u, const int fa ) {
	dfn[u] = low[u] = ++ dfc, stk[++ top] = u;
	adj ( src, u, v, c ) if ( v ^ fa ) {
		if ( ! dfn[v] ) {
			Tarjan ( v, u ), chkmin ( low[u], low[v] );
			if ( low[v] >= dfn[u] ) {
				tre.add ( u, ++ snode, 0 );
				buildSquare ( u, v, snode );
			}
		} else chkmin ( low[u], dfn[v] );
	}
}

inline void init ( const int u, const int f ) {
	dep[u] = dep[fa[u][0] = f] + 1;
	for ( int i = 1; i <= 14; ++ i ) fa[u][i] = fa[fa[u][i - 1]][i - 1];
	adj ( tre, u, v, c ) if ( v ^ f ) {
		dis[v] = dis[u] + c;
		init ( v, u );
	}
}

inline int calcLCA ( int u, int v ) {
	if ( dep[u] < dep[v] ) u ^= v ^= u ^= v;
	for ( int i = 14; ~ i; -- i ) if ( dep[fa[u][i]] >= dep[v] ) u = fa[u][i];
	if ( u == v ) return u;
	for ( int i = 14; ~ i; -- i ) if ( fa[u][i] ^ fa[v][i] ) u = fa[u][i], v = fa[v][i];
	return fa[u][0];
}

inline int climb ( int u, const int tar ) {
	for ( int i = 14; ~ i; -- i ) if ( dep[fa[u][i]] > dep[tar] ) u = fa[u][i];
	return u; 
}

int main () {
	n = snode = rint (), m = rint (), q = rint ();
	for ( int i = 1, u, v, w; i <= m; ++ i ) {
		u = rint (), v = rint (), w = rint ();
		src.add ( u, v, w );
	}
	Tarjan ( 1, 0 );
	init ( 1, 0 );
	for ( int u, v; q --; ) {
		u = rint (), v = rint ();
		int w = calcLCA ( u, v );
		if ( w <= n ) wint ( dis[u] + dis[v] - 2 * dis[w] );
		else {
			int pu = climb ( u, w ), pv = climb ( v, w );
			wint ( dis[u] - dis[pu] + dis[v] - dis[pv] + mncost ( w, pu, pv ) );
		}
		putchar ( '\n' );
	}
	return 0;
}