P2149 [SDOI2009]Elaxia的路线

P2149 [SDOI2009]Elaxia的路线

提交 6.45k

通过 1.87k

时间限制 1.00s

内存限制 125.00MB

题目提供者 xmyzwls

难度 省选/NOI-

历史分数100

提交记录

查看题解

标签

各省省选山东高性能2009

 

查看算法标签

进入讨论版

相关讨论

 

查看讨论

推荐题目

 

查看推荐

 

展开

题目描述

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

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

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

输入格式

第一行两个正整数 n,mn,mn,m，表示点数和边数。

第二行四个正整数 x1,y1,x2,y2x_1,y_1,x_2,y_2x1​,y1​,x2​,y2​，分别表示 Elaxia 的宿舍和实验室及 w** 的宿舍和实验室的标号。

接下来 mmm 行，每行三个整数 u,v,wu,v,wu,v,w，表示 u,vu,vu,v之间有一条边，需要 www 的时间经过。

输出格式

一行一个整数表示答案。（即最长公共路径的长度）

输入输出样例

输入 #1

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

输出 #1

3

思路

　　这道题一开始拿到的思路是给最短路全打上标记，但是发现一个坑，这里交了只有10分，就是标记的方向问题。

　　后来想了想可以把标记问题转换一下。

　　假设 x1 -> y1 上存在一点对 (u, v) ，且 uv 间有路，若 dis[x1][u] + dis[u][v] + dis[v][y1] == dis[x1][y1] 则说明 uv 一定是一组被标记的带方向的最短路上一个点对。

　　我们跑四次dijkstra处理出 x1->y1, x2->y2, y1->x1, y2->x2的dis，之后枚举所有的边，找到所有的形似uv这样被标记的点对，通过四次拓扑排序建立DAG图，在DAG图上找最长链即可。

　　因为要跑多次拓扑和dijkstra，初始化是很重要的。

CODE

#include <bits/stdc++.h>
#define dbg(x) cout << #x << "=" << x << endl
#define eps 1e-8
#define pi acos(-1.0)

using namespace std;
typedef long long LL;

template<class T>inline void read(T &res)
{
    char c;T flag=1;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';
    while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
}

namespace _buff {
    const size_t BUFF = 1 << 19;
    char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
    char getc() {
        if (ib == ie) {
            ib = ibuf;
            ie = ibuf + fread(ibuf, 1, BUFF, stdin);
        }
        return ib == ie ? -1 : *ib++;
    }
}

int qread() {
    using namespace _buff;
    int ret = 0;
    bool pos = true;
    char c = getc();
    for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
        assert(~c);
    }
    if (c == '-') {
        pos = false;
        c = getc();
    }
    for (; c >= '0' && c <= '9'; c = getc()) {
        ret = (ret << 3) + (ret << 1) + (c ^ 48);
    }
    return pos ? ret : -ret;
}

const int maxn = 2e5 + 7;
const int inf  = 0x3f3f3f3f;

int head[maxn << 2], edge[maxn << 2], w[maxn << 2], nxt[maxn << 2];
int cnt;

inline void BuildGraph (int u, int v, int c) {
    cnt++;
    edge[cnt] = v;
    nxt[cnt]  = head[u];
    w[cnt] = c;
    head[u] = cnt;
}

struct node {
    int u,v;
    bool operator <(const node &t) const {
        return u > t.u;
    }
};

struct Node {
    int v, w;
};

int n,m,s,t;
int dis[10][maxn];
bool vis[maxn];
int minn = 0;

vector <Node> e[maxn];
queue<Node> que;

priority_queue < node > q;

void dijkstra(int s, int id) {
    memset(vis, 0, sizeof(vis));
    for(int i = 1; i <= n; i++) {
        dis[id][i] = 0x3f3f3f3f;
    }
    dis[id][s] = 0;
    q.push({0,s});
    while(!q.empty()) {
        node temp = q.top();
        q.pop();
        if(vis[temp.v]) continue;
        vis[temp.v] = true;
        for(int i = head[temp.v]; i; i = nxt[i]) {
            int v = edge[i];
            int c = w[i];
            if(dis[id][v] > dis[id][temp.v] + c) {
                dis[id][v] = dis[id][temp.v] + c;
                q.push({dis[id][v],v});
            }
        }
    }
}

int in[maxn];
int ddis[maxn];
int ans;

void topo(int s1, int s2, int s3, int s4, int x1, int y1, int x2, int y2) {
    for ( int i = 1; i <= n; ++i ) {
        e[i].clear();
    }
    memset(in, -1, sizeof(in));
    for ( int i = 1; i <= n; ++i ) {
        for (int j = head[i]; j; j = nxt[j]) {
            int u = i;
            int v = edge[j];
            int c = w[j];
            //printf("dis[%d][%d]:%d c:%d dis[%d][%d]:%d dis[%d][%d]:%d
",s1,u,dis[s1][u],c,s2,v,dis[s2][v],s1,y1,dis[s1][y1]);
            if(dis[s1][u] + c + dis[s2][v] == dis[s1][y1]) {
                if(dis[s3][u] + c + dis[s4][v] == dis[s3][y2]) {
                    if(in[u] == -1)
                        in[u]=0;
                    if(in[v] == -1)
                        in[v]=0;
                    in[v]++;
                    e[u].push_back({v,c});
                }
            }
        }
    }
    while(!que.empty()) {
        que.pop();
    }
    for ( int i = 1; i <= n; ++i ) {
        if(in[i] == 0) {
            Node temp;
            temp.v = i, temp.w = 0;
            que.push(temp);
        }
    }
    memset(ddis, 0, sizeof(ddis));
    while(!que.empty()) {
        Node temp;
        temp = que.front();
        que.pop();
        int u = temp.v;
        for ( int i = 0; i < e[u].size(); ++i ) {
            int v = e[u][i].v;
            int c = e[u][i].w;
            if(in[v] == -1) continue;
            ddis[v] = max(ddis[v], ddis[u] + c);
            //printf("ddis[%d]:%d
",v, ddis[v]);
            ans = max(ans, ddis[v]);
            in[v]--;
            if(in[v] == 0) {
                que.push(e[u][i]);
            }
        }
    }
}

int main()
{
    scanf("%d %d",&n, &m);
    int x1, y1, x2, y2;
    scanf("%d %d %d %d",&x1, &y1, &x2, &y2);
    
    int a, b, c;
    for (int i = 1; i <= m; ++i) {
        scanf("%d %d %d",&a, &b, &c);
        BuildGraph(a, b, c);
        BuildGraph(b, a, c);
    }
    dijkstra(x1, 1);
    dijkstra(y1, 2);
    dijkstra(x2, 3);
    dijkstra(y2, 4);
    ans = 0;
    topo(1,2,3,4,x1,y1,x2,y2);
    topo(1,2,4,3,x1,y1,y2,x2);
    topo(2,1,3,4,y1,x1,x2,y2);
    topo(2,1,4,3,y1,x1,y2,x2);
    cout << ans << endl;
    return 0;
}