洛谷·bzoj·[Sdoi2009]Elaxia的路线

初见安：这里是传送门：洛谷P2149 & bzoj P1880

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 ≤ ≤ 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，输入数据保证没有重边和自环。

Sol

这个题我卡了好久QAQ可以说是实力毒瘤了。求无向图两条最短路径的最长公共部分，首先得到两条线路的最短路径并把边处理出来是很简单的，而要得到重合的边，处理每个点到终点的距离，在两条线路上同时满足  是不行的。因为有可能你枚举的边刚好长度合适，但是其实到不了起点。所以还要算一遍从起点出发每个点的距离，使得u到起点的距离+边的长度+v到终点的距离=起点到终点的距离才行。这里有一个细节——因为是无向图，所以如果一个人是从u走到v，而另一个人是从v走到u，同样满足题意但是我们却判断不到。这样的话我们先正着跑一遍，再反着跑一遍就行了。也就是把其中一条路径的条件中的u和v的要求反过来。

问题来了——怎么跑？据前文意思，要跑四遍最短路预处理，然后处理两次重合的边并当成图存下来。接下来就可以找最长的路径了。怎么找？因为重合的边已经和起点终点没有关系了。既然是当成图存的，那么就不一定仍旧是无向图了，所以我们可以用拓扑排序扩散重合的每条边，求出最长的一段连续距离【两人能一起走的部分一定是连续的一条链，否则的话既然另一个人走了更短的那条路，你怎么不走呢】即可。

思路大体清晰，但是细节很多，代码【本狸比较蠢】双又很冗长……见谅……【核心部分不多真的！QAQ】

#include<bits/stdc++.h>
#define maxn 1505
using namespace std;
int read()
{
    int x = 0, ch = getchar();
    while(!isdigit(ch)) ch = getchar();
    while(isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
    return x;
}

struct edge
{
    int to, w, nxt;
    edge() {}
    edge(int t, int ww, int nn) {to = t, w = ww, nxt = nn;}
}e[maxn * maxn << 1], e1[maxn * maxn << 1];

int head[maxn], k = 0;
void add(int u, int v, int w)
{
    e[k] = edge(v, w, head[u]);
    head[u] = k++;
}

int head1[maxn], k1 = 0;//其实可以结构体打包……代码量就可以少一点 
void add1(int u, int v, int w)
{
    e1[k1] = edge(v, w, head1[u]);
    head1[u] = k1++;
}

int n, m;
int s1, t1, s2, t2;
int dis1[maxn], dis2[maxn], dis3[maxn], dis4[maxn], ind[maxn];
bool vis[maxn];
void spfa(int u, int *dis)//正常求最短路 
{
    memset(vis, 0, sizeof vis);
    queue<int> q;
    q.push(u);
    dis[u] = 0;
    register int v;
    while(q.size())
    {
        
        u = q.front(); q.pop(); vis[u] = false;
        for(int i = head[u]; ~i; i = e[i].nxt)
        {
            v = e[i].to;
            if(dis[u] + e[i].w < dis[v])
            {
                dis[v] = dis[u] + e[i].w;
                if(!vis[v]) q.push(v), vis[v] = true;
            }
        }
    }
}

void resign(int op)//找重合的边 
{
    for(int u = 1; u <= n; u++)
        for(int i = head[u]; ~i; i = e[i].nxt)
        {	
            register int v = e[i].to;
            if(op && dis1[u] + e[i].w + dis2[v] == dis1[t1] && dis3[u] + e[i].w + dis4[v] == dis3[t2])//两路同时满足的条件 
                add1(u, v, e[i].w), ind[v]++;
            if(!op && dis1[u] + e[i].w + dis2[v] == dis1[t1] && dis4[u] + e[i].w + dis3[v] == dis3[t2])
                add1(u, v, e[i].w), ind[v]++;
        }
}

int len[maxn], ans = 0;
void topo()
{
    queue<int> q;
    for(int i = 1; i <= n; i++) if(!ind[i]) q.push(i);
    register int u, v;
    while(q.size())
    {
        u = q.front(), q.pop();
        for(int i = head1[u]; ~i; i = e1[i].nxt)
        {
            v = e1[i].to;
            len[v] = max(len[v], len[u] + e1[i].w);//拓扑排序找最长链 
            ans = max(ans, len[v]);
            ind[v]--;
            if(!ind[v]) q.push(v);
        }
    } 
}

int main()
{
    memset(dis1, 0x3f, sizeof dis1);
    memset(dis2, 0x3f, sizeof dis2);
    memset(dis3, 0x3f, sizeof dis3);
    memset(dis4, 0x3f, sizeof dis4);
    memset(head, -1, sizeof head);
    memset(head1, -1, sizeof head1);
    n = read(), m = read();
    s1 = read(), t1 = read(), s2 = read(), t2 = read();
    register int u, v, w;
    for(int i = 1; i <= m; i++)
        u = read(), v = read(), w = read(), add(u, v, w), add(v, u, w);
    
    spfa(s1, dis1);
    spfa(t1, dis2);
    spfa(s2, dis3);
    spfa(t2, dis4);//4个点分别作为起点跑一遍最短路 
    
    resign(0); topo();
    memset(ind, 0, sizeof ind);//随时memset初始化…… 
    memset(head1, -1, sizeof head);
    k1 = 0;
    resign(1); topo();
    printf("%d\n", ans);
    return 0;
} 

迎评：）
——End——