CSU 2157-地铁(以边来记录最短路)

A: 地铁

Submit Page    Time Limit: 5 Sec     Memory Limit: 128 Mb     Submitted: 106     Solved: 21    

---

Description

 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

Hint

解题思路：这道题乍一看就感觉是最短路，然而每条路上都有另一个与上一条边相关的权值，所以我们就考虑以边来记录最短路径，如果你用点来记录的话不一定是记录的最小值，因为走下一个点的最短路还与上一条边有关。

其实以点来记录最短路的题目也是可以用以边来记录的做的，但是同理，如果点上还有权值的话就要用点来记录了。

AC代码：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<string.h>
#include<string>
#include<math.h>
#include<stdlib.h>
#include<queue>
#include<map>
#include<set>
#include<stack>
#define bug printf("*********\n");
#define mem0(a) memset(a, 0, sizeof(a));
#define mem1(a) memset(a, -1, sizeof(a));
#define finf(a, n) fill(a, a+n, INF);
#define in1(a) scanf("%d" ,&a);
#define in2(a, b) scanf("%d%d", &a, &b);
#define in3(a, b, c) scanf("%d%d%d", &a, &b, &c);
#define out1(a) printf("%d\n", a);
#define out2(a, b) printf("%d %d\n", a, b);
#define pb(G, a, b) G[a].push_back(b);
using namespace std;
typedef long long LL;
typedef pair<LL, pair<int, LL> > LLppar;
typedef pair<int, int> par;
typedef pair<LL, int> LLpar;
const int mod = 998244353;
const int INF = 1e9+7;
const int N = 1010;
const double pi = 3.1415926;

int n, m, cnt;
int head[100010];
LL dis[100010*2]; //注意开long long

struct edge
{
    int to;
    LL cost;
    LL time;
    int next;
}e[100010*2];

void add(int u, int v, LL w, LL t)
{
    e[cnt].to = v;
    e[cnt].cost = w;
    e[cnt].time = t;
    e[cnt].next = head[u];
    head[u] = cnt ++;
}

LL dijstra()
{
    fill(dis, dis+2*m+1, 1e16);
    priority_queue<pair<LL, int> > q;
    for(int i = head[1]; i != -1;  i= e[i].next) { //初始化起点所连的边
        int en = e[i].to;
        q.push(make_pair(-e[i].cost, i));
        dis[i] = e[i].cost;
    }
    while(!q.empty()) {
        LLpar cur = q.top();
        q.pop();
        LL a = - cur.first;
        int b = e[cur.second].to;
        if(b == n) return dis[cur.second]; //最先走到终点的路
        for(int i = head[b]; i != -1; i = e[i].next) {
            int en = e[i].to;
            LL len = a + e[i].cost + abs(e[i].time - e[cur.second].time);
            if(dis[i] > len) {
                dis[i] = len;
                q.push(make_pair(-len, i));
            }
        }
    }
}

int main()
{
    int a, b;
    LL c, t;
    while(~scanf("%d%d", &n, &m)) {
        cnt = 0;
        mem1(head);
        for(int i = 0; i < m; i ++) {
            scanf("%d%d%lld%lld", &a, &b, &c, &t);
            add(a, b, t, c);
            add(b, a, t, c);
        }
        printf("%lld\n", dijstra());
    }
    return 0;
}