【TJOI2012】桥（最短路径树）

题意

一张有向图，求去掉任意一条边后使得最短路最长。求最长的最短路长度以及删边的方案数。

思路

题解都说是最短路径树，但是实际上这棵树不用建出来，所以也就是一个思路而已。

首先找到一条最短路，可以知道能删的边肯定在这条路径上。可以想象一下，就算有多条最短路也不用管，只要找出一条就好了。

然后试着删掉一条边，删边之后的最短路必然要经过至少一条不在这条路径上的边。我们枚举新最短路上的一条新边，构造出这条最短路径，那么在原最短路径上而不在新最短路径上的某条边删掉时，就有可能会走这条新最短路。

那么考虑构造这条新最短路。假设枚举到的边是u->v，那么新最短路就是s->u->v->t，s->u和v->t都是最短路树上的路径。

然后考虑如何贡献答案。我们记f[i]表示原最短路上第i条边删掉之后能得到的最短路长度。那么只要s->u->v->t不经过i，就可以贡献给i。我们可以记ner[u][0/1]表示在正/反最短路树上，离u最近的最短路径上的点，即终点与u的LCA。知道了这个，u->v贡献给ner[u][0]->ner[v][1]这段路径上的边就可以了。

因为是线性的，所以线段树，或者简单一点，搞个并查集从小到大覆盖就行。

注意不要用SPFA。

图论好题。

代码

#include<bits/stdc++.h>
#define pii pair<int, int>
#define fi first
#define se second
#define mp make_pair
using namespace std;
const int N = 2e5 + 10;
const int M = 4e5 + 10;
struct G
{
	int h[N], ecnt, nxt[M], v[M], w[M];
	void clear(){
		ecnt = 1;
		memset(h, 0, sizeof(h));
	}
	void add_dir(int _u, int _v, int _w){
	    v[++ecnt] = _v; w[ecnt] = _w;
	    nxt[ecnt] = h[_u]; h[_u] = ecnt;
	}
	void add_undir(int _u, int _v, int _w){
	    add_dir(_u, _v, _w);
	    add_dir(_v, _u, _w);
	}
}g;
int n, m, dis[2][N], pre[N][2], ner[2][N], trs[N], pn;
bool inp[N], inp1[M];
struct Data{
	int x, y, l;
}dat[M];
int dn, fa[N], fg[N], ans1, ans2;

queue<int> que;
bool inq[N];
priority_queue<pii> que1;
void dij(int s, int d[N])
{
	memset(d, 0x7f, sizeof(dis) >> 1); d[s] = 0;
	memset(inq, 0, sizeof(inq));
	que1.push(mp(0, s));
	for (int i = 1; i <= n; ++ i){
		int u;
		while (1){
			u = que1.top().se; que1.pop();
			if (!inq[u]){inq[u] = 1; break;}
		}
		for (int i = g.h[u]; i; i = g.nxt[i]){
			int v = g.v[i], w = g.w[i];
			if (d[v] > d[u] + w){
				d[v] = d[u] + w;
				que1.push(mp(-d[v], v));
				pre[v][0] = u; pre[v][1] = i;
			}
		}
	}
	while (!que1.empty()) que1.pop();
}

void bfs(int s, int d[N], int ner[N])
{
	que.push(s);
	memset(inq, 0, sizeof(inq)); inq[s] = 1; ner[s] = s;
	while (!que.empty()){
		int u = que.front(); que.pop();
		for (int i = g.h[u]; i; i = g.nxt[i]){
			int v = g.v[i], w = g.w[i];
			if (!inq[v] && d[v] == d[u] + w){
				if (inp[v]) ner[v] = v;
				else ner[v] = ner[u];
				que.push(v); inq[v] = 1;
			}
		}
	}
}

void get_path()
{
	dij(n, dis[1]);
	dij(1, dis[0]);
	for (int i = n; i != 1; i = pre[i][0]){
		inp1[pre[i][1]] = 1;
		inp[i] = 1;
		trs[i] = ++pn;
	}
	inp[1] = 1;
	trs[1] = pn+1;
	bfs(1, dis[0], ner[0]);
	bfs(n, dis[1], ner[1]);
}

bool cmp(Data x, Data y)
{
	return x.l < y.l;
}

int Find(int x)
{
	if (fa[x] == x) return x;
	return fa[x] = Find(fa[x]);
}

void solve()
{
	for (int u = 1; u <= n; ++ u)
		for (int i = g.h[u]; i; i = g.nxt[i])
			if (!inp1[i]){
				int v = g.v[i];
				int x = trs[ner[1][v]], y = trs[ner[0][u]] - 1;
				int len = dis[0][u] + dis[1][v] + g.w[i];
				if (ner[0][v] == 0 || ner[1][u] == 0 || x > y) continue;
				dat[++dn] = (Data){x, y, len};
			}
	sort(dat + 1, dat + dn + 1, cmp);
	for (int i = 1; i <= pn + 1; ++ i)
		fa[i] = i;
	for (int i = 1; i <= dn; ++ i)
		for (int j = Find(dat[i].x); j <= dat[i].y; j = Find(j)){
			fg[j] = dat[i].l;
			fa[j] = j+1;
		}
	ans1 = 0; ans2 = 0;
	for (int i = 1; i <= pn; ++ i){
		if (fg[i] > ans1) ans1 = fg[i], ans2 = 1;
		else if (fg[i] == ans1) ++ ans2;
	}
}

int main()
{
	scanf("%d%d", &n, &m);
	for (int i = 1; i <= m; ++ i){
		int x, y, z;
		scanf("%d%d%d", &x, &y, &z);
		g.add_undir(x, y, z);
	}
	get_path();
	solve();
	if (ans1 == dis[0][n]) printf("%d %d\n", ans1, m);
	else printf("%d %d\n", ans1, ans2);
	return 0;
}