Bellman_Ford算法&& SPFA算法&& SPFA算法判断负环&& Floyd算法代码详解+注释）

Bellman_Ford算法适用于解有边数限制的最短路问题。

算法步骤为：

1） for(1—n次）//这里的n就是边数的限制（比如说求从1号点到9号点边数不超过5条的最短路，那么我们的你就为5）。
2）把dist数组备份到backup数组里。
3）遍历所有边，有backup去更新所有点的距离

dist[b]=min(dist[b],backup[a]+w);

Bellman_Ford算法完整代码为：

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=10010;
int dist[N];
struct Edge{
    int a,b,w;
}edges[N];
int backup[N];
int n,m,k;

int bellman_ford()
{
    memset(dist,0x3f,sizeof dist);
    dist[1]=0;
    for(int i=0;i<k;i++)
    {
        memcpy(backup,dist,sizeof dist);
        
        for(int i=0;i<m;i++)
        {
            int a=edges[i].a,b=edges[i].b,w=edges[i].w;
            dist[b]=min(dist[b],backup[a]+w);
        }
    }
    
    if(dist[n]>0x3f3f3f3f/2) return 0;
    else return 1;
    
}


int main()
{
    cin>>n>>m>>k;
    
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        edges[i]={a,b,c};
    }
    
    if(!bellman_ford()) puts("impossible");
    else
    {
        cout<<dist[n]<<endl;
    }
    
    return 0;
}

SPFA算法的基本步骤为：

1）queue<–1;//把第一个点加都队列里面去；
st[1]=true;//标记一下第一个点已经在队列里面了
2）while(queue 不空）
{
t=queue.front();
queue.pop();
st[t]=false;//表示这个点已经不在队列里面了

更新t的所有出边 t---->b;
if(!st[b]) queue<----b;//如果b不在队列里面就把b加到队列里面去。
}

SPFA的完整代码为：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N=100010;
int h[N],e[N],ne[N],w[N],idx;
int n,m;
int dist[N];
bool st[N];

void add(int a,int b,int c)//用邻接表来存整个图
{
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}


int spfa()
{
    memset(dist,0x3f,sizeof dist);
    queue<int> q;
    q.push(1);
    dist[1]=0;
    st[1]=true;
    
    while(q.size())
    {
        int t=q.front();
        q.pop();
        
        st[t]=false;
        for(int i=h[t];i!=-1;i=ne[i])//更新一下t的所有出边
        {
            int j=e[i];
            if(dist[j]>dist[t]+w[i])
            {
                dist[j]=dist[t]+w[i];
                if(!st[j]) //如果j不在队列里面就把j加到队列里面去
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }
    
    return dist[n];
}

int main()
{
    cin>>n>>m;
    
    memset(h,-1,sizeof h);
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    
    if(spfa()==0x3f3f3f3f)  puts("impossible");
    else cout<<dist[n]<<endl;
    
    return 0;
}

SPFA判断负环

基本思想：

在SPFA的基础上增加一个cnt数组；
cnt[x]表示当前最短路的边数
更新操作为：

cnt[x]=cnt[t]+1;

SPFA判断负环的完整代码为：

#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N=10010;
int h[N],e[N],ne[N],w[N],idx;
int dist[N],cnt[N];
bool st[N];
int n,m;

void add(int a,int b,int c)
{
    e[idx]=b;
    w[idx]=c;
    ne[idx]=h[a];
    h[a]=idx++;
}

bool spfa()
{
    memset(dist,0x3f,sizeof dist);
    queue<int> q;
    for(int i=1;i<=n;i++)
    {
        q.push(i);
        st[i]=true;
    }
    
    while(q.size())
    {
        int t=q.front();
        q.pop();
        
        st[t]=false;
        for(int i=h[t];i!=-1;i=ne[i])
        {
            int j=e[i];
            if(dist[j]>dist[t]+w[i])
            {
                dist[j]=dist[t]+w[i];
                cnt[j]=cnt[t]+1;//边数更新操作
                
                if(cnt[t]>n) return true;//如果cnt[t]大于n则说明存在负环
                
                if(!st[j])
                {
                    q.push(j);
                    st[j]=true;
                }
            }
        }
        
    }
    
    return false;
}

int main()
{
    cin>>n>>m;
    
    memset(h,-1,sizeof h);
    while(m--)
    {
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    
    if(spfa()) cout<<"Yes";
    else cout<<"No";
    
    return 0;
}

Floyd算法

Floyd算法的基本思想是基于动态规划。适用于求多源最短路问题。基本步骤为：

for(k=1到n)
    for(i=1到n)
        for(j=1到n)
            d[i,j]=min(d[i,j],d[i,k]+d[k,j]);

Floyd算法的完整代码为：

//原理是基于动态规划
//适用于求多源最短路

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N=210,INF=0x3f3f3f3f;
int d[N][N];
int n,m,q;

void floyd()
{
    for(int k=1;k<=n;k++)
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)
    d[i][j]=min(d[i][j],d[i][k]+d[k][j]);
}

int main()
{
    cin>>n>>m>>q;
    
    for(int i=0;i<=n;i++)
    for(int j=0;j<=n;j++)
    if(i==j) d[i][j]=0;
    else d[i][j]=INF;
    
    for(int i=0;i<m;i++)
    {
        int a,b,c;
        cin>>a>>b>>c;
        d[a][b]=min(d[a][b],c);
    }
    
    floyd();
    
    while(q--)
    {
        int a,b;
        cin>>a>>b;
        if(d[a][b]>INF/2) puts("impossible");
        else cout<<d[a][b]<<endl;
        
    }
    return 0;
}