數據結構&圖論：K短路-可持久化可並堆

本來A*就可以搞定的題，為了怕以后卡復雜度，找了個這么個方法

現階段水平不夠就不補充算法分析部分了

對於圖G，建立一個以終點t為起點的最短路徑構成的最短路徑樹
（就是反着跑一遍最短路，然后對於一個不為終點的點v，v到終點t的最短路徑上（任選一條）v的后繼結點為v的父親，就形成了一棵樹）
然后對於所有點，定義其不在最短路徑樹上的出邊的f值為：f[e] = l[e] + dis[e.tail] - dis[e.head] ，就是走這條邊，走到t需要多繞的距離
那么我們只要找到第k小的這種邊的序列就得到解了
那么我們維護按權值一個從小到大的優先隊列，每次從隊頭取出一個序列q，設q的最后一條邊e的head為u，tail為v
我們可以選擇在序列的末尾加上v到t的所有路徑上非樹邊的最小的得到一個新的序列q1
或者選擇u到t的所有路徑上所有非樹邊中e的后繼（沒用過的邊中最小的）替換e得到q2，將q1，q2都塞進優先隊列，重復k次，
可是怎么才能盡快知道一個節點v到t的所有路徑上的非樹邊最小的一個呢？
打個可持久化的可並堆就沒問題了，每個點合並他到根的路徑上所有非樹出邊，然后對於找e的后繼替換e的操作，直接找e的兩個孩子就行了

本題難度爆表，低級圖論和高級數據結構的大綜合

直接上代碼了，以后學的多了再回過頭來看方法

#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int maxn=8005;  //為啥開這么大？？？ 
const int maxm=100005;
const int INF=0x7fffffff;
int n,m,cnt,cntf,st,ed,k,tot,tp;
bool vi[maxn];
int g[maxn],gf[maxn],dis[maxn],_next[maxn],root[maxn],sta[maxn];
struct Edge
{
    int u,v,w,f,next;
    bool vis,flag;
}e[maxm];
struct Edgef
{
    int t,w,next;
}ef[maxm];

void addedge(int x,int y,int z)
{
    cnt++;
    e[cnt].u=x;e[cnt].v=y;e[cnt].w=z;
    e[cnt].next=g[x];g[x]=cnt;
    e[cnt].vis=0;
}
void addedgef(int x,int y,int z)
{
    cntf++;
    ef[cntf].t=y;ef[cntf].w=z;
    ef[cntf].next=gf[x];gf[x]=cntf;
}

struct Node
{
    int lc,rc,dis,c,y;
}tr[maxn*100];
int newnode(int c,int y)
{
    tot++;
    tr[tot].lc=tr[tot].rc=0;
    tr[tot].dis=0;
    tr[tot].c=c;
    tr[tot].y=y;
    return tot;
}
int merge(int x,int y)
{
    //cout<<x<<" "<<y<<endl;
    if(x==0||y==0) return x|y;
    if(tr[x].c>tr[y].c) swap(x,y);
    int ret=++tot;
    tr[ret]=tr[x];
    int k=merge(tr[ret].rc,y);
    if(tr[tr[ret].lc].dis<=tr[k].dis) swap(tr[ret].lc,k);
    tr[ret].rc=k;
    tr[ret].dis=tr[tr[ret].lc].dis+1;
    return ret;
}
struct HeapNode
{
    int x,d;
};
bool operator <(HeapNode x,HeapNode y)
{
    return x.d>y.d;
}
priority_queue<HeapNode> q;

struct Graph
{
    int u,x,d;
};
bool operator < (Graph x,Graph y)
{
    return x.d>y.d;
};
priority_queue<Graph> Q;
void getdis()
{
    dis[ed]=0;
    HeapNode temp;
    temp.x=ed;temp.d=0;
    q.push(temp);
    while(!q.empty())
    {
        HeapNode x=q.top();q.pop();
        if(dis[x.x]<x.d) continue;
        for(int tmp=gf[x.x];tmp;tmp=ef[tmp].next)
        {
            int y=ef[tmp].t;vi[y]=1;
            if(dis[y]>x.d+ef[tmp].w)
            {
                dis[y]=x.d+ef[tmp].w;
                temp.x=y;temp.d=dis[y];
                q.push(temp);
            }
        }
    }
}
void solve(int x)
{
    if(x==ed)
    {
        for(int tmp=g[x];tmp;tmp=e[tmp].next)
        {
            int y=e[tmp].v;
            if(e[tmp].flag==0) continue;
            if(e[tmp].vis==0)
            {
                root[x]=merge(root[x],newnode(e[tmp].f,e[tmp].v));
            }
        }
        return;
    }
    for(int tmp=g[x];tmp;tmp=e[tmp].next)
    {
        int y=e[tmp].v;
        if(e[tmp].flag==0) continue;
        if(e[tmp].vis==0)
            root[x]=merge(root[x],newnode(e[tmp].f,e[tmp].v));
        else root[x]=merge(root[x],root[y]);
    }
}
int main()
{
    int u,v,w;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&u,&v,&w);
        addedge(u,v,w);
        e[cnt].flag=1;
        addedgef(v,u,w);
    }
    scanf("%d%d%d",&st,&ed,&k);
    if(st==ed) k++;
    
    for(int i=1;i<=n;i++)
        dis[i]=INF,vi[i]=0;
    getdis();
    
    if(k==1)
    {
        if(vi[st]) printf("%d\n",dis[st]);
        else printf("-1\n");
        return 0;
    }
    for(int i=1;i<=cnt;i++)
    {
        e[i].f=e[i].w-dis[e[i].u]+dis[e[i].v];
        if(dis[e[i].v]==INF) e[i].flag=0;
    }
    for(int i=1;i<=n;i++)
    {
        if(i==ed) continue;
        for(int tmp=g[i];tmp;tmp=e[tmp].next)
        {
            v=e[tmp].v;
            if(!e[tmp].flag) continue;
            if(dis[i]==dis[v]+e[tmp].w)
            {
                e[tmp].vis=1;
                _next[i]=v;
                break;
            }
        }
    }
    memset(root,0,sizeof(root));
    tot=0;
    for(int i=1;i<=n;i++)
        if(!root[i])
        {
            if(dis[i]==INF) continue;
            sta[tp=1]=i;
            while(1)
            {
                u=sta[tp];
                if(u==ed) break;
                if(!root[_next[u]]) sta[++tp]=_next[u];
                else break;
            }
            while(tp)
            {
                solve(sta[tp]);
                tp--;
            }
        }
    k-=2;
    Graph ss;
    ss.u=st;ss.d=tr[root[st]].c;ss.x=root[st];
    Q.push(ss);
    while(k--)
    {
        Graph tmp=Q.top();Q.pop();
        if(tmp.u==0)
        {
            printf("-1\n");
            return 0;
        }
        if(tr[tmp.x].lc)
        {
            Graph tmp1;
            tmp1.u=tmp.u;
            tmp1.d=-tr[tmp.x].c;
            tmp1.x=merge(tr[tmp.x].lc,tr[tmp.x].rc);
            tmp1.d+=tr[tmp1.x].c+tmp.d;
            Q.push(tmp1);
        }
        Graph tmp2;
        tmp2.u=tr[tmp.x].y;
        tmp2.d=tmp.d+tr[root[tmp2.u]].c;
        tmp2.x=root[tmp2.u];
        Q.push(tmp2);
    }
    Graph ans=Q.top();
    if(ans.u==0)
    {
        printf("-1\n");
        return 0;
    }
    if(vi[st]) printf("%d\n",dis[st]+ans.d);
    else printf("-1\n");
    return 0;
}

200多行幸虧沒出什么調不出來的錯誤，唉，菜啊