poj 3463 最短路与次短路&&统计个数

题意：求最短路和比最短路长度多1的次短路的个数

本来想图(有)方(模)便(版)用spfa的，结果妹纸要我看看dijkstra怎么解....

写了三遍orz

Ver1.0：堆优化+邻接表，WA

//不能用堆优化+邻接表，因为需要处理dis[i][0]和dis[i][1]两套，如果都挤到一个堆里就乱套了

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
#include <vector>
using namespace std;
const int Ni = 10000;
const int INF = 1<<27;
struct node
{                   //eg[i].x  eg[i].d    i:start  x:end   d:distance
    int x,d;
    node(){}
    node(int a,int b){x=a;d=b;}
    bool operator < (const node & a) const      //用于优先队列, 取距离原点最近的点
    {
        if(d==a.d) return x<a.x;
        else return d > a.d;
    }
};
vector<node> eg[Ni];
int dis[Ni][5],cnt[Ni][5],n,T;

void Dijkstra(int s)    //1.比最短路短2.等于最短路3.长于最短路但短于次短路4.等于次短路
{
    memset(dis,0,sizeof(dis));
    memset(cnt,0,sizeof(cnt));

    int i;
    for(i=0;i<=n;i++)
    {
        dis[i][1]=INF;
        dis[i][2]=INF;
    }
    dis[s][1]=0;
    dis[s][2]=0;
    priority_queue<node> q;         //q：优先队列，用来取离原点最近的顶点
    q.push(node(s,dis[s][1]));      //初始只有一个原点自己
    while(!q.empty())
    {
        node x=q.top();q.pop();
        for(i=0;i<eg[x.x].size();i++)
        {
            node y=eg[x.x][i];
            if(dis[y.x][1]>x.d+y.d)       //1
            {
                cnt[y.x][1]=1;
                cnt[y.x][2]=1;
                dis[y.x][2]=dis[y.x][1];
                dis[y.x][1]=x.d+y.d;
                q.push(node(y.x,dis[y.x][1]));
            }
            else if (dis[y.x][1]==x.d+y.d)      //2
            {
                cnt[y.x][1]++;
            }
            else if ((dis[y.x][1]<x.d+y.d)&&(x.d+y.d<dis[y.x][2]))      //3
            {
                cnt[y.x][2]=1;
                dis[y.x][2]=x.d+y.d;
            }
            else if (x.d+y.d==dis[y.x][2])      //4
            {
                cnt[y.x][2]++;
            }
        }
    }
}

void debug()
{
    cout<<"Debug only"<<endl;
    for (int i=1;i<=n;i++)
        printf("%d - %d %d - %d %d
",i,dis[i][1],cnt[i][1],dis[i][2],cnt[i][2]);
    cout<<ans1<<"    "<<ans2<<endl;
    
}

int main()
{
    scanf("%d",&T);
    while (T--)
    {
        int a,b,d,m,k,st;
        scanf("%d%d",&n,&m);
        for(int i=0;i<=n;i++) eg[i].clear();
        while(m--)
        {
            scanf("%d%d%d",&a,&b,&d);
            eg[a].push_back(node(b,d));
        }
        scanf("%d %d",&k,&st);
        Dijkstra(k);

        debug1();
        
        int t1=dis[st][1],t2=dis[st][2],ans1=cnt[st][1],ans2;
        if (t2-t1==1)
            ans2=cnt[st][2];
        else ans2=0;
        printf("%d
",ans1+ans2);
    }

    return 0;
}

Ver2.0：邻接矩阵，WA

//不能用邻接矩阵，因为会有重边

#include <iostream>
#include <cstring>
using namespace std;
#define MAXINT 9999999

int minx,minj,x,y,t,k,n,m,tmp,st,flag;
int v[1010][3],d[1010][3],cnt[1010][3],a[1010][1010];

int main()
{
    int T;
    cin>>T;
    while (T--)
    {
        cin>>n>>m;
        memset(a,0,sizeof(a));
        memset(d,MAXINT,sizeof(d));
        memset(v,0,sizeof(v));
        memset(cnt,0,sizeof(cnt));

        for (int i=1;i<=m;i++)
        {
            cin>>x>>y>>t;
            a[x][y]=t;
        }
        cin>>k>>st;
        d[k][1]=0;  //d[k][2]=0;
        cnt[k][1]=1;   // cnt[k][2]=1;

        for (int i=1;i<=2*n;i++)
        {
            minx=MAXINT;
            for (int j=1;j<=n;j++)
            {
                if ((v[j][1]==0)&&(d[j][1]<minx))
                {
                    minx=d[j][1];
                    minj=j;
                    flag=1;
                }
                if ((v[j][2]==0)&&(d[j][2]<minx))
                {
                    minx=d[j][2];
                    minj=j;
                    flag=2;
                }
            }
            v[minj][flag]=1;
            for (int j=1;j<=n;j++)
               // if ((v[j][1]==0)&&(a[minj][j]>0))
               if (a[minj][j]>0)
            {
                tmp=minx+a[minj][j];

                if (tmp<d[j][1])
                {
                    d[j][2]=d[j][1];
                    d[j][1]=tmp;
                    cnt[j][2]=cnt[j][1];
                    cnt[j][1]=cnt[minj][flag];
                }
                else if (tmp==d[j][1])
                {
                    cnt[j][1]+=cnt[minj][flag];
                }
                else if (tmp<d[j][2])
                {
                    d[j][2]=tmp;
                    cnt[j][2]=cnt[minj][flag];
                }
                else if (tmp==d[j][2])
                {
                    cnt[j][2]+=cnt[minj][flag];
                }
            }
    }

    for (int i=1;i<=n;i++)
        cout<<d[i][1]<<" "<<cnt[i][1]<<" = "<<d[i][2]<<" "<<cnt[i][2]<<endl;
    cout<<endl;
    int t1=d[st][1],t2=d[st][2],ans1=cnt[st][1],ans2;
    if (t2==t1+1) ans2=cnt[st][2]; else ans2=0;
    cout<<ans1+ans2<<endl;
    }
    return 0;
}

Ver3.0：朴素n^2算法+邻接表  AC

#include <stdio.h>
#include <string.h>
#define INF 999999

struct node
{
    int to,dat;
}edge[1010][1010];

int cnt[1010][2],d[1010][2],vis[1010][2];
int x,y,z,n,m,T,st,ed;

void insert_node(int x,int y,int z)
{
    edge[x][0].dat++;
    int tmp=edge[x][0].dat;
    edge[x][tmp].to=y;
    edge[x][tmp].dat=z;
}

void dijkstra()
{
    memset(vis,0,sizeof(vis));
    memset(d,INF,sizeof(d));
    memset(cnt,0,sizeof(cnt));
    d[st][0]=0;
    cnt[st][0]=1;

    for (int i=1;i<=2*n;i++)
    {
        int minj,flag,minx=INF;
        for (int j=1;j<=n;j++)
            if ((vis[j][0]==0)&&(d[j][0]<minx))
            {
                minx=d[j][0];
                minj=j;
                flag=0;
            }
            else if ((vis[j][1]==0)&&(d[j][1]<minx))
            {
                minx=d[j][1];
                minj=j;
                flag=1;
            }
        vis[minj][flag]=1;
        int tmp=edge[minj][0].dat;
        for (int j=1;j<=tmp;j++)
        {
            int yy=edge[minj][j].to;
            int zz=edge[minj][j].dat;
            //if (vis[yy][flag]==0)
            //{
                int tm=minx+zz;
                if (tm<d[yy][0])
                {
                    d[yy][1]=d[yy][0];
                    cnt[yy][1]=cnt[yy][0];
                    d[yy][0]=tm;
                    cnt[yy][0]=cnt[minj][flag];
                }
                else if (tm==d[yy][0])
                {
                    cnt[yy][0]+=cnt[minj][flag];
                }
                else if (tm<d[yy][1])
                {
                    d[yy][1]=tm;
                    cnt[yy][1]=cnt[minj][flag];
                }
                else if (tm==d[yy][1])
                {
                    cnt[yy][1]+=cnt[minj][flag];
                }
            //}

        }

    }
}

int main()
{
//    freopen("in.txt","r",stdin);

    scanf("%d",&T);
    while (T--)
    {
        memset(edge,0,sizeof(edge));
        scanf("%d %d",&n,&m);
        for (int i=1;i<=m;i++)
        {
            scanf("%d %d %d",&x,&y,&z);
            insert_node(x,y,z);
        }
        scanf("%d %d",&st,&ed);

/*
        for (int i=1;i<=n;i++)
            for (int j=1;j<=edge[i][0].dat;j++)
                printf("Debug: %d -> %d = %d
",i,edge[i][j].to,edge[i][j].dat);
*/

        dijkstra();

        int tx,ty,ans2,ans1;
        tx=d[ed][0];    ty=d[ed][1];
        ans1=cnt[ed][0];
        if (ty-tx==1)   ans2=cnt[ed][1];
            else ans2=0;
//        printf("%Debug: %d %d %d %d
",tx,ty,ans1,ans2);
        printf("%d
",ans1+ans2);
    }
    return 0;
}

邻接表很少用到都不大会写了>_<

dij松弛的条件改变下，有四种情况
1.比最短路短2.等于最短路3.长与最短路但短于次短路4.等于次短路

d[i][0]记最短路， d[i][1]记次短路

注意这里：

int tm=minx+zz;
if (tm<d[yy][0])
{
    d[yy][1]=d[yy][0];
    cnt[yy][1]=cnt[yy][0];
    d[yy][0]=tm;
    cnt[yy][0]=cnt[minj][flag];        
}
else if (tm==d[yy][0])
{
    cnt[yy][0]+=cnt[minj][flag];
    
    //因为松弛操作是从minj点开始的
    //（d[minj]+a[minj,j]<d[j]）
    //所以记录cnt的时候要+=cnt[minj][flag]
    //一开始以为直接+1就行，WA了
    //前面的cnt[yy][0]=cnt[minj][flag]同理
}
else if (tm<d[yy][1])
{
    d[yy][1]=tm;
    cnt[yy][1]=cnt[minj][flag];
}
else if (tm==d[yy][1])
{
    cnt[yy][1]+=cnt[minj][flag];
}

Reference：

http://blog.csdn.net/wmn_wmn/article/details/7376707

http://www.cnblogs.com/Missa/archive/2012/08/31/2665244.html