BZOJ 2725 [Violet 6]故乡的梦 线段树+最短路树

\(\color{#0066ff}{ 题目描述 }\)

\(\color{#0066ff}{输入格式}\)

\(\color{#0066ff}{输出格式}\)

\(\color{#0066ff}{输入样例}\)

6 7
1 2 1
2 3 1
3 4 2
4 5 1
5 6 1
1 3 3
4 6 3
1 6
4
1 2
1 3
4 3
6 5

\(\color{#0066ff}{输出样例}\)

7
6
Infinity
7

\(\color{#0066ff}{数据范围与提示}\)

\(\color{#0066ff}{ 题解 }\)

分别从s和t跑最短路，构建出最短路树

标记最短路树的点和边

从最短路树上的每个点bfs，找到能影响的L和R

显然若上图a，b之间的某条边断了，x到y的边就可以用来更新这部分答案

从a找到所有x，b找到所有y

枚举所有边，只要不在最短路树上，就类似于上图更新（用线段树维护）

在\(O(nlogn)\)的复杂度下求出删去每条最短路树上的边的ans

对于询问，如果不是最短路树的边，ans就是最短路

否则用刚刚在线段树求的ans输出

跑dij的pair要开long long！！！！

#include<bits/stdc++.h>
#define LL long long
LL in() {
	char ch; LL x = 0, f = 1;
	while(!isdigit(ch = getchar()))(ch == '-') && (f = -f);
	for(x = ch ^ 48; isdigit(ch = getchar()); x = (x << 1) + (x << 3) + (ch ^ 48));
	return x * f;
}
const int maxn = 2e6 + 100;
int L[maxn], R[maxn], S, T;
int n, m;
struct node {
	int to;
	LL dis;
	bool vis;
	node *nxt;
	node(int to = 0, LL dis = 0, bool vis = false, node *nxt = NULL): to(to), dis(dis), vis(vis), nxt(nxt) {}
};
node *head[maxn];
bool vis[maxn];
LL diss[maxn], dist[maxn];
int st[maxn], cnt, rst[maxn];
LL ans[maxn];
const LL inf = 9999999999999LL;
using std::pair;
using std::make_pair;
struct Tree {
	Tree *ch[2];
	LL val;
	int l, r;
	Tree(LL val = 0, int l = 0, int r = 0): val(val), l(l), r(r) {}
}*root;
void build(Tree *&o, int l, int r) {
	o = new Tree(inf, l, r);
	if(l == r) return;
	int mid = (l + r) >> 1;
	build(o->ch[0], l, mid);
	build(o->ch[1], mid + 1, r);
}
void add(int from, int to, LL dis) {
	head[from] = new node(to, dis, 0, head[from]);
}
void dij(int s, LL *dis) {
	std::priority_queue<pair<LL, int>, std::vector<pair<LL, int> >, std::greater<pair<LL, int> > > q;
	for(int i = 1; i <= n; i++) vis[i] = 0, dis[i] = inf;
	q.push(make_pair(dis[s] = 0, s));
	while(!q.empty()) {
		int tp = q.top().second;
		q.pop();
		if(vis[tp]) continue;
		vis[tp] = true;
		for(node *i = head[tp]; i; i = i->nxt)
			if(dis[i->to] > dis[tp] + i->dis)
				q.push(make_pair(dis[i->to] = dis[tp] + i->dis, i->to));
	}
}
void bfs(int s, int *P, LL *dis) {
	std::queue<int> v;
	P[st[s]] = s;
	v.push(st[s]);
	while(!v.empty()) {
		int tp = v.front(); v.pop();
		for(node *i = head[tp]; i; i = i->nxt) {
			if(dis[i->to] == dis[tp] + i->dis && !vis[i->to] && !P[i->to]) {
				P[i->to] = s;
				v.push(i->to);
			}
		}
	}
}
void change(Tree *o, int l, int r, LL val) {
	if(o->r < l || o->l > r) return;
	if(l <= o->l && o->r <= r) return (void)(o->val = std::min(o->val, val));
	change(o->ch[0], l, r, val), change(o->ch[1], l, r, val);
}
void query(Tree *o) {
	if(o->l == o->r) return (void)(ans[o->l] = o->val);
	o->ch[0]->val = std::min(o->ch[0]->val, o->val);
	o->ch[1]->val = std::min(o->ch[1]->val, o->val);
	query(o->ch[0]);
	query(o->ch[1]);
}
int main() {
	n = in(), m = in();
	LL x, y, z;
	for(int i = 1; i <= m; i++) {
		x = in(), y = in(), z = in();
		add(x, y, z), add(y, x, z);
	}
	dij(S = in(), diss);
	dij(T = in(), dist);
	for(int i = 1; i <= n; i++) vis[i] = 0;
	for(int o = S; o != T;) {
		st[rst[o] = ++cnt] = o;
		vis[o] = true;
		for(node *i = head[o]; i; i = i->nxt) {
			if(diss[o] + dist[i->to] + i->dis == diss[T]) {
				i->vis = true;
				o = i->to;
				break;
			}
		}
	}
	st[rst[T] = ++cnt] = T;
	vis[T] = true;
	for(int i = 1; i <= cnt; i++) bfs(i, L, diss);
	for(int i = cnt; i >= 1; i--) bfs(i, R, dist);
	build(root, 1, cnt);
	for(int i = 1; i <= n; i++)
		for(node *j = head[i]; j; j = j->nxt) {
			if(j->vis) continue;
			if(L[i] < R[j->to] && L[i] && R[j->to]) change(root, L[i], R[j->to] - 1, diss[i] + dist[j->to] + j->dis);
		}
	query(root);
	for(int q = in(); q --> 0;) {
		x = in(), y = in();
		if(rst[x] > 0 && rst[y] > 0 && abs(rst[x] - rst[y]) == 1) {
			LL t = ans[std::min(rst[x], rst[y])];
			if(t == inf) printf("Infinity\n");
			else printf("%lld\n", t);
		}
		else if(diss[T] == inf) printf("Infinty\n");
		else printf("%lld\n", diss[T]);
	}
	return 0;
}