BZOJ1880 [Sdoi2009]Elaxia的路线【最短路 + dp】

题目

最近，Elaxia和w的关系特别好，他们很想整天在一起，但是大学的学习太紧张了，他们必须合理地安排两个人在一起的时间。Elaxia和w每天都要奔波于宿舍和实验室之间，他们希望在节约时间的前提下，一起走的时间尽可能的长。现在已知的是Elaxia和w**所在的宿舍和实验室的编号以及学校的地图：地图上有N个路口，M条路，经过每条路都需要一定的时间。具体地说，就是要求无向图中，两对点间最短路的最长公共路径。

输入格式

第一行：两个整数N和M（含义如题目描述）。第二行：四个整数x1、y1、x2、y2（1 ≤ x1 ≤ N，1 ≤ y1 ≤ N，1 ≤ x2 ≤ N，1 ≤ ≤ N），分别表示Elaxia的宿舍和实验室及w**的宿舍和实验室的标号（两对点分别 x1,y1和x2,y2）。接下来M行：每行三个整数，u、v、l（1 ≤ u ≤ N，1 ≤ v ≤ N，1 ≤ l ≤ 10000），表 u和v之间有一条路，经过这条路所需要的时间为l。出出出格格格式式式：：：一行，一个整数，表示每天两人在一起的时间（即最长公共路径的长度）。

输出格式

一行，一个整数，表示每天两人在一起的时间（即最长公共路径的长度）

输入样例

9 10

1 6 7 8

1 2 1

2 5 2

2 3 3

3 4 2

3 9 5

4 5 3

4 6 4

4 7 2

5 8 1

7 9 1

输出样例

提示

对于30%的数据，N ≤ 100；

对于60%的数据，N ≤ 1000；

对于100%的数据，N ≤ 1500，输入数据保证没有重边和自环。

题解

最后的路径为公共的最短路，所以我们先将第一对点的所有最短路边建成一个新的拓扑图

然后就可以在新图上dp了

设\(f[i]\)为第一对点走到\(i\)时的最大公共最短路长

显然\(f[i] = max{f[j] + edge.w}\)【\(j\)为\(i\)拓扑图中的前驱点且i-j这条边在第二对点的最短路上】

#include<iostream>

#include<cmath>

#include<cstdio>

#include<queue>

#include<cstring>

#include<algorithm>

#define LL long long int

#define REP(i,n) for (int i = 1; i <= (n); i++)

#define Redge(u) for (int k = h[u],to; k; k = ed[k].nxt)

#define BUG(s,n) for (int i = 1; i <= (n); i++) cout<<s[i]<<' '; puts("");

using namespace std;

const int maxn = 1505,maxm = 3000005,INF = 1000000000;

inline int read(){

	int out = 0,flag = 1; char c = getchar();

	while (c < 48 || c > 57) {if (c == '-') flag = -1; c = getchar();}

	while (c >= 48 && c <= 57) {out = (out << 3) + (out << 1) + c - '0'; c = getchar();}

	return out * flag;

}

int h[maxn],ne = 2;

struct EDGE{int from,to,nxt,w,f;}ed[maxm];

inline void build(int u,int v,int w){

	ed[ne] = (EDGE){u,v,h[u],w}; h[u] = ne++;

	ed[ne] = (EDGE){v,u,h[v],w}; h[v] = ne++;

}

int n,m,S1,T1,S2,T2;

int d[4][maxn],vis[maxn];

struct node{int u,d;};

inline bool operator <(const node& a,const node& b){return a.d > b.d;}

priority_queue<node> q;

void dijkstra(int S,int p){

	for (int i = 1; i <= n; i++) d[p][i] = INF,vis[i] = false;

	d[p][S] = 0;

	node u;

	q.push((node){S,d[p][S]});

	while (!q.empty()){

		u = q.top(); q.pop();

		if (vis[u.u]) continue;

		vis[u.u] = true;

		Redge(u.u) if (!vis[to = ed[k].to] && d[p][to] > d[p][u.u] + ed[k].w){

			d[p][to] = d[p][u.u] + ed[k].w;

			q.push((node){to,d[p][to]});

		}

	}

}

int de[maxn],f[maxn];

queue<int> Q;

void solve(){

	dijkstra(S1,0); dijkstra(T1,1);

	dijkstra(S2,2); dijkstra(T2,3);

	for (int k = 2; k < ne; k++)

		if (d[0][ed[k].from] + ed[k].w + d[1][ed[k].to] == d[0][T1])

			ed[k].f = true,de[ed[k].to]++;

	Q.push(S1);

	int u;

	while (!Q.empty()){

		u = Q.front(); Q.pop();

		Redge(u) if (ed[k].f){

			if (d[2][u] + ed[k].w + d[3][to = ed[k].to] == d[2][T2] || d[3][u] + ed[k].w + d[2][to = ed[k].to] == d[2][T2])

				f[to] = max(f[to],f[u] + ed[k].w);

			if (!(--de[to])) Q.push(to);

		}

	}

	int ans = 0;

	for (int i = 1; i <= n; i++) ans = max(ans,f[i]);

	printf("%d\n",ans);

}

int main(){

	n = read(); m = read();

	S1 = read(); T1 = read(); S2 = read(); T2 = read();

	int a,b,w;

	for (int i = 1; i <= m; i++){

		a = read(); b = read(); w = read();

		build(a,b,w);

	}

	solve();

	return 0;

}