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 = , int next = , int w = ):end(end), next(next), w(w) {        }
 }Edge;
 
 typedef class MapManager {
     public:
         int ce;
         int *h;
         Edge *es;
 
         MapManager() {        }
         MapManager(int n, int m):ce(-) {
             h = new int[(n + )];
             es = new Edge[(m + )];
             memset(h, -, sizeof(int) * (n + ));
         }
 
         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 + )];
     dg = new vector<int>[(n + )];
     for (int i = ; i < m; i++) {
         scanf("%d%d%d", &es[i].end, &es[i].next, &es[i].w);
         dg[es[i].end].push_back(i << );
         dg[es[i].next].push_back(i <<  | );
     }
 }
 
 boolean cmp(const int& a, const int& b) {
     return es[a >> ].w < es[b >> ].w;
 }
 
 int s, t;
 
 inline void build() {
     g = MapManager((m << ) + , m << );
     s = m << , t = m <<  | ;
     for (int i = ; i <= n; i++) {
         sort(dg[i].begin(), dg[i].end(), cmp);
         for (int j = ; j < (signed) dg[i].size(); j++) {
             int u = (j) ? (dg[i][j - ]) : (-), v = dg[i][j];
             g.addEdge(v, u, );
             g.addEdge(u, v, es[v >> ].w - es[u >> ].w);
         }
     }
 
     for (int i = ; i < (signed) dg[].size(); i++)
         g.addEdge(s, dg[][i], es[dg[][i] >> ].w);
     for (int i = ; i < (signed) dg[n].size(); i++)
         g.addEdge(dg[n][i] ^ , t, es[dg[n][i] >> ].w);
 
     for (int i = , w; i < m; i++) {
         w = es[i].w;
         g.addEdge(i << , i <<  | , w);
         g.addEdge(i <<  | , i << , w);
     }
 }
 
 typedef class Node {
     public:
         int p;
         ll dis;
 
         Node(int p = , ll dis = ):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 << ) + ];
     memset(f, 0x3f, sizeof(ll) * ((m << ) + ));
     que.push(Node(s, f[s] = ));
     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 ;
 }