bzoj 4289 Tax - 最短路

题目传送门

　　这是一条通往vjudge的神秘通道

　　这是一条通往bzoj的神秘通道

题目大意

　　如果一条路径走过的边依次为$e_{1}, e_{2}, \cdots , e_{k}$，那么它的长度为$e_{1} + \max (e_{1}, e_{2}) + \max (e_{2}, e_{3}) + \cdots + \max (e_{k - 1}, e_{k}) + e_{k}$，问点$1$到点$n$的最短路。

　　显然需要把状态记在最后一条边上。

　　然后给一个菊花图，这个做法就gg了。

　　因此考虑一些黑科技。

　　可以把边看成点，然后考虑如何在辺与边之间快速连边。

　　对于一个点的出边，可以把它们按照权值排序，大的向比它略小的连一条权值为0的边，小的向比它略大的连一天权值为它们边权之差的边。

　　然后原图中每条边向它的反向边连一条边权相同的边。

　　然后再建两个虚点，一个起点，向以1为起点的边连边，边权不变。一个终点，以$n$为终点的边向它连边。

Code

/**
 * bzoj
 * Problem#4289
 * Accepted
 * Time: 3200ms
 * Memory: 31292k
 */
#include <bits/stdc++.h>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;

#define ll long long

typedef class Edge {
    public:
        int end, next, w;
        
        Edge(int end = 9, int next = 0, int w = 0):end(end), next(next), w(w) {        }
}Edge;

typedef class MapManager {
    public:
        int ce;
        int *h;
        Edge *es;
        
        MapManager() {        }
        MapManager(int n, int m):ce(-1) {
            h = new int[(n + 1)];
            es = new Edge[(m + 5)];
            memset(h, -1, sizeof(int) * (n + 1));
        }
        
        void addEdge(int u, int v, int w) {
            es[++ce] = Edge(v, h[u], w);
            h[u] = ce;
//            cerr << u << "->" << v << " " << w << endl;
        }
        
        Edge& operator [] (int pos) const {
            return es[pos];
        }
}MapManager;

int n, m;
Edge *es;
vector<int> *dg;
MapManager g;

inline void init() {
    scanf("%d%d", &n, &m);
    es = new Edge[(m + 1)];
    dg = new vector<int>[(n + 1)];
    for (int i = 0; i < m; i++) {
        scanf("%d%d%d", &es[i].end, &es[i].next, &es[i].w);
        dg[es[i].end].push_back(i << 1);
        dg[es[i].next].push_back(i << 1 | 1);
    }
}

boolean cmp(const int& a, const int& b) {
    return es[a >> 1].w < es[b >> 1].w;
}

int s, t;

inline void build() {
    g = MapManager((m << 1) + 2, m << 3);
    s = m << 1, t = m << 1 | 1;
    for (int i = 1; i <= n; i++) {
        sort(dg[i].begin(), dg[i].end(), cmp);
        for (int j = 1; j < (signed) dg[i].size(); j++) {
            int u = (j) ? (dg[i][j - 1]) : (-1), v = dg[i][j];
            g.addEdge(v, u, 0);
            g.addEdge(u, v, es[v >> 1].w - es[u >> 1].w);
        }
    }
    
    for (int i = 0; i < (signed) dg[1].size(); i++)
        g.addEdge(s, dg[1][i], es[dg[1][i] >> 1].w);
    for (int i = 0; i < (signed) dg[n].size(); i++)
        g.addEdge(dg[n][i] ^ 1, t, es[dg[n][i] >> 1].w);
    
    for (int i = 0, w; i < m; i++) {
        w = es[i].w;
        g.addEdge(i << 1, i << 1 | 1, w);
        g.addEdge(i << 1 | 1, i << 1, w);
    }
}

typedef class Node {
    public:
        int p;
        ll dis;
        
        Node(int p = 0, ll dis = 0):p(p), dis(dis) {            }
        
        boolean operator < (Node b) const {
            return dis > b.dis;
        }
}Node;

ll *f;
priority_queue<Node> que;
inline ll dijstra() {
    f = new ll[(m << 1) + 2];
    memset(f, 0x3f, sizeof(ll) * ((m << 1) + 2));
    que.push(Node(s, f[s] = 0));
    while (!que.empty()) {
        Node e = que.top();
        que.pop();
        if (e.dis != f[e.p])    continue;
        for (int i = g.h[e.p]; ~i; i = g[i].next) {
            Node eu (g[i].end, e.dis + g[i].w);
            if (eu.dis < f[eu.p]) {
                f[eu.p] = eu.dis;
                que.push(eu);
            }
        }
    }
    return f[t];
}

inline void solve() {
    printf(Auto"\n", dijstra());
}

int main() {
    init();
    build();
    solve();
    return 0;
}