Bellman_Ford算法

         Bellman_Ford算法也是求单源最短路径的算法，但是它能算带负权边的图的最短路径(对于带负圈的图就无能为力)，且可以判断当前图是否带有负圈。它的时间复杂度是O(n*m)，其中n为点数，m为边数。

         Bellman_Ford算法为什么能求得单源最短路径呢？因为它一共松弛n-1轮，每轮遍历了所有的边，所以它每轮至少要生成一个点的最短距离。所以通过n-1轮后，必然产生所有点的最短距离。(可见刘汝佳<<入门经典>>P205以及<<训练指南>>P332)

//Bellman_Ford算法简单形式
//求的是从0点到其他点的单源最短路径,复杂度O(n*m)

#define INF 1e9
const int maxn=1000;
int n,m;//点数,边数，编号都从0开始
int w[maxn];//w[i]表示第i条边的权值(距离)
int u[maxn],v[maxn];//u[i]和v[i]分别表示第i条边的起点和终点
int d[maxn];//单源最短路径

//计算以s为源点的单源最短距离
void Bellman_Ford(int s)
{
    for(int i=0;i<n;i++) d[i]=INF;
    d[s]=0;
    for(int k=0;k<n-1;k++)  //迭代n-1次
    for(int i=0;i<m;i++)    //检查每条边
    {
        int x=u[i],y=v[i];
        if(d[x]<INF) d[y] =min(d[y],d[x]+w[i]); //松弛
    }
}

下面是标准版的模板，可以判负圈

//Bellman_Ford标准版模板_SPFA(能判负圈)
//求的是从s点到其他点的单源最短路径,复杂度O(n*m)

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#include<algorithm>
using namespace std;
#define INF 1e9

struct Edge
{
    int from,to,dist;
    Edge(int f,int t,int d):from(f),to(t),dist(d){}
};

struct BellmanFord
{
    int n,m;            //点数和边数,编号都从0开始
    vector<Edge> edges; //边列表
    vector<int> G[maxn];//每个节点出发的边编号(从0开始编号)
    bool inq[maxn];     //是否在队列中
    int d[maxn];        //s到各个点的距离
    int p[maxn];        //最短路中的上一条弧
    int cnt[maxn];      //进队次数

    void init(int n)
    {
        this->n=n;
        for(int i=0;i<n;i++) G[i].clear();
        edges.clear();
    }

    void AddEdge(int from,int to,int dist)
    {
        edges.push_back(Edge(from,to,dist));
        m = edges.size();
        G[from].push_back(m-1);
    }

    //计算以s为源点的最短路径
    //如果图中存在s能到达的负圈，那么返回true
    bool negativeCycle(int s)
    {
        queue<int> Q;
        memset(inq,0,sizeof(inq));
        memset(cnt,0,sizeof(cnt));
        for(int i=0;i<n;i++) d[i]= i==s?0:INF;
        Q.push(s);

        while(!Q.empty())
        {
            int u=Q.front(); Q.pop();
            inq[u]=false;
            for(int i=0;i<G[u].size();i++)
            {
                Edge &e=edges[G[u][i]];
                if(d[e.to] > d[u]+e.dist)
                {
                    d[e.to] = d[u]+e.dist;
                    p[e.to] = G[u][i];
                    if(!inq[e.to])
                    {
                        Q.push(e.to);
                        inq[e.to]=true;
                        if(++cnt[e.to]>n) return true;
                    }
                }
            }
        }
        return false;
    }
}BF;