文章目录
Bellman-Ford算法
- 可以解决单源最短路问题
- 也可以处理有负权边的情况
考虑环
- 零环和正环的存在不能使最短路径更短;
- 如果图中有负环且从源点可以到达,那么就会影响最短路径的求解。
Bellman-Ford算法的思想:
for(i = 0; i < n - 1; i++) //对图中的边进行V-1轮操作
{
for(each edge u->v) //每轮操作都遍历所有边
{
if(d[u] + length[u->v] < d[v]) //以u为中介点可以使d[v]更小
{
d[v] = d[u] + length[u->v]; //松弛操作
}
}
}
for(each edge u->v) //对每条边进行判断
{
if(d[u] + length[u->v] < d[v]) //如果仍可以被松弛
{
return false; //说明图中有从源点可达的负环
}
return true; //数组d的所有值都已经达到最优
- 如果最短路径存在,那么最短路径上的顶点个数肯定不会超过V个。
题目来源:PAT A1003 Emergency
//Bellman-Ford算法
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
using namespace std;
const int INF = 0xfffffff;
const int maxv = 510;
int n, m, s, e; //顶点个数,边数,起点编号,终点编号
int d[maxv]; //从起点到各点的最短距离
bool vis[maxv] = {false};
int Value[maxv]; //各点的救援队数量
int total_value[maxv]; //从起点到各点的救援队数量
int num[maxv]; //从起点到各点最短路径的数量
set<int> pre[maxv];
struct Node
{
int v;
int dis;
Node(int _v, int _dis) : v(_v), dis(_dis) {} //构造函数
};
vector<Node> Adj[maxv];
void Bellman(int s)
{
fill(d, d + maxv, INF);
d[s] = 0;
fill(num, num + maxv, 0);
num[s] = 1;
total_value[s] = Value[s];
for (int i = 0; i < n - 1; i++)
{
for (int u = 0; u < n; u++)
{
for (int j = 0; j < Adj[u].size(); j++)
{
int v = Adj[u][j].v;
int dis = Adj[u][j].dis;
if (d[v] > d[u] + dis)
{
d[v] = d[u] + dis;
total_value[v] = total_value[u] + Value[v];
num[v] = num[u];
pre[v].clear();
pre[v].insert(u);
}
else if (d[v] == d[u] + dis)
{
if (total_value[v] < total_value[u] + Value[v])
{
total_value[v] = total_value[u] + Value[v];
}
pre[v].insert(u);
num[v] = 0; //重新统计num[v];
set<int>::iterator it;
for (it = pre[v].begin(); it != pre[v].end(); it++)
{
num[v] += num[*it];
}
}
}
}
}
}
int main()
{
int u, v, dis1;
cin >> n >> m >> s >> e;
for (int i = 0; i < n; i++)
{
cin >> Value[i];
}
for (int i = 0; i < m; i++)
{
cin >> u >> v >> dis1;
Node temp1(v, dis1);
Node temp2(u, dis1);
Adj[u].push_back(temp1);
Adj[v].push_back(temp2);
}
Bellman(s);
cout << num[e] << ' ' << total_value[e] << endl;
return 0;
}