1808: 地铁

1808: 地铁

Time Limit: 5 Sec  Memory Limit: 128 MB
Submit: 693  Solved: 161
[Submit][Status][Web Board]

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
思路：最短路；
这里不能够按照点来求最短路，而是按照边来求，因为有了额外花费这个条件，某一点可能经由不同的边到达，该点的最小值不仅可能由上一最小值点更新，也可能由一个大一些的点更新过来，加上额外花费之后变成了最小值点，所以不能以点建图，而应该以边建图
但每条边两端点出所要增加的价值是个定值，所以可以用最短路来求到每条边的最小值。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<queue>
#include<math.h>
#include<stack>
#include<vector>
using namespace std;
typedef long long LL;
LL d[100005];
typedef struct node
{
        int from;
        int to;
        LL cost;
        int id;
        LL p;
        bool operator <(const node&cx)const
        {
                return cx.cost < cost;
        }
} ss;
vector<ss>vec[100005];
LL t[100005];
void dj(int s);
int main(void)
{
        int n,m;
        while(scanf("%d %d",&n,&m)!=EOF)
        {
                int i,j;
                for(i = 0; i < 100005; i++)
                        vec[i].clear();
                for(i = 1; i <= m; i++)
                {
                        int a,b,c;
                        scanf("%d %d %lld %d",&a,&b,&t[i],&c);
                        ss ab;
                        ab.from = a;
                        ab.to = b;
                        ab.cost = c;
                        ab.id = i;
                        ab.p = t[i];
                        vec[a].push_back(ab);
                        ab.to = a;
                        ab.from = b;
                        vec[b].push_back(ab);
                }
                if(n == 1)printf("0
");
                else
                {
                        LL maxx = 1e16;
                        dj(1);
                        for(i = 0; i < vec[n].size(); i++)
                        {
                                maxx = min(maxx,d[vec[n][i].id]);
                        }
                        printf("%lld
",maxx);
                }
        }
        return 0;
}
void dj(int s)
{
        LL sum = 0;
        fill(d,d+100005,1e16);
        priority_queue<ss>que;
        int i,j;
        for(i = 0; i < vec[s].size(); i++)
        {
                ss ak = vec[s][i];
                ss ac;
                ac.cost = ak.cost;
                ac.from = s;
                ac.to = ak.to;
                ac.id = ak.id;
                ac.p = ak.p;
                que.push(ac);
                d[ac.id] = ak.cost;
        }
        while(!que.empty())
        {
                ss ak = que.top();
                que.pop();
                if(d[ak.id] < ak.cost)continue;
                for(i = 0; i  < vec[ak.to].size(); i++)
                {
                        ss ac = vec[ak.to][i];
                        //printf("%lld %lld %lld
",ac.p,ak.p,ak.id);
                        if(d[ac.id] > d[ak.id] + ac.cost + abs(ac.p-ak.p))
                        {
                                d [ac.id]= d[ak.id] + ac.cost + abs(ac.p-ak.p);
                                ss av;
                                av.from = ac.from;
                                av.to  = ac.to;
                                av.cost = d[ac.id];
                                av.p = ac.p;
                                av.id = ac.id;
                                que.push(av);
                        }
                }
        }
}