【概述】
Bellman-Ford算法适用于计算单源最短路径,即:只能计算起点只有一个的情况。
其最大特点是可以处理存在负边权的情况,但无法处理存在负权回路的情况。
其时间复杂度为:O(V*E),其中,V 是顶点数,E 是边数。
【算法分析】
Bellman Ford 算法与 Dijkstra 算法的思想相同,只不过 Dijkstra 是每次确定一个最短距离点,并用这个点去更新与之相连的其他边,而 Ford 算法是每次更新所有的边,从而确定一个点的最短距离
起始时,认为起点是白点(dis[1]=0),每一次都枚举所有的边,必然会有一些边,连接着白点和蓝点。因此每次都能用所有的白点去修改所有的蓝点,每次循环也必然会有至少一个蓝点变成白点。
以下图为例
令起点为白点,即:dis[1]=0,dis[2、3、4、5]=∞
遍历所有边,将与白点相连的蓝点变为白点,即:dis[1]=0,dis[2]=2,dis[3]=1,dis[4]=2,dis[5] =∞
继续向下遍历,修改蓝点为白点,即:dis[1]=0,dis[2]=2,dis[3]=1,dis[4]=2,dis[5] =4
【算法核心】
设起点为 s,dis[v] 表示从 s 到 v 的最短路径,u[i] 和 v[i] 分别表示第 i 条边的起点和终点,w[j] 是连接 u、v 的边 j 的长度。
初始化:
dis[s]=0,dis[v]=0x3f3f3f3f(v≠s),即:初始化为一极大值
算法主体:
void Bellman_Ford()
{
for(int i=0;i<n;i++)
dis[i]=INF;
dis[0]=0;
for(int i=1;i<=n-1;i++)//枚举除终点外的所有点
for(int j=1;j<=m;j++)//枚举所有边
{
int x=u[j];//边j的起点
int y=v[j];//边j的终点
if(dis[x]<INF)//松弛
dis[y]=min(dis[y],dis[x]+w[j]);
}
}
算法结束:dis[v] 即为 s 到 v 最短距离
【SPFA】
SPFA 实质就是 Ford 算法加了判断负环的队列实现版本。
其利用队列以进行 Ford 算法的过程,初始时将起点加入队列,每次从队列中取出一个元素,并对所有与它相邻的点进行修改,若相邻的点修改成功,则将其入队,直到队列为空时算法结束。
SPFA 时间复杂度可达:O(k*E),其中,E 是边数,k 是常数,平均值是 2。
int dis[N];
bool vis[N];
void SPFA(int S) {
memset(vis, false, sizeof(vis));
memset(dis, INF, sizeof(dis));
dis[S] = 0;
queue<int> Q;
Q.push(S);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
vis[x] = false;
for (int i = head[x]; i != -1; i = edge[i].next) {
int to = edge[i].to;
if (dis[to] > dis[x] + edge[i].dis) {
dis[to] = dis[x] + edge[i].dis;
if (!vis[to]) {
vis[to] = true;
Q.push(to);
}
}
}
}
}
【SPFA 的 SLF 优化】
在 SPFA 的基础上,可以进一步的进行优化,即 SLF 优化
SLF 优化就是 small label first 优化,由于先扩展最小的点可以尽量使程序尽早结束,因此当加入一个新点 u 的时候,如果此时的 dis[u] 比队首的 dis[q.front()] 小的话,就将点 v 加入队首,否则加入队尾,利用 STL 中的双端队列 deque 即可
struct Edge{
int to,dis;
};
vector<Edge> edge[N];
bool vis[N];
int dis[N];
void SPFA(int s) {
memset(dis, INF, sizeof(dis));
memset(vis, false, sizeof(vis));
vis[s] = true;
dis[s] = 0;
deque<int> Q;
Q.push_back(s);
while (!Q.empty()) {
int x = Q.front();
Q.pop_front();
vis[x] = 0;
for (int i = 0; i < edge[x].size(); i++) {
int y = edge[x][i].to;
if (dis[y] > dis[x] + edge[x][i].to) {
dis[y] = dis[x] + edge[x][i].to;
if (!vis[y]) {
vis[y] = true;
if (!Q.empty() && dis[y] < dis[Q.front()])//加入队首
Q.push_front(y);
else//加入队尾
Q.push_back(y);
}
}
}
}
}
【模版】
1.标准版
struct Edge {
int to, next;
int dis;
} edge[N];
int head[N], tot;
bool vis[N];
int dis[N];
void addEdge(int x, int y, int dis) {
edge[++tot].to = y;
edge[tot].dis = dis;
edge[tot].next = head[x];
head[x] = tot;
}
void SPFA(int S) {
memset(vis, false, sizeof(vis));
memset(dis, INF, sizeof(dis));
dis[S] = 0;
queue<int> Q;
Q.push(S);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
vis[x] = false;
for (int i = head[x]; i != -1; i = edge[i].next) {
int to = edge[i].to;
if (dis[to] > dis[x] + edge[i].dis) {
dis[to] = dis[x] + edge[i].dis;
if (!vis[to]) {
vis[to] = true;
Q.push(to);
}
}
}
}
}
int main(){
int n,m;
while(scanf("%d%d",&n,&m)!=EOF){
memset(head,-1,sizeof(head));
for(int i=1;i<=m;i++){
int x,y,dis;
scanf("%d%d%d",&x,&y,&dis);
//无向图添边两次
addEdge(x,y,dis);
addEdge(y,x,dis);
}
int S;
scanf("%d",&S);
SPFA(S);
for(int i=1;i<=n;i++)
printf("%d\n",dis[i]);
}
return 0;
}
2.带负环判断的SPFA
struct Edge {
int from, to;
int dis;
Edge() {}
Edge(int from, int to, int dis) : from(from), to(to), dis(dis) {}
};
struct SPFA {
int n, m;
Edge edges[N]; //所有的边信息
int head[N]; //每个节点邻接表的头
int next[N]; //每个点的下一条边
int pre[N]; //最短路中的上一条弧
bool vis[N];
int dis[N];
int cnt[N]; //进队次数
void init(int n) {
this->n = n;
this->m = 0;
memset(head, -1, sizeof(head));
}
void AddEdge(int from, int to, int dist) {
edges[m] = Edge(from, to, dist);
next[m] = head[from];
head[from] = m++;
}
bool negativeCycle(int s) { //判负环
memset(vis, false, sizeof(vis));
memset(cnt, 0, sizeof(cnt));
memset(dis, INF, sizeof(dis));
dis[s] = 0;
queue<int> Q;
Q.push(s);
while (!Q.empty()) {
int x = Q.front();
Q.pop();
vis[x] = false;
for (int i = head[x]; i != -1; i = next[i]) {
Edge &e = edges[i];
if (dis[e.to] > dis[x] + e.dis) {
dis[e.to] = dis[x] + e.dis;
pre[e.to] = i;
if (!vis[e.to]) {
vis[e.to] = true;
Q.push(e.to);
if (++cnt[e.to] > n)
return true;
}
}
}
}
return false;
}
} spfa;
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
spfa.init(n);
int S;
scanf("%d", &S);
for (int i = 1; i <= m; i++) {
int x, y, dis;
scanf("%d%d%d", &x, &y, &dis);
//无向边添边两次
spfa.AddEdge(x, y, dis);
spfa.AddEdge(y, x, dis);
}
spfa.negativeCycle(S);
for (int i = 1; i <= n; i++)
printf("%d\n", spfa.dis[i]);
}
return 0;
}