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
",d[t]);
return 0;
}