Bellman_Ford算法也是求单源最短路径的算法,但是它能算带负权边的图的最短路径(对于带负圈的图就无能为力),且可以判断当前图是否带有负圈。它的时间复杂度是O(n*m),其中n为点数,m为边数。
Bellman_Ford算法为什么能求得单源最短路径呢?其实他求解最短路径就是用的Dijkstra思想。因为它一共松弛n-1轮,每轮遍历了所有的边,所以它每轮至少要生成一个点的最短距离。所以通过n-1轮后,必然产生所有点的最短距离。
//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;
下面是另一个代码。
#include <iostream>
using namespace std;
const int maxnum = 100;
const int maxint = 99999;
// 边,
typedef struct Edge
{
int u, v; // 起点,重点
int weight; // 边的权值
} Edge;
Edge edge[maxnum]; // 保存边的值
int dist[maxnum]; // 结点到源点最小距离
int nodenum, edgenum, source; // 结点数,边数,源点
// 初始化图
void init()
{
// 输入结点数,边数,源点
cin >> nodenum >> edgenum >> source;
for(int i=1; i<=nodenum; ++i)
dist[i] = maxint;
dist[source] = 0;
for(int i=1; i<=edgenum; ++i)
{
cin >> edge[i].u >> edge[i].v >> edge[i].weight;
if(edge[i].u == source) //注意这里设置初始情况
dist[edge[i].v] = edge[i].weight;
}
}
// 松弛计算
void relax(int u, int v, int weight)
{
if(dist[v] > dist[u] + weight)
dist[v] = dist[u] + weight;
}
bool Bellman_Ford()
{
for(int i=1; i<=nodenum-1; ++i)
for(int j=1; j<=edgenum; ++j)
relax(edge[j].u, edge[j].v, edge[j].weight);
bool flag = 1;
// 判断是否有负环路
for(int i=1; i<=edgenum; ++i)
if(dist[edge[i].v] > dist[edge[i].u] + edge[i].weight)
{
flag = 0;
break;
}
return flag;
}
int main()
{
//freopen("input3.txt", "r", stdin);
init();
if(Bellman_Ford())
for(int i = 1 ; i <= nodenum; i++)
cout << dist[i] << endl;
return 0;
}