BZOJ 4289: PA2012 Tax Dijkstra + 查分

Description

给出一个N个点M条边的无向图，经过一个点的代价是进入和离开这个点的两条边的边权的较大值，求从起点1到点N的最小代价。起点的代价是离开起点的边的边权，终点的代价是进入终点的边的边权

N<=100000

M<=200000

 

Input

Output

那个取最大值的操作十分烦人，考虑如何将这个判断去掉.
可以用查分的方式：如果进来的边是小的，那么从大的边出去就要补齐差值.
补齐差值就直接连一条差值为 $d$ 的边即可.
然后跑一个 $Dijkstra$ 即可.

#include <cstdio>  
#include <queue> 
#include <algorithm>
#include <cstring>
#include <map>         
#define N 400003 
#define inf 10000000000000 
#define ll long long 
#define setIO(s) freopen(s".in","r",stdin) 
using namespace std;               
namespace IO
{
    char *p1, *p2, buf[100000];
 
    #define nc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2) ? EOF : *p1 ++ )
 
    int rd() {
        int x = 0, f = 1;
        char c = nc();
        while (c < 48) {
            if (c == '-')
                f = -1;
            c = nc();
        }
        while (c > 47) {
            x = (((x << 2) + x) << 1) + (c ^ 48), c = nc();
        }
        return x * f;
    }
};           
struct Edge 
{ 
    int to,dis;      
    Edge(int to=0,int dis=0):to(to),dis(dis){} 
}; 
vector<Edge>G[N];       
bool cmp(Edge a,Edge b) 
{
    return a.dis<b.dis;    
}   
map<int,int>id[N]; 
int n,m,cnt,edges,s,t;  
int hd[N*6],nex[N*6],to[N*6],done[N*6];      
ll d[N*6],val[N*6]; 
inline void addedge(int u,int v,int c) 
{    
    nex[++edges]=hd[u],hd[u]=edges,to[edges]=v,val[edges]=1ll*c;   
}    
struct Node 
{
    ll dis;  
    int u;
    Node(ll dis=0,int u=0):dis(dis),u(u){}   
    bool operator<(Node b) const 
    {
        return dis>b.dis;        
    }
};    
priority_queue<Node>q; 
inline void Dijkstra() 
{
    int i; 
    for(i=0;i<=t;++i) d[i]=inf, done[i]=0;    
    d[s]=0, q.push(Node(0,s));                     
    while(!q.empty()) 
    {
        Node e=q.top();q.pop();   
        if(done[e.u]) continue;   
        done[e.u]=1;                 
        int u=e.u; 
        for(i=hd[u];i;i=nex[i]) 
        {
            int v=to[i]; 
            if(d[u]+val[i]<d[v]) 
            {
                d[v]=d[u]+val[i];   
                q.push(Node(d[v],v));   
            }
        }
    }    
}
int main() 
{
    int i,j; 
    // setIO("input");    
    n=IO::rd(),m=IO::rd(); 
    for(i=1;i<=m;++i) 
    {
        int a=IO::rd(),b=IO::rd(),c=IO::rd(); 
        G[a].push_back(Edge(b,c)), G[b].push_back(Edge(a,c));
    } 
    for(i=1;i<=n;++i) 
    {
        sort(G[i].begin(),G[i].end(),cmp); 
        if(G[i].empty()) continue;  
        id[i][G[i][0].dis]=++cnt;     
        for(j=1;j<(int)G[i].size();++j) if(G[i][j].dis!=G[i][j-1].dis) id[i][G[i][j].dis]=++cnt; 
    }  
    for(i=1;i<=n;++i) 
    {   
        int k,lst=0,pre=0; 
        for(k=0;k<(int)G[i].size();k=j+1) 
        {
            j=k;   
            int cur=id[i][G[i][j].dis];        
            while(j<(int)G[i].size()-1&&G[i][j+1].dis==G[i][j].dis) ++j;      
            if(lst) addedge(cur,lst,0), addedge(lst,cur,G[i][k].dis-pre);    
            for(int o=k;o<=j;++o) addedge(cur, id[G[i][o].to][G[i][o].dis], G[i][o].dis);         
            lst=cur, pre=G[i][k].dis;    
        }
    }
    s=0, t=cnt+2;   
    for(i=0;i<G[1].size();++i)  if(i==0||G[1][i].dis!=G[1][i-1].dis) addedge(s,id[1][G[1][i].dis],G[1][i].dis);   
    for(i=0;i<G[n].size();++i)  if(i==0||G[n][i].dis!=G[n][i-1].dis) addedge(id[n][G[n][i].dis],t,0);   
    Dijkstra(), printf("%lld\n",d[t]);   
    return 0; 
}