洛谷：P2685 [TJOI2012]桥 （正反最短路，区间维护）

桥

题意：

Boss会镇守一条路，使得玩家从 1 走到 n 的最短距离尽可能大；

思路：

• 显然 Boss 必须镇守 1 到 n 最短路上的一条路，不然玩家肯定能走最短路。

• 所以此问题就变成：删掉最短路上的任意一条边，使得 1 到 n 的最短距离最大

暴力：我们肯定能枚举删掉最短路上的每一条边，然后再跑一遍最短路，但不用想时间复杂度都爆表；

那我们能不能预处理出这些情况，使得不需要每次都跑一遍最短路呢？

答案是可以的：

• 首先以 1、n 为起点各跑一遍最短路，这样我们能得到两颗最短路树交织形成的图；
• 之后我们再从这两颗最短路树的根（一左一右）各跑一遍bfs，途中记录每一个点是从 1 ~ n 这条最短路上的哪一个点过来的

红色是我们的最短路，绿色代表该点从红边上的哪一个点过来；以1、n为根左右都跑一遍bfs，每个点就有左右 l[i]、r[i] 的标记了

• 自此我们预处理就完成了，可以发现，现在我们枚举的每一条不在最短路上的边 {a、b、w} ，路径 {1 ~ n} 可以用 {1 ~ l[a] ~ a ~ b ~ r[b] ~ n} 代替

• 这个代替的前提是是什么？就是路径 {l[a] ~ r[b]} 上任意一条边被占据，当此路径被占据时，我们就可以用 dist1[a] + distn[b] + w 尝试替代 dist1[n]
• 可以发现这是一个区间问题，1 ~ n 路径上所有的边看作一个个区间，区间维护的信息是：当删掉此区间内的一条边后这个图的 1 ~ n 最短路值
• 我们完全可以用线段树维护这个区间，枚举最短路之外的每一条边，对于这条边 {a、b、w} ，在线段树上修改 {l[a]，r[b]} 的值
• 最后遍历一遍我们的线段树，到底的每一条边的信息取一个 max 就是我们的答案了

细节看注释吧
Code：

#include<bits/stdc++.h>
#include<unordered_set>
#include<unordered_map>
#define mem(a,b) memset(a,b,sizeof a)
#define cinios (ios::sync_with_stdio(false),cin.tie(0),cout.tie(0))
#define sca scanf
#define pri printf
#define ul (u << 1)
#define ur (u << 1 | 1)
#define forr(a,b,c) for(int a=b;a<=c;a++)
#define rfor(a,b,c) for(int a=b;a>=c;a--)
//#define x first
//#define y second
//[博客地址](https://blog.csdn.net/weixin_51797626?t=1) 
using namespace std;
inline int read() { int x = 0, f = 1, ch = getchar(); while (ch < '0' || ch>'9') { if (ch == '-') f = -1; ch = getchar(); } while (ch >= '0' && ch <= '9') { x = x * 10 + ch - '0'; ch = getchar(); } return x * f; }
inline void write(int x) { if (x < 0) putchar('-'), x = -x; if (x >= 10) write(x / 10); putchar(x % 10 + '0'); }

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;

const int N = 100010, M = 1000010, MM = N;
int INF = 0x3f3f3f3f, mod = 998244353;
ll LNF = 0x3f3f3f3f3f3f3f3f;
int n, m, k, T, S, D;
int h[N], e[M], ne[M], w[M], idx;
int dist1[N], distn[N], l[N], r[N];
bool st[N], isdis[M];
vector<int> arr;
int id[N], mx = -1, cnt;

inline void add(int a, int b, int x) {
	e[idx] = b, ne[idx] = h[a], w[idx] = x, h[a] = idx++;
}

void dj(int* d, int x) {
	mem(st, 0);
	d[x] = 0;
	priority_queue<PII, vector<PII>, greater<PII>> q;
	q.push({ 0,x });

	while (q.size())
	{
		int ver = q.top().second;
		q.pop();

		if (st[ver])continue;
		st[ver] = true;

		for (int i = h[ver]; ~i; i = ne[i]) {
			int j = e[i];
			if (d[j] > d[ver] + w[i]) {
				d[j] = d[ver] + w[i];
				q.push({ d[j],j });
			}
		}
	}
}

void bfs(int* l, int* d) {
	queue<int> q;
	for (auto j : arr) {
		l[j] = j;
		q.push(j);
	}
	while (q.size())
	{
		int t = q.front();
		q.pop();
		for (int i = h[t]; ~i; i = ne[i]) {
			int j = e[i];
			if (d[t] + w[i] == d[j] && !l[j]) { 
				//在最短路树上维护l[i]、r[i]
				l[j] = l[t];
				q.push(j);
			}
		}
	}
}

struct tree
{
	int l, r, w;
}tr[N << 2]; //线段树板子
void build(int u, int l, int r) {
	tr[u] = { l,r,INF };
	if (l == r)return;
	int mid = l + r >> 1;
	build(ul, l, mid), build(ur, mid + 1, r);
}
inline void pushdown(int u) {
	tr[ul].w = min(tr[ul].w, tr[u].w);
	tr[ur].w = min(tr[ur].w, tr[u].w);
}
void modify(int u, int l, int r, int d) {
	if (tr[u].l >= l && tr[u].r <= r) {
		tr[u].w = min(tr[u].w, d);//平常无需pushdown
		return;
	}
	int mid = tr[u].l + tr[u].r >> 1;
	if (mid >= l)modify(ul, l, r, d);
	if (mid < r)modify(ur, l, r, d);
}
void query(int u) {
	if (tr[u].l == tr[u].r) {
		if (mx < tr[u].w && tr[u].w != INF) {
			mx = tr[u].w;
			cnt = 1;
		}
		else if (mx == tr[u].w)cnt++;//累计方案数
		return;
	}
	pushdown(u);//最后查询的时候pushdown即可
	query(ul); query(ur);
}

int main() {
	cinios;

	cin >> n >> m;
	mem(h, -1);
	forr(i, 1, m) {
		int a, b, x;
		cin >> a >> b >> x;
		add(a, b, x), add(b, a, x);
	}

	mem(dist1, 0x3f);
	mem(distn, 0x3f);
	dj(distn, n);
	dj(dist1, 1);//两遍最短路

	int z = 1;
	arr.push_back(z);//记录路径
	while (z != n) {
		for (int k = h[z]; ~k; k = ne[k]) {
			int j = e[k];
			if (distn[z] == distn[j] + w[k]) { //切记从树叶跑到树根，不然有分叉会错
				z = j;
				arr.push_back(z);
				isdis[k] = isdis[k ^ 1] = true;//标记点会错，要标记边
				break;
			}
		}
	}
	for (int j = 0; j < arr.size(); j++)
		id[arr[j]] = j + 1;//离散到线段树上的点

	bfs(l, dist1);
	bfs(r, distn);//处理每个点的l[i]、r[i]

	build(1, 1, arr.size() - 1);//建树，是区间，注意范围
	
	for (int i = 0; i < idx; i++) {
		if (isdis[i])continue;//枚举所有不在最短路上的边
		int b = e[i], a = e[i ^ 1];
		if (dist1[a] < dist1[b]) { //满足前后关系
			modify(1, id[l[a]], id[r[b]] - 1, dist1[a] + distn[b] + w[i]);
		}
	}
	
	query(1);
	if (mx == dist1[n])cnt = m;//如果修改不能减少最短路长度，显然删任何边都行
	cout << mx << ' ' << cnt;

	return 0;
}
/*
*/

玛丽卡（此题简化版，好像也没简化多少 ）