最短路spfa

spfa可以处理负权回路 什么是负权回路 ：如果存在一个环（从某个点出发又回到自己的路径），而且这个环上所有权值之和是负数，那这就是一个负权环，也叫负权回路

如果一条边是负值而且这个图是无向图那么肯定是有负权回路 最小值能在2 3间不断更新

如果一条边是负值但是这个图是有向图 但是可以不断走 1 2 3 来不断更新

但是这个图就没有负权回路

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
#include<queue>
#include<math.h>
#include<vector>
#include<iostream>
#define inf 0x3f3f3f3f
#define ll long long
#define N 100000+10
using namespace std;
int n,m;
int x,y,z;
bool v[100];
int d[100];
int w[100][100];
void spfa(int x)
{
    memset(v,0,sizeof(v));
    d[x]=0;
    queue<int>q;
    q.push(x);
    v[x]=1;
    while(!q.empty())
    {
        int st=q.front();
        q.pop();
        v[st]=0;
        for(int i=1;i<=n;i++)
        {
            if(d[st]+w[st][i]<d[i])
            {
                d[i]=d[st]+w[st][i];
                if(!v[i])
                {
                    q.push(i);
                    v[i]=1;
                }
            }
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
   memset(w,inf,sizeof(w));
   memset(d,inf,sizeof(d));
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        w[x][y]=z;//单向图 
    }
    spfa(1);
    for(int i=1;i<=n;i++)
    {
        printf("%d ",d[i]);
    }
}

我们也能通过邻接表来存 邻接表除了速度比邻接矩阵快还有个好处是能存相同起点和终点的边
先看数组模拟链表
当初我是看啊哈 算法 看懂了 在这里盗用几张他的图

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
#include<queue>
#include<math.h>
#include<vector>
#include<iostream>
#define inf 0x3f3f3f3f
#define ll long long
#define N 100000+10
using namespace std;
int n,m;
bool v[100];
int d[100];
struct node
{
    int x,y,z;
    int next;
}s[100];
int first[100];
void spfa(int x)
{
    memset(v,0,sizeof(v));
    d[x]=0;
    queue<int>q;
    q.push(x);
    v[x]=1;
    while(!q.empty())
    {
        int st=q.front();
        q.pop();
        v[st]=0;
        for(int i=first[st];i!=-1;i=s[i].next)
        {
            if(d[st]+s[i].z<d[s[i].y])
            {
                d[s[i].y]=d[st]+s[i].z;
                if(!v[s[i].y])
                {
                    q.push(s[i].y);
                    v[s[i].y]=1;
                }
            }
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
   memset(d,inf,sizeof(d));
   memset(first,-1,sizeof(first));
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&s[i].x,&s[i].y,&s[i].z);
        s[i].next=first[s[i].x];
        first[s[i].x]=i;
    }
    spfa(1);
    for(int i=1;i<=n;i++)
    {
        printf("%d ",d[i]);
    }
}

但是数组模拟有个缺点是不能存无向图
我们也能用vector直接进行链表操作 但是好像比数组要慢

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
#include<queue>
#include<math.h>
#include<vector>
#include<iostream>
#define inf 0x3f3f3f3f
#define ll long long
#define N 100000+10
using namespace std;
int n,m;
int x,y,z;
bool v[100];
int d[100];
struct node
{
    int y,z;
};
vector<node>e[100];
void spfa(int x)
{
    memset(v,0,sizeof(v));
    d[x]=0;
    queue<int>q;
    q.push(x);
    v[x]=1;
    while(!q.empty())
    {
        int st=q.front();
        q.pop();
        v[st]=0;
        for(int i=0;i<e[st].size();i++)
        {
            if(d[st]+e[st][i].z<d[e[st][i].y])
            {
                d[e[st][i].y]=d[st]+e[st][i].z;
                if(!v[e[st][i].y])
                {
                    q.push(e[st][i].y);
                    v[e[st][i].y]=1;
                }
            }
        }
    }
}
int main()
{
    scanf("%d%d",&n,&m);
   memset(d,inf,sizeof(d));
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
       e[x].push_back((node){y,z});
       e[y].push_back((node){x,z});
    //存入无向图
    }
    spfa(1);
    for(int i=1;i<=n;i++)
    {
        printf("%d ",d[i]);
    }
}

有时候我们可以用到优先队列
列如 这道题

http://poj.org/problem?id=1724

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
#include<queue>
#include<math.h>
#include<iostream>
using namespace std;
int k,n,m;
int ans;
int u[11000],v[11000],w[11000],z[11000];
int first[110],next[11000];
struct node
{
   int x;
   int l;
   int q;
   friend bool operator<(node n1,node n2)
   {
       if(n1.l==n2.l)
        return n2.q<n1.q;
       return n2.l<n1.l;
   }
};
void spfa(node u)
{
      node st,ed;
    priority_queue<node> q;
    q.push(u);
    while(!q.empty())
    {
        st=q.top();
        q.pop();
        int x=st.x;
        if(x==n)
        {
            ans=st.l;
           return;
        }
        for(int i=first[x];i;i=next[i])
        {
            if(st.q+z [i]<=k)
            {
                ed.x=v[i];
                ed.l=w[i]+st.l;
                ed.q=z[i]+st.q;
                q.push(ed);
            }
        }
    }
}
int main()
{
    scanf("%d%d%d",&k,&n,&m);
    for(int i=1;i<=n;i++)
        first[i]=-1;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d%d",&u[i],&v[i],&w[i],&z[i]);
        next[i]=first[u[i]];
        first[u[i]]=i;
    }
    node u={1,0,0};
     ans=-1;
    spfa(u);
 printf("%d\n",ans);
}