[SDOI 2009]Elaxia的路线

Description

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

Input

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

Output

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

Sample Input

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

Sample Output

3

HINT

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

题解

一开始看点数小，直接强行$SPFA$预处理出第一条路径，然后再$SPFA$第二条路径时记录答案。$TLE$...

• 首先，分别从$x_1$，$y_1$，$x_2$，$y_2$为源点分别跑一次$SPFA$，记$dis[0][u]$，$dis[1][u]$，$dis[2][u]$，$dis[3][u]$分别为从$x_1$，$y_1$，$x_2$，$y_2$为起始点到点$u$的最短路径。

• 构建出一个新的有向图，包含$x_1->y_1$和$x_2->y_2$的所有最短路上的边。判断一条边$u->v$是否在$x_1->y_1$的最短路上，就是判断$dis[1][u]+val(u,v)+dis[2][v]==dis[1][y1]$（$val(u,v)$为边$u->v$的长度），如果为真，那么在最短路上，为假则不在最短路上。是否在$x_2->y_2$的最短路上同理。

• 不过要注意一点，因为边的走向可能是$u->v$，也可能是$v->u$。所以，对于一条边必须判断两次（第一次为$u->v$，第二次为$v->u$）。

• 最后，按照新图的拓扑序，在各个点之间进行递推，求得答案。

 //It is made by Awson on 2017.10.20
 #include <set>
 #include <map>
 #include <cmath>
 #include <ctime>
 #include <cmath>
 #include <stack>
 #include <queue>
 #include <vector>
 #include <string>
 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 #define LL long long
 #define Min(a, b) ((a) < (b) ? (a) : (b))
 #define Max(a, b) ((a) > (b) ? (a) : (b))
 #define sqr(x) ((x)*(x))
 #define y1 yy
 using namespace std;
 const int N = ;

 int n, m, x1, x2, y1, y2, u, v, c;
 struct tt {
   int to, cost, next;
   bool color;
 }edge[(N*N>>)+], g[(N*N>>)+];
 int path[N+], top, path_g[N+], top_g;
 int dist[][N+], ans, cnt[N+], in[N+];
 struct node {
   int x, val;
   node (){
   }
   node (int _x, int _val) {
     x = _x, val = _val;
   }
 };

 void init(int u, int v, int c) {
   g[++top_g].to = v;
   g[top_g].cost = c;
   g[top_g].next = path_g[u];
   path_g[u] = top_g;
 }
 void add(int u, int v, int c) {
   edge[++top].to = v;
   edge[top].next = path[u];
   edge[top].cost = c;
   path[u] = top;
 }
 void topsort() {
   queue<node>Q; while (!Q.empty()) Q.pop();
   for (int i = ; i <= n; i++) if (!in[i]) Q.push(node(i, ));
   while (!Q.empty()) {
     int u = Q.front().x, val = Q.front().val; Q.pop();
     ans = Max(ans, val);
     for (int i = path_g[u]; i; i = g[i].next) {
       int v = g[i].to; in[v]--; cnt[v] = Max(cnt[v], val+g[i].cost);
       if (!in[v]) Q.push(node(v, cnt[v]));
     }
   }
 }
 void SPFA(int x, int t) {
   bool vis[N+] = {}; vis[x] = ;
   memset(dist[t], /, sizeof(dist[t])); dist[t][x] = ;
   queue<int>Q; while (!Q.empty()) Q.pop(); Q.push(x);
   while (!Q.empty()) {
     int u = Q.front(); Q.pop(); vis[u] = ;
     for (int i = path[u]; i; i = edge[i].next) {
       int v = edge[i].to;
       if (dist[t][v] > dist[t][u]+edge[i].cost) {
     dist[t][v] = dist[t][u]+edge[i].cost;
     if (!vis[v]) {
       vis[v] = ; Q.push(v);
     }
       }
     }
   }
 }
 void work() {
   scanf("%d%d%d%d%d%d", &n, &m, &x1, &y1, &x2, &y2);
   for (int i = ; i <= m; i++) {
     scanf("%d%d%d", &u, &v, &c);
     add(u, v, c), add(v, u, c);
   }
   SPFA(x1, ); SPFA(y1, ); SPFA(x2, ), SPFA(y2, );
   for (int u = ; u <= n; u++)
     for (int i = path[u]; i; i = edge[i].next) {
       int v = edge[i].to;
       if (dist[][u]+dist[][v]+edge[i].cost != dist[][y1]) continue;
       if (dist[][u]+dist[][v]+edge[i].cost != dist[][y2]) continue;
       init(u, v, edge[i].cost); in[v]++;
     }
   topsort();
   memset(path_g, , sizeof(path_g)); top_g = ;
   memset(cnt, , sizeof(cnt));
   for (int u = ; u <= n; u++)
     for (int i = path[u]; i; i = edge[i].next) {
       int v = edge[i].to;
       if (dist[][u]+dist[][v]+edge[i].cost != dist[][y1]) continue;
       if (dist[][u]+dist[][v]+edge[i].cost != dist[][y2]) continue;
       init(u, v, edge[i].cost); in[v]++;
     }
   topsort();
   printf("%d\n", ans);
 }
 int main() {
   work();
   return ;
 }