CSU 1808 地鐵（拆點最短路）

1808: 地鐵

Time Limit: 5 Sec  Memory Limit: 128 MB
Submit: 728  Solved: 171
[Submit][Status][Web Board]

Description

 Bobo 居住在大城市 ICPCCamp。

ICPCCamp 有 n 個地鐵站，用 1,2,…,n 編號。 m 段雙向的地鐵線路連接 n 個地鐵站，其中第 i 段地鐵屬於 ci 號線，位於站 ai,bi 之間，往返均需要花費 ti 分鐘（即從 ai 到 bi 需要 ti 分鐘，從 bi 到 ai 也需要 ti 分鐘）。

衆所周知，換乘線路很麻煩。如果乘坐第 i 段地鐵來到地鐵站 s，又乘坐第 j 段地鐵離開地鐵站 s，那麼需要額外花費 |ci-cj | 分鐘。注意，換乘只能在地鐵站內進行。

Bobo 想知道從地鐵站 1 到地鐵站 n 所需要花費的最小時間。

Input

輸入包含不超過 20 組數據。

每組數據的第一行包含兩個整數 n,m (2≤n≤105,1≤m≤105).

接下來 m 行的第 i 行包含四個整數 ai,bi,ci,ti (1≤ai,bi,ci≤n,1≤ti≤109).

保證存在從地鐵站 1 到 n 的地鐵線路（不一定直達）。

Output

對於每組數據，輸出一個整數表示要求的值。

Sample Input

3 3
1 2 1 1
2 3 2 1
1 3 1 1
3 3
1 2 1 1
2 3 2 1
1 3 1 10
3 2
1 2 1 1
2 3 1 1

Sample Output

1
3
2

HINT

思路：一開始沒思路，看了別人寫的拆點才恍然大悟可以這麼做。 於是乎自己寫了一下，發現TLE？？？

嘛，把spfa改成dijsktra就A了  我也不知道爲什麼，我一直覺得spfa不管怎樣都會比dijsktra快

解法的話就是跟我們現實生活中一樣，一個地鐵站口會有多條線路，那麼就把地鐵站拆成多個對應不同線路的地鐵站口，然後連邊

最後把同一個地鐵站口不同線路的點再連線路差的絕對值就好

代碼：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <map>
#include <vector>
#include <queue>
using namespace std;
#define N 250005
#define INF 0x3f3f3f3f
struct Edge
{
    int v,cost,next;
} edge[N*2];
int cnt,head[N];
int vis[N];
long long d[N],ans;
map<int,int>ma[N];///ma[i][j]表示在第i號地鐵站的第j線路的編號
vector<int>nex[N];///nex[i][j]表示以i爲起點的第j條地鐵
void init()
{
    cnt=0;
    memset(head,-1,sizeof(head));
}
void addedge(int u,int v,int cost)
{
    edge[cnt].v=v,edge[cnt].cost=cost;
    edge[cnt].next=head[u],head[u]=cnt++;
}
struct node{
    int now;
    int c;
    node(int  _now = 0,int _c=0):now(_now),c(_c){}
    bool operator <(const node &r)const
    {
        return c>r.c;
    }
};
void dijkstra(int n){
    priority_queue<node> que;
    while(!que.empty()) que.pop();
    for(int i=1;i<=n;++i) d[i]=INF;
    for(int i=0;i<nex[1].size();++i){
        int st;
        st = ma[1][nex[1][i]];
        d[st]=0;
        que.push(node(st,0));
    }
    node temp;
    while(!que.empty()){
        temp = que.top();
        que.pop();
        int u = temp.now;
        int cost = temp.c;

        for(int i=head[u];i!=-1;i=edge[i].next){
            int v = edge[i].v;
            int w = edge[i].cost;
            if(d[v]>cost+w){
                d[v]= cost + w;
                que.push(node(v,d[v]));
            }
        }
    }
}
void spfa(int n)
{
    memset(vis,0,sizeof(vis));
    for(int i=1; i<=n; i++)
        d[i]=INF;
    queue<int>que;
    for(int i=0; i<nex[1].size(); i++)
    {
        int id=ma[1][nex[1][i]];
        vis[id]=1;
        d[id]=0;
        que.push(id);
    }
    while(!que.empty())
    {
        int now=que.front();
        que.pop();
        vis[now]=0;
        for(int i=head[now]; i!=-1; i=edge[i].next)
        {
            int v=edge[i].v;
            if(d[now]+edge[i].cost>=d[v]) continue;
            d[v]=d[now]+edge[i].cost;
            if(!vis[v])
            {
                vis[v]=1;
                que.push(v);
            }
        }
    }
}
int main()
{
    int n,m;
    int a,b,c,t;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        init();
        int num=0;
        for(int i=1; i<=n; i++)
        {
            ma[i].clear();
            nex[i].clear();
        }
        for(int i=1; i<=m; i++)
        {
            scanf("%d %d %d %d",&a,&b,&c,&t);
            if(!ma[a][c])
            {
                ma[a][c]=++num;
                nex[a].push_back(c);
            }
            int u=ma[a][c];

            if(!ma[b][c])
            {
                ma[b][c]=++num;
                nex[b].push_back(c);
            }
            int v=ma[b][c];

            addedge(u,v,t);
            addedge(v,u,t);
        }
        for(int i=1; i<=n; i++)
        {
            sort(nex[i].begin(),nex[i].end());
            for(int j=0; j<nex[i].size()-1; j++)
            {
                int id=nex[i][j],id1=nex[i][j+1];
                int u=ma[i][id];
                int v=ma[i][id1];
                int cost=id1-id;
                addedge(u,v,cost);
                addedge(v,u,cost);
            }
        }
        ans=-1;
        dijkstra(num);
        for(int i=0; i<nex[n].size(); i++)
        {
            if(ans==-1||ans>d[ma[n][nex[n][i]]])
                ans=d[ma[n][nex[n][i]]];
        }
        printf("%lld\n",ans);
    }
    return 0;
}