luogu 2483 K短路 (可持久化左偏树)

题面：

题目大意：给你一张有向图，求1到n的第k短路

$K$短路模板题

假设整个图的边集为$G$

首先建出以点$n$为根的，沿反向边跑的最短路树，设这些边构成了边集$T$

那么每个点沿着树边走到点$n$，它对于答案的贡献为0

我们加入一条非树边，它对于答案的贡献就是$delta(u,v)=dis[v]+e(u,v)-dis[u]$，即如果选择了这条边，这条路径的长度就会增加$delta(u,v)$

那么一条路径$p$的总长度就是$dis_{min}+\sum\limits_{e\in p,e\in G-T} delta(e)$

我们现在要求出前$K$条总长度最小的路径长度，(即使在这道题里我们不知道K是多少)

我们首先向一个堆中加入一条非树边，然后依次拓展，拓展的过程是这样的：

每次从堆中取出一条边集$p$，然后有两种情况

1.把末尾这条边替换成，这条边原来所在的边集里，边权大于等于它的一条边

2.新加入一条，末尾这条边的终点$v$，在最短路树里的一个祖先所能扩展的一条最短的非树边

这样扩展保证了每次新产生的边集贡献$\geq $原来的边集贡献，保证了有序性

且每次都选择最短的边集，保证了同一种边集不会重复讨论

第二个操作需要找出最小的后继状态，而后继状态可能很多，想办法用数据结构维护

在最短路树上每个点都维护反向非树边的集合，那么子节点也要包含父节点的集合，需要可持久化

而对于第一个操作，我们需要一个有序表来扩展，所以要用到堆之类的东西

可持久化可并堆！

无非就是$merge$里每次合并都新建节点罢了

第一个操作就是把最后一条边换成这条边在堆中的左右儿子

第二个操作直接取堆顶即可

这也是类似于普通$dijkstra$最短路的扩展过程

 #include <queue>
 #include <cmath>
 #include <vector>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define N1 5010
 #define M1 200010
 #define S1 N1<<8
 #define ll long long
 #define dd double
 using namespace std;
 const dd eps=1e-;
 
 template <typename _T> void read(_T &ret)
 {
     ret=; _T fh=; char c=getchar();
     while(c<''||c>''){ if(c=='-') fh=-; c=getchar(); }
     while(c>=''&&c<=''){ ret=ret*+c-''; c=getchar(); }
     ret=ret*fh;
 }
 
 int n,m;
 struct Edge{
 int to[M1<<],nxt[M1<<],val[M1<<],head[N1],cte; dd dis[M1<<];
 void ae(int u,int v,dd d)
 {
     cte++; to[cte]=v; nxt[cte]=head[u];
     head[u]=cte; dis[cte]=d;
 }
 }e; 
 
 struct node1{
 int x; dd d;
 node1(int x,dd d):x(x),d(d){} node1(){}
 friend bool operator < (const node1 &s1,const node1 &s2)
 {
     return s1.d>s2.d;
 }
 };
 
 struct Heap{
 int ch[S1][],h[S1],root0[N1],root1[N1],tot; node1 val[S1];
 int merge0(int x,int y)
 {
     if(!x||!y) return x+y;
     if(val[x]<val[y]) swap(x,y);
     ch[x][]=merge0(ch[x][],y);
     if(h[ch[x][]]<h[ch[x][]]) swap(ch[x][],ch[x][]);
     h[x]=h[ch[x][]]+;
     return x;
 }
 int merge1(int x,int y)
 {
     if(!x||!y) return x+y;
     if(val[x]<val[y]) swap(x,y);
     int nx=++tot; val[nx]=val[x]; ch[nx][]=ch[x][]; ch[nx][]=ch[x][]; h[nx]=h[x];
     ch[nx][]=merge1(ch[x][],y);
     if(h[ch[nx][]]<h[ch[nx][]]) swap(ch[nx][],ch[nx][]);
     h[nx]=h[ch[nx][]]+;
     return nx;
 }
 }h;
 
 priority_queue<node1>q;
 int use[N1]; dd dis[N1];
 void dijkstra()
 {
     node1 k; int x,j,v;
     q.push(node1(n,)); dis[n]=;
     for(j=;j<n;j++) dis[j]=;
     while(!q.empty())
     {
         k=q.top(); q.pop(); x=k.x;
         if(use[x]) continue; use[x]=;
         for(j=e.head[x];j;j=e.nxt[j])
         {
             v=e.to[j];
             if(dis[v]-eps>dis[x]+e.dis[j])
             {
                 dis[v]=dis[x]+e.dis[j];
                 q.push(node1(v,dis[v]));
             }
         }
     }
 }
 int fa[N1],de; dd la[N1];
 void dfs_tree(int x)
 {
     int j,v;
     if(fa[x]) h.root1[x]=h.merge1(h.root1[fa[x]],h.root0[x]);
     for(j=e.head[x];j;j=e.nxt[j])
     {
         v=e.to[j]; if(!e.val[j]) continue;
         dfs_tree(v);
     }
 }
 void build_tree()
 {
     int i,x,j,v;
     for(i=;i<=n;i++)
     {
         for(j=e.head[i];j;j=e.nxt[j])
         {
             v=e.to[j];
             if(!fa[v]&&fabs(dis[i]+e.dis[j]-dis[v])<eps)
                 e.val[j]^=, fa[v]=i;
         }
     }
     for(x=;x<=n;x++)
     {
         for(j=e.head[x];j;j=e.nxt[j])
         {
             v=e.to[j]; if(e.val[j]) continue;
             h.val[++h.tot]=node1(x,dis[x]+e.dis[j]-dis[v]);
             h.root0[v]=h.merge0(h.root0[v],h.tot);
         }
     }
 }
 dd E;
 struct node2{
 int x,v; dd d,D;
 node2(int x,int v,dd d,dd D):x(x),v(v),d(d),D(D){} node2(){}
 friend bool operator < (const node2 &s1,const node2 &s2)
 {
     return s1.D>s2.D;
 }
 };
 priority_queue<node2>que;
 
 void debug()
 {
     int x=;
     while(fa[x]) printf("%d ",fa[x]), x=fa[x];
     puts("");
 }
 
 int main()
 {
     //freopen("testdata.in","r",stdin);
     scanf("%d%d%lf",&n,&m,&E);
     int i,j,k,x,y,v,xx,vv,ans=; dd d,now,w;
     for(i=;i<=m;i++)
     {
         read(x), read(y), scanf("%lf",&d);
         e.ae(y,x,d);
     }
     dijkstra();
     build_tree();
     dfs_tree(n);
     node2 K;
     que.push(node2(,,,)); ans=;
     //debug();
     while(!que.empty())
     {
         K=que.top(); que.pop(); x=K.x; v=K.v; E-=K.D+dis[];
         //printf("%lf\n",K.D+dis[1]);
         if(E>-eps) ans++; else break;
         if(h.root1[v])
         {
             j=h.root1[v]; vv=h.val[j].x; w=h.val[j].d;
             que.push(node2(j,vv,w,K.D+w));
         }
         if(h.ch[x][])
         {
             j=h.ch[x][]; vv=h.val[j].x; w=h.val[j].d;
             que.push(node2(j,vv,w,K.D-K.d+w));
         }
         if(h.ch[x][])
         {
             j=h.ch[x][]; vv=h.val[j].x; w=h.val[j].d;
             que.push(node2(j,vv,w,K.D-K.d+w));
         }
     }
     printf("%d\n",ans);
     return ;
 }