SGU 314 Shortest Paths

题目链接：http://acm.sgu.ru/problem.php?contest=0&problem=314

题意：给出n个点m条边的有向图。输出从s到t的前K短路。

思路：首先，从t开始遍历一次得到每个点到t的最短路dis[i]，且得到一棵最短路树，即边<u,v,d>满足dis[u]=dis[v]+d。那么，从任意一个节点到t的最短路都对应最短路树上的一条路径。对于不在最短路树上的边e<u,v,d>，如果我们走了这条边，则长度要增加det(e)=d+dis[v]-dis[u]。那么，我们可以计算出所有不在最短路树上的边的det值。那么除最短路外的每一条路径都是走了若干条不在最短路树上的边，也就是dis[s]加了几个det。那么问题转化成每次选出一些det值，使得这些值的和依次递增。当然这些选出的det不能乱选，他们要在一条路径上。接下来，为每个点u建立一个小根堆H1(u)，H1(u)堆中的每个点是从u出发的非树边的det值。接着，对于树边<u,v>，我们要将H1(v)接在H1(u)下面得到H2(u)，且H2(u)还是一个小根堆 。设H2(u)的根节点为head[u]，最后从head[s]开始得到前K个解。

#include <iostream>

#include <cstdio>

#include <string.h>

#include <algorithm>

#include <cmath>

#include <vector>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <map>





#define max(x,y) ((x)>(y)?(x):(y))

#define min(x,y) ((x)<(y)?(x):(y))

#define abs(x) ((x)>=0?(x):-(x))

#define i64 long long

#define u32 unsigned int

#define u64 unsigned long long

#define clr(x,y) memset(x,y,sizeof(x))

#define CLR(x) x.clear()

#define ph(x) push(x)

#define pb(x) push_back(x)

#define Len(x) x.length()

#define SZ(x) x.size()

#define PI acos(-1.0)

#define sqr(x) ((x)*(x))

#define MP(x,y) make_pair(x,y)



#define FOR0(i,x) for(i=0;i<x;i++)

#define FOR1(i,x) for(i=1;i<=x;i++)

#define FOR(i,a,b) for(i=a;i<=b;i++)

#define DOW0(i,x) for(i=x;i>=0;i--)

#define DOW1(i,x) for(i=x;i>=1;i--)

#define DOW(i,a,b) for(i=a;i>=b;i--)

using namespace std;





void RD(int &x){scanf("%d",&x);}

void RD(i64 &x){scanf("%I64d",&x);}

void RD(u32 &x){scanf("%u",&x);}

void RD(double &x){scanf("%lf",&x);}

void RD(int &x,int &y){scanf("%d%d",&x,&y);}

void RD(i64 &x,i64 &y){scanf("%I64d%I64d",&x,&y);}

void RD(u32 &x,u32 &y){scanf("%u%u",&x,&y);}

void RD(double &x,double &y){scanf("%lf%lf",&x,&y);}

void RD(int &x,int &y,int &z){scanf("%d%d%d",&x,&y,&z);}

void RD(i64 &x,i64 &y,i64 &z){scanf("%I64d%I64d%I64d",&x,&y,&z);}

void RD(u32 &x,u32 &y,u32 &z){scanf("%u%u%u",&x,&y,&z);}

void RD(double &x,double &y,double &z){scanf("%lf%lf%lf",&x,&y,&z);}

void RD(char &x){x=getchar();}

void RD(char *s){scanf("%s",s);}

void RD(string &s){cin>>s;}





void PR(int x) {printf("%d\n",x);}

void PR(i64 x) {printf("%I64d\n",x);}

void PR(u32 x) {printf("%u\n",x);}

void PR(double x) {printf("%.6lf\n",x);}

void PR(char x) {printf("%c\n",x);}

void PR(char *x) {printf("%s\n",x);}

void PR(string x) {cout<<x<<endl;}



const int INF=1000000000;

const int N=10005;

const int M=50005;



struct node

{

    int u,v,dis;

};



struct Heap

{

    node* edge;

    int dep;

    Heap* child[4];

};



int n,m,K,s,t,dis[N];

node *Next[N];

vector<node*> g[N],g1[N];

Heap* nullNode;

Heap* head[N];



void Add(int u,int v,int dis)

{

    node* E=new node;

    E->u=u;

    E->v=v;

    E->dis=dis;

    g[u].pb(E); g1[v].pb(E);

}



void input()

{

    RD(n,m,K);

    RD(s,t);

    int u,v,dis;

    while(m--)

    {

        RD(u,v,dis);

        Add(u,v,dis);

    }

}



queue<int> dfsQ;



struct NODE

{

    int v;

    i64 dis;

    Heap* H;

    node* E;



    NODE(){}

    NODE(i64 _dis,int _v,node* _E)

    {

        v=_v;

        dis=_dis;

        E=_E;

    }



    NODE(Heap* _H,i64 _dis)

    {

        H=_H;

        dis=_dis;

    }



    friend bool operator<(NODE a,NODE b)

    {

        return a.dis>b.dis;

    }

};





void dijkstra()

{

    clr(dis,-1);

    priority_queue<NODE> Q;

    Q.push(NODE(0,t,(node*)NULL));

	NODE p;

	vector<node*>::iterator it;

	while (!Q.empty())

	{

	    p=Q.top();

	    Q.pop();

		if(dis[p.v]!=-1) continue;

		dis[p.v]=p.dis;

		Next[p.v]=p.E;

		dfsQ.push(p.v);

		for(it=g1[p.v].begin();it!=g1[p.v].end();it++)

		{

		    Q.push(NODE(p.dis+(*it)->dis,(*it)->u,*it));

		}

	}

}



int cmp(Heap* a,Heap* b)

{

    return a->edge->dis>b->edge->dis;

}



Heap* creat(Heap* curNode,Heap* newNode)

{

    if(curNode==nullNode) return newNode;

    Heap* root=new Heap;

    memcpy(root,curNode,sizeof(Heap));

    if(newNode->edge->dis<curNode->edge->dis)

    {

        root->edge=newNode->edge;

        root->child[2]=newNode->child[2];

        root->child[3]=newNode->child[3];



        newNode->edge=curNode->edge;

        newNode->child[2]=curNode->child[2];

        newNode->child[3]=curNode->child[3];

    }

    if(root->child[0]->dep<root->child[1]->dep)

    {

        root->child[0]=creat(root->child[0],newNode);

    }

    else

    {

        root->child[1]=creat(root->child[1],newNode);

    }

    root->dep=max(root->child[0]->dep,root->child[1]->dep)+1;

    return root;

}





void build()

{

    nullNode=new Heap;

    nullNode->dep=0;

    nullNode->edge=new node;

    nullNode->edge->dis=INF;

    fill(nullNode->child,nullNode->child+4,nullNode);



    vector<Heap*> V;

    Heap* p;

    vector<node*>::iterator it;

    int u,v,i;

    while(!dfsQ.empty())

    {

        u=dfsQ.front();

        dfsQ.pop();



        if(Next[u]==NULL) head[u]=nullNode;

        else head[u]=head[Next[u]->v];



        V.clear();

        for(it=g[u].begin();it!=g[u].end();it++)

        {

           v=(*it)->v;

           if(dis[v]==-1) continue;

           (*it)->dis+=dis[v]-dis[u];

           if(Next[u]!=*it)

           {

               p=new Heap;

               fill(p->child,p->child+4,nullNode);

               p->dep=1;

               p->edge=*it;

               V.pb(p);

           }

        }

        if(SZ(V)==0) continue;

        make_heap(V.begin(),V.end(),cmp);

        FOR0(i,SZ(V))

        {

            if(2*i+1<SZ(V)) V[i]->child[2]=V[2*i+1];

            else V[i]->child[2]=nullNode;



            if(2*i+2<SZ(V)) V[i]->child[3]=V[2*i+2];

            else V[i]->child[3]=nullNode;

        }

        head[u]=creat(head[u],V.front());

    }

}



void print()

{

    priority_queue<NODE> Q;

    if(dis[s]==-1) puts("NO");

    else

    {

        PR(dis[s]);

        if(head[s]!=nullNode) Q.push(NODE(head[s],dis[s]+head[s]->edge->dis));

    }

    K--;

    NODE p,q;

    int i;

    while(K--)

    {

        if(Q.empty())

        {

            puts("NO");

            continue;

        }

        p=Q.top();

        Q.pop();

        PR(p.dis);

        if(head[p.H->edge->v]!=nullNode)

        {

            q.H=head[p.H->edge->v];

            q.dis=p.dis+q.H->edge->dis;

            Q.push(q);

        }

        FOR0(i,4) if(p.H->child[i]!=nullNode)

        {

            q.H=p.H->child[i];

            q.dis=p.dis-p.H->edge->dis+p.H->child[i]->edge->dis;

            Q.push(q);

        }

    }

}



int main()

{

    input();

    dijkstra();

    build();

    print();

    return 0;

}