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}+sumlimits_{ein p,ein 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-7;

template <typename _T> void read(_T &ret)
{
    ret=0; _T fh=1; char c=getchar();
    while(c<'0'||c>'9'){ if(c=='-') fh=-1; c=getchar(); }
    while(c>='0'&&c<='9'){ ret=ret*10+c-'0'; c=getchar(); }
    ret=ret*fh;
}

int n,m;
struct Edge{
int to[M1<<1],nxt[M1<<1],val[M1<<1],head[N1],cte; dd dis[M1<<1];
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][2],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][1]=merge0(ch[x][1],y);
    if(h[ch[x][0]]<h[ch[x][1]]) swap(ch[x][0],ch[x][1]);
    h[x]=h[ch[x][1]]+1;
    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][0]=ch[x][0]; ch[nx][1]=ch[x][1]; h[nx]=h[x];
    ch[nx][1]=merge1(ch[x][1],y);
    if(h[ch[nx][0]]<h[ch[nx][1]]) swap(ch[nx][0],ch[nx][1]);
    h[nx]=h[ch[nx][1]]+1;
    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,0)); dis[n]=0;
    for(j=1;j<n;j++) dis[j]=666666666;
    while(!q.empty())
    {
        k=q.top(); q.pop(); x=k.x; 
        if(use[x]) continue; use[x]=1;
        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=1;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]^=1, fa[v]=i;
        }
    }
    for(x=1;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=1; 
    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=0; dd d,now,w; 
    for(i=1;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(0,1,0,0)); ans=0;
    //debug();
    while(!que.empty())
    {
        K=que.top(); que.pop(); x=K.x; v=K.v; E-=K.D+dis[1]; 
        //printf("%lf
",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][0])
        {
            j=h.ch[x][0]; 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][1])
        {
            j=h.ch[x][1]; vv=h.val[j].x; w=h.val[j].d;
            que.push(node2(j,vv,w,K.D-K.d+w));
        }
    }
    printf("%d
",ans);
    return 0;
}