CSU 1808 地铁（最短路变形）

http://acm.csu.edu.cn/csuoj/problemset/problem?pid=1808

题意：

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 所需要花费的最小时间。

 

思路：
因为一个点可能位于多条边中，然后边也是有属性的，这样的话，如果记录点的状态，当前可能是最优的，但是对于后面的点来说，由于还受边的影响，就不一定是最优的。

可以自己模拟一下下面这组数据：

 4 4
1 2 3 5
2 3 3 3
2 3 1 2
3 4 1 1

解决的办法有两种：一种是记录边的状态，另一种是拆点，一个点属于几条线段，就把它拆成几个点。

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<sstream>
#include<vector>
#include<stack>
#include<queue>
#include<cmath>
#include<map>
#include<set>
using namespace std;
typedef long long ll;
typedef pair<int,ll> pll;
const int INF = 0x3f3f3f3f;
const int maxn=2*1e5+5;
const int mod=1e9+7;

int n, m;
ll ans;

struct Edge
{
    ll from, to, c, dist;
    Edge(ll u, ll v, ll w, ll d) :from(u), to(v), c(w), dist(d){}
};

struct HeapNode
{
    ll id , val;
    HeapNode(ll x, ll y) :id(x), val(y){}
    bool operator < (const HeapNode& rhs) const{
        return val > rhs.val;
    }
};

struct Dijkstra
{
    int n, m;
    vector<Edge> edges;
    vector<int> G[maxn];
    bool done[maxn];
    ll d[maxn];

    void init(int n)
    {
        this->n = n;
        for (int i = 0; i < n; i++)    G[i].clear();
        edges.clear();
    }

    void AddEdges(int from, int to, int c, int dist)
    {
        edges.push_back(Edge(from,to,c,dist));
        m = edges.size();
        G[from].push_back((m - 1));
    }

    void dijkstra(int s)
    {
        priority_queue<HeapNode> Q;
        for (int i = 0; i<=m ; i++)    d[i] = 1e18;
        d[s] = 0;
        memset(done, 0, sizeof(done));
        for(int i=0;i<G[s].size();i++)
        {
            Edge& e=edges[G[s][i]];
            d[G[s][i]]=e.dist;
            Q.push(HeapNode(G[s][i],e.dist));
        }
        while (!Q.empty())
        {
            HeapNode x = Q.top(); Q.pop();
            int id = x.id;
            if (done[id]) continue;
            done[id] = true;
            int u=edges[id].to;
            if(u==n-1)  ans=min(ans,d[id]);

            for (int i = 0; i < G[u].size(); i++)
            {
                Edge& e = edges[G[u][i]];
                if (d[G[u][i]] > d[id] + e.dist + abs(e.c-edges[id].c))
                {
                    d[G[u][i]] = d[id] + e.dist + abs(e.c-edges[id].c);
                    Q.push(HeapNode(G[u][i],d[G[u][i]]));
                }
            }
        }
    }
}t;


int main()
{
    //freopen("in.txt","r",stdin);
    while(~scanf("%d%d",&n,&m))
    {
        t.init(n);
        for(int i=0;i<m;i++)
        {
            int a,b,c,d;
            scanf("%d%d%d%d",&a,&b,&c,&d);
            a--; b--;
            t.AddEdges(a,b,c,d);
            t.AddEdges(b,a,c,d);
        }
        ans=1e18;
        t.dijkstra(0);
        cout<<ans<<endl;
    }
    return 0;
}