CSU 1808 (最短路 把边当成点来跑 dijkstra)

 Bobo 居住在大城市 ICPCCamp。

ICPCCamp 有 n 个地铁站，用 1,2,…,n 编号。 m 段双向的地铁线路连接 n 个地铁站，其中第 i 段地铁属于 c _i 号线，位于站 a _i,b _i 之间，往返均需要花费 t _i 分钟（即从 a _i 到 b _i 需要 t _i 分钟，从 b _i 到 a _i 也需要 t _i 分钟）。

众所周知，换乘线路很麻烦。如果乘坐第 i 段地铁来到地铁站 s，又乘坐第 j 段地铁离开地铁站 s，那么需要额外花费 |c _i-c _j | 分钟。注意，换乘只能在地铁站内进行。

Bobo 想知道从地铁站 1 到地铁站 n 所需要花费的最小时间。

Input

输入包含不超过 20 组数据。

每组数据的第一行包含两个整数 n,m (2≤n≤10 ⁵,1≤m≤10 ⁵).

接下来 m 行的第 i 行包含四个整数 a _i,b _i,c _i,t _i (1≤a _i,b _i,c _i≤n,1≤t _i≤10 ⁹).

保证存在从地铁站 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

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN=1e5+10;
int a[MAXN],b[MAXN],c[MAXN],t[MAXN],head[MAXN*4];
int tot;
ll dis[MAXN*2];
int vis[MAXN*2];
struct Edge {
    int v,next;
    int t,c;
} edge[MAXN*4];
struct node {
    int id;
    int time;
    bool friend operator<(node a,node b) {
        return a.time>b.time;
    }
};
void add(int u,int v,int c,int t) {
    edge[tot].v=v;
    edge[tot].c=c;
    edge[tot].t=t;
    edge[tot].next=head[u];
    head[u]=tot++;
}
void init() {
    memset(head,-1,sizeof(head));
    tot=0;
}
ll dijkStra(int s,int t) {
    priority_queue<node>q;
    while(!q.empty())
        q.pop();
    node x;
    for(int i=0; i<tot; i++) {
        dis[i]=1e18+10;
        vis[i]=0;
    }
    for(int i=head[s]; ~i; i=edge[i].next) { //把边当成点,放入队列跑dijkstra.
        x=(node) {
            i,edge[i].t
        };
        dis[i]=edge[i].t;
        q.push(x);
    }
    ll ans=1e18;
    while(!q.empty()) {
        x=q.top();
        q.pop();
        int p=x.id;   //开始的点
        if(vis[p])
            continue;
        vis[p]=1;
        int u=edge[p].v;  //下一个点
        if(u==t)
            ans=min(ans,dis[p]);
        for(int i=head[u]; ~i; i=edge[i].next) {  //另外一条边
            if(!vis[i]&&dis[i]>dis[p]+edge[i].t+abs(edge[i].c-edge[p].c)) {
                dis[i]=dis[p]+edge[i].t+abs(edge[i].c-edge[p].c);
                q.push((node) {
                    i,dis[i]
                });
            }
        }
    }
    return ans;
}
int main() {
    int n,m;
    while(cin>>n>>m) {
        init();
        for(int i=1; i<=m; i++) {
            cin>>a[i]>>b[i]>>c[i]>>t[i];
            add(a[i],b[i],c[i],t[i]);
            add(b[i],a[i],c[i],t[i]);
        }
//        for(int j=1;j<=n;j++)
//        for(int i=head[j];i!=-1;i=edge[i].next){
//            int v=edge[i].v;
//            cout<<j<<"  "<<v<<"  "<<edge[i].c<<"   "<<edge[i].t<<endl;
//        }
        cout<<dijkStra(1,n)<<endl;
    }
    return 0;
}