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]);
    }
}

有時候我們可以用到優先佇列
列如 這道題

#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);
}