最短路模板

Dijkstra算法（优先队列优化），O(ElogV)，单源;

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int N=1100,M=11111;
int head[N],cnt;
int d[N],p[N];
struct node
{
    int v,w,next;
    bool operator<(const node x)const
    {
        return x.w<w;
    }
}e[M];
void init()
{
    cnt=0;
    memset(head,-1,sizeof(head));
}
void add(int u,int v,int w)
{
    e[cnt].v=v,e[cnt].w=w;
    e[cnt].next=head[u],head[u]=cnt++;
}
void dijstar(int s)
{
    memset(d,0x3f,sizeof(d));
    memset(p,0,sizeof(p));
    priority_queue<node> q;
    d[s]=0;
    q.push(node{s,0,0});
    int i,u,v,w;
    while(!q.empty())
    {
        u=q.top().v;
        q.pop();
        if(p[u]) continue;
        p[u]=1;
        for(i=head[u];i!=-1;i=e[i].next)
        {
            v=e[i].v,w=e[i].w;
            if(!p[v]&&d[v]>d[u]+w)
            {
                d[v]=d[u]+w;
                q.push(node{v,d[v],0});
            }
        }
    }
}

Spfa(基于Bellman-Ford)算法，单源。在实际的应用中SPFA的算法时间效率不是很稳定，为了避免最坏情况的出现，通常使用效率更加稳定的Dijkstra算法。

const int N=110;
const int M=N*N;
int d[N],p[N],cnt[N],q[M];
int head[N],js;//,pre[N];
struct node
{
    int v,w,next;
}e[M];
void add(int u,int v,int w)
{
    e[js].v=v,e[js].w=w;
    e[js].next=head[u],head[u]=js++;
}
void init()
{
      //memset(pre,-1,sizeof(pre));
      memset(head,-1,sizeof(head));
    js=0;
}
int spfa(int s,int n)
{
      memset(d,0x3f,sizeof(d));
    memset(p,0,sizeof(p));
    memset(cnt,0,sizeof(cnt));
    int u,v,w,l=0,r=0;
    q[++r]=s,d[s]=0,p[s]=1;
    while(l<r)
    {
        p[u=q[++l]]=0;
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            v=e[i].v,w=e[i].w;
            if(d[v]>d[u]+w)
            {
                d[v]=d[u]+w;
                //pre[v]=u;
                if(!p[v])
                {
                    if(++cnt[v]>n)      //存在负环
                        return 0;
                    p[v]=1;
                    q[++r]=v;
                }
            }
        }
    }
    return 1;
}
void prpath(int s,int t)
{
    int js=0,tmp[N];
    while(t!=s)
    {
        tmp[++js]=t;
        t=pre[t];
    }
    for(int i=js;i>=1;i--)
        printf("%d->",tmp[i]);
    printf("%d
",s);
}

Floyd算法，全源。d[i][i]实际上表示「从顶点 i 绕一圈再回来的最短路径」，因此图存在负环当且仅当 d[i][i]<0。

int d[N][N],path[N[N],n;//path记录路径,d表示初始距离（若相连则初始化为边权，若无则为无穷大）
int floyd()
{
    int i,j,k;
    for(i=1;i<=n;i++)
        for(j=1;j<=n;j++)
            path[i][j]=j;
    for(k=1;k<=n;k++)
    {
        for(i=1;i<=n;i++)
        {
            for(j=1;j<=n;j++)
            {
                if(d[i][k]+d[k][j]<d[i][j])
                {
                    d[i][j]=d[i][k]+d[k][j];
                    path[i][j]=path[i][k];
                    if(i==j&&d[i][j]<0)     ////存在负环
                        return 0;
                }
            }
        }
    }
    return 1;
}
void prpath(int u,int v)
{
    printf("%d->%d: 
",u,v);
    printf("%d",u);
    while(u!=v)
    {
        printf("->%d",path[u][v]);
        u=path[u][v];
    }
    printf("
");
}