poj3463&&hdu1688 次短路（dijkstra）

　A*算法超内存。

　　对于最短路，我们可以维护dis[]数组，来求得最短路，但是此题有次短路，所以定义dis[][2]，dis[][0]表示最短路，dis[][1]表示次短路;cnt[][2]，cnt[][0]表示最短路条数，cnt[][1]表示次短路条数。

更新时:

如果小于最短路，更新dis[][0]。

如果等于最短路，更新cnt[][0]。

如果大于最短路小于次短路，更新dis[][1];

如果等于次短路，更新cnt[][1]。

由于此时要求2条路，若以外层循环需要2*n-1次。

以下为dijkstra:

#include<stdio.h>
#include<string.h>
#define INF 1000000001
const int maxn = ;
const int maxm = ;
struct node
{
    int to;
    int v;
    int next;
}edge[maxn*maxn/];
int pre[maxn],index,dis[maxn][],cnt[maxn][],n,vis[maxn][];
void init()
{
    index=;
    memset(pre,-,sizeof(pre));
}
void add(int x,int y,int z)
{
    edge[index].to=y;
    edge[index].v=z;
    edge[index].next=pre[x];
    pre[x]=index++;
}
void dij(int s,int t)
{
    int i,j,k,pos;
    for(i=;i<=n;i++)
    {
        dis[i][]=INF;
        dis[i][]=INF;
        cnt[i][]=cnt[i][]=;
        vis[i][]=vis[i][]=;
    }
    dis[s][]=;
    cnt[s][]=;
    pos=s;
    k=;
    for(i=;i<*n;i++)
    {
        int min=INF;
        for(j=;j<=n;j++)
        {
            if(!vis[j][]&&min>dis[j][])
            {
                min=dis[j][];
                k=;
                pos=j;
            }
            else if(!vis[j][]&&min>dis[j][])
            {
                min=dis[j][];
                k=;
                pos=j;
            }
        }
        if(min>=INF)
            break;
        vis[pos][k]=;
        for(j=pre[pos];j!=-;j=edge[j].next)
        {
            int v=edge[j].to;
            if(dis[v][]>min+edge[j].v)
            {
                dis[v][]=dis[v][];//
                cnt[v][]=cnt[v][];
                dis[v][]=min+edge[j].v;
                cnt[v][]=cnt[pos][k];
            }
            else if(dis[v][]==min+edge[j].v)
            {
                cnt[v][]+=cnt[pos][k];
            }
            else if(dis[v][]>min+edge[j].v)
            {
                dis[v][]=min+edge[j].v;
                cnt[v][]=cnt[pos][k];
            }
            else if(dis[v][]==min+edge[j].v)
            {
                cnt[v][]+=cnt[pos][k];
            }
        }
    }
    int ans=cnt[t][];
    if(dis[t][]==dis[t][]+)
        ans+=cnt[t][];
    printf("%d\n",ans);
}
int main()
{
    int i,j,ft,m;
    scanf("%d",&ft);
    while(ft--)
    {
        init();
        scanf("%d%d",&n,&m);
        for(i=;i<m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
        }
        int s,t;
        scanf("%d%d",&s,&t);
        dij(s,t);
    }
}

以下为A*算法(超内存):

#include<stdio.h>
#include<string.h>
#include<queue>
#define INF 100000001
using namespace std;
const int maxn = ;
struct node
{
    int to;
    int g,f;
    friend bool operator<(node a,node b){
        if(a.f!=b.f)
            return a.f>b.f;
        return a.g>b.g;
    }
};
struct Enode
{
    int to;
    int v;
    int next;
}edge[],fedge[];
int pre[maxn],index,vis[maxn],n,findex,fpre[maxn],dis[maxn];
void init()
{
    findex=index=;
    memset(fpre,-,sizeof(fpre));
    memset(pre,-,sizeof(pre));
}
void add(int x,int y,int z)
{
    edge[index].to=y;
    edge[index].v=z;
    edge[index].next=pre[x];
    pre[x]=index++;
}
void fadd(int x,int y,int z)
{
    fedge[findex].to=y;
    fedge[findex].v=z;
    fedge[findex].next=fpre[x];
    fpre[x]=findex++;
}
void spfa(int s)
{
    int i,j;
    queue<int>q;
    for(i=;i<=n;i++)
    {
        vis[i]=;
        dis[i]=INF;
    }
    dis[s]=;
    vis[s]=;
    q.push(s);
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        vis[t]--;
        for(i=fpre[t];i!=-;i=fedge[i].next)
        {
            int v=fedge[i].to;
            if(dis[v]>dis[t]+fedge[i].v)
            {
                dis[v]=dis[t]+fedge[i].v;
                q.push(v);
            }
        }
    }
}
void A_star(int s,int t)
{
    int i,j,cnt=,first=-;
    priority_queue<node>q;
    node temp;
    temp.f=dis[s];
    temp.g=;
    temp.to=s;
    q.push(temp);
    while(!q.empty())
    {
        temp=q.top();
        q.pop();
        if(temp.to==t)
        {
            if(cnt==)
            {
                first=temp.g;
            }
            else if(temp.g-first>)
            {
                break;
            }
            cnt++;
        }
        for(i=pre[temp.to];i!=-;i=edge[i].next)
        {
            node tt;
            tt.to=edge[i].to;
            tt.g=temp.g+edge[i].v;
            tt.f=tt.g+dis[tt.to];
            q.push(tt);
        }
    }
    printf("%d\n",cnt);
}
int main()
{
    int i,j,ft,m;
    scanf("%d",&ft);

    while(ft--)
    {
        init();
        scanf("%d%d",&n,&m);
        for(i=;i<m;i++)
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            add(x,y,z);
            fadd(y,x,z);
        }
        int s,t;
        scanf("%d%d",&s,&t);
        spfa(t);
        A_star(s,t);
    }
}