【有负权边的最短路问题】- Bellman-Ford算法

Bellman-Ford算法

1. 可以解决单源最短路问题
2. 也可以处理有负权边的情况

考虑环

1. 零环和正环的存在不能使最短路径更短；
2. 如果图中有负环且从源点可以到达，那么就会影响最短路径的求解。

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的所有值都已经达到最优

1. 如果最短路径存在，那么最短路径上的顶点个数肯定不会超过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;
}