[BZOJ1880][Sdoi2009]Elaxia的路线

最新推荐文章于 2019-11-11 19:19:50 发布

转载最新推荐文章于 2019-11-11 19:19:50 发布 · 131 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/dsjkafdsaf/p/11270289.html

本文探讨了一种解决两个点对之间寻找最短路径的最长公共路径问题的算法。通过构造无向图并利用拓扑排序，算法有效地找出两对点最短路径的交集，以确定两人在一起的最长时间。

题目描述

最近，\(Elaxia\)和\(w\)的关系特别好，他们很想整天在一起，但是大学的学习太紧张了，他们必须合理地安排两个人在一起的时间。

\(Elaxia\)和\(w\)每天都要奔波于宿舍和实验室之间，他们希望在节约时间的前提下，一起走的时间尽可能的长。

现在已知的是\(Elaxia\)和\(w\)所在的宿舍和实验室的编号以及学校的地图：地图上有\(N\)个路口，\(M\)条路，经过每条路都需要一定的时间。具体地说，就是要求无向图中，两对点间最短路的最长公共路径。

Input

第一行：两个整数\(N\)和\(M\)（含义如题目描述）。

第二行：四个整数\(x_1,y_1,x_2,y_2（1≤x_1≤N,1≤y_1≤N,1≤x_2≤N,1≤y_2≤N）\)，分别表示\(Elaxia\)的宿舍和实验室及\(w\)的宿舍和实验室的标号（两对点分别 \(x_1,y_1\)和\(x_2,y_2\)）。

接下来\(M\)行：每行三个整数，\(u\),\(v\),\(l\)\(（1≤u≤N,1≤v≤N,1≤l≤10000）\)，表 \(u\)和\(v\)之间有一条路，经过这条路所需要的时间为\(l\)。

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

Output

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

Sample Input

Sample Output

很显然，对于在一起的路径，他一定是连续的。

因为，若不是连续的路径，中间的一段路肯定是走较短的那一段更优。

所以，那一段路一定是连续的路径。

问题就变成了，两对点的最短路径的交集的最长链。

对于一对点的最长链，若满足\(dis[x]+cost[x][y]==dis[y]\)，那么\(x->y\)，这条路径就在最短路图上了。

求出两个图的交集即可。

这个图具有拓扑关系，优先级更高的点可以更新其他与他相连的点。

由此，我们可以找出交集中入度为\(0\)的点，将其加入源点，同时跑拓扑。

最后，距离最大的值就是答案了。

有一个细节就是，题目并没有严格规定方向，所以必须在一对边的最短路图中把反向表也标记。

代码如下

#include <cstdio>
#include <cstring>
#include <queue>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
#define LL long long
#define u64 unsigned long long
#define reg register
#define Raed Read
#define debug(x) cerr<<#x<<" = "<<x<<endl;
#define rep(a,b,c) for(reg int a=(b),a##_end_=(c); a<=a##_end_; ++a)
#define ret(a,b,c) for(reg int a=(b),a##_end_=(c); a<a##_end_; ++a)
#define drep(a,b,c) for(reg int a=(b),a##_end_=(c); a>=a##_end_; --a)
#define erep(i,G,x) for(reg int i=(G).Head[x]; i; i=(G).Nxt[i])
 
inline int Read() {
    int res = 0, f = 1;
    char c;
    while (c = getchar(), c < 48 || c > 57)if (c == '-')f = 0;
    do res = (res << 3) + (res << 1) + (c ^ 48);
    while (c = getchar(), c >= 48 && c <= 57);
    return f ? res : -res;
}
 
template<class T>inline bool Min(T &a, T const&b) {
    return a > b ? a = b, 1 : 0;
}
template<class T>inline bool Max(T &a, T const&b) {
    return a < b ? a = b, 1 : 0;
}
 
const int N = 1505, M = N*N, mod = 1e9 + 9;
 
bool MOP1;
 
int n,m,sx1,sy1,sx2,sy2;
 
struct Link_list {
    int Tot,Head[N],Nxt[M],to[M],cost[M];
    inline void AddEdgepair(int a,int b,int c) {
        to[++Tot]=b,cost[Tot]=c,Nxt[Tot]=Head[a],Head[a]=Tot;
        to[++Tot]=a,cost[Tot]=c,Nxt[Tot]=Head[b],Head[b]=Tot;
    }
} G;
 
struct T2100 {
    int vis[N],Dis[N],Ans;
    struct node {
        int u,dis;
        bool operator<(node _)const {
            return dis>_.dis;
        }
    };
    void Dij(int x) {
        memset(Dis,6,sizeof Dis);
        memset(vis,0,sizeof vis);
        priority_queue<node>Q;
        Dis[x]=vis[x]=0;
        Q.push((node)<%x,0%>);
        while(!Q.empty()) {
            node Now=Q.top();
            Q.pop();
            int No=Now.u;
            if(vis[No])continue;
            vis[No]=1;
            erep(i,G,No) {
                int y=G.to[i];
                if(Dis[No]+G.cost[i]<Dis[y]) {
                    Dis[y]=Dis[No]+G.cost[i];
                    Q.push((node)<%y,Dis[y]%>);
                }
            }
        }
    }
    int us[N];
    int path1[M];
    bool In1[N];
    bool dfs1(int x) {
        if(x==sy1)return true;
        if(us[x])return In1[x];
        bool tot=false;
        erep(i,G,x) {
            int y=G.to[i];
            if(Dis[x]+G.cost[i]==Dis[y])tot|=(path1[i]=dfs1(y));
        }
        us[x]=1,In1[x]=tot;
        return tot;
    }
    bool In2[N];
    int path2[M],path3[M];
    bool dfs2(int x) {
        if(x==sy2)return true;
        if(us[x])return In2[x];
        bool tot=false;
        erep(i,G,x) {
            int y=G.to[i];
            if(Dis[x]+G.cost[i]==Dis[y])tot|=(path2[i]=path3[i^1]=dfs2(y));
        }
        us[x]=1,In2[x]=tot;
        return tot;
    }
    int In[N];
    void Topu1(void) {
        memset(Dis,0,sizeof Dis);
        queue<int>Q;
        rep(i,1,n)if(!In[i])Q.push((int)i);
        while(!Q.empty()) {
            int x=Q.front();
            Q.pop();
            erep(i,G,x) {
                int y=G.to[i];
                if(!path1[i]||!path2[i])continue;
                if(Dis[x]+G.cost[i]>Dis[y])Dis[y]=Dis[x]+G.cost[i];
                In[y]--;
                if(!In[y])Q.push(y);
            }
        }
        rep(i,1,n)Max(Ans,Dis[i]);
    }
    void Topu2(void) {
        memset(Dis,0,sizeof Dis);
        queue<int>Q;
        rep(i,1,n)if(!In[i])Q.push((int)i);
        while(!Q.empty()) {
            int x=Q.front();
            Q.pop();
            erep(i,G,x) {
                int y=G.to[i];
                if(!path1[i]||!path3[i])continue;
                if(Dis[x]+G.cost[i]>Dis[y])Dis[y]=Dis[x]+G.cost[i];
                In[y]--;
                if(!In[y])Q.push(y);
            }
        }
        rep(i,1,n)Max(Ans,Dis[i]);
    }
    inline void solve(void) {
        Ans=0;
        Dij(sx1),dfs1(sx1);
        memset(us,0,sizeof us);
        Dij(sx2),dfs2(sx2);
        rep(i,1,n) {
            erep(j,G,i) {
                int y=G.to[j];
                if(path1[j]&path2[j])In[y]++;
            }
        }
        Topu1();
        rep(i,1,n) {
            erep(j,G,i) {
                int y=G.to[j];
                if(path1[j]&path3[j])In[y]++;
            }
        }
        Topu2();
        printf("%d",Ans);
    }
} P100;
 
bool MOP2;
 
inline void _main(void) {
    n=Raed(),m=Read();
    sx1=Read(),sy1=Read();
    sx2=Read(),sy2=Read();
    G.Tot=1;
    rep(i,1,m) {
        int a=Read(),b=Read(),c=Raed();
        G.AddEdgepair(a,b,c);
    }
    P100.solve();
}
 
signed main() {
#define offline1
#ifdef offline
    freopen("path.in", "r", stdin);
    freopen("path.out", "w", stdout);
    _main();
    fclose(stdin);
    fclose(stdout);
#else
    _main();
#endif
    return 0;
}

转载于:https://www.cnblogs.com/dsjkafdsaf/p/11270289.html