[BZOJ4289]PA2012 Tax 差分建图+最短路

这是一个不寻常的最短路，走一步的代价是两条边权值的最大值，听起来就很难维护。
重新建图，把点建到边上，这样走一步就相当于两个点权值的最大值，是可以用普通的最短路算法做的，点数是$O(m)$，但是边数最坏会达到$O(m^2)$
解决方法是继续改造这个图，可以使用线段树建图，不过直接差分建图也会很方便。
将无向边拆成两条有向边，把边变成点后这两条边连一条长度为0的路径，对于原图来自同一个出发点的边集(u,v1)，(u,v2)……(u,vi)，按照边权从小到大排序，对于相邻的(u,vi,wi)，(u,vj,wj)，在新建图上i,j连权值为wj-wi的边，j,i连接权值为0的边，新图进行最短路即可

/**************************************************************
    Problem: 4289
    User: di4CoveRy
    Language: C++
    Result: Accepted
    Time:4680 ms
    Memory:102448 kb
****************************************************************/

#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>

#define INF (1LL<<62)

#define N 200050
#define M 5*400050

using namespace std;
typedef long long LL;
vector<int> E[N];
int a[M],b[M],v[M],n,m,S,T,cnt;
bool vis[N],flag[M];
LL dis[M];
struct Node{ int u; LL dis; };

bool operator<(Node p1,Node p2) {
    return p1.dis == p2.dis ? p1.u < p2.u : p1.dis > p2.dis;
}
bool operator==(Node p1,Node p2) {
    return p1.u == p2.u && p1.dis == p2.dis;
}
struct Heap{
    priority_queue<Node> A,B;
    void push(Node p) { A.push(p); }
    void pop(Node p) { B.push(p); }
    Node top() {
        while (!B.empty() && A.top() == B.top()) A.pop() , B.pop();
        return A.top();
    }
}heap;

struct Edge{ int a,b,v,next; }e[M];
int h[M],zeus;
void add_Edge(int a,int b,int v) {
    e[++zeus] = (Edge){a,b,v,h[a]}; h[a] = zeus;
}

void add(int A,int B,int V) {
    a[++cnt] = A , b[cnt] = B , v[cnt] = V;
    E[A].push_back(cnt);
}
void g() {
    heap.push( (Node){1,0} );

    for (int _=2;_<=cnt;_++) heap.push((Node){_,INF});
    for (int _=2;_<=cnt;_++) dis[_] = INF;

    for (;;) {
        Node u = heap.top(); heap.pop(u);
        if (u.u == T) break;
        flag[u.u] = 1;
        int x = b[u.u];
        for (int i=h[u.u];i;i=e[i].next) {
            int v = e[i].b , cp = e[i].v;
//          if (flag[v]) continue;
            if (dis[v] > dis[u.u] + cp) {
                heap.pop( (Node){v , dis[v]} );
                dis[v] = dis[u.u] + cp;
                heap.push( (Node){v , dis[v]} );
            }
        }
    }
    return ;
}

bool cmp(int p1,int p2) { return v[p1] < v[p2]; }

int main() {
    #ifndef ONLINE_JUDGE
        freopen("1.in","r",stdin);
    #endif
    scanf("%d%d",&n,&m);
    add(1,1,0); add(1,1,0);
    for (int i=1;i<=m;i++) {
        int a,b,v;
        scanf("%d%d%d",&a,&b,&v);
        add(a,b,v); add(b,a,v);
    }
    add(n,n,0); add(n,n,0);

    for (int _=1;_<=cnt;_+=2) 
        add_Edge(_,_+1,v[_]) , add_Edge(_+1,_,v[_]);

    for (int _=1;_<=n;_++) {
        sort(E[_].begin(),E[_].end(),cmp);
        for (int i=1;i<(int)E[_].size();i++) {
            int p1 = E[_][i-1] , p2 = E[_][i];
            add_Edge(p1,p2,v[p2]-v[p1]);
            add_Edge(p2,p1,0);
        }
    }

//  for (int i=1;i<=zeus;i++) printf("%d %d %d\n",e[i].a,e[i].b,e[i].v);

    S = 2 , T = cnt-1;
    g();
//  for (int i=1;i<=cnt;i++) printf("%d ",dis[i]); printf("\n");
    cout << dis[T] << endl;
    return 0;
}