Bellman-Ford 算法

Bellman-Ford算法要遍历所有边，所以使用邻接表会比较方便。

考虑最短路径树，第1次操作后，最短路径树中第二层的顶点的d值会被确定，由于树最高n层（简单图，每个顶点最多出现一次），所以需要遍历n-1次，每次操作都相同。

正因为每次操作都相同，所以如果存在某次操作没有更新任何边，则可直接跳出，不用操作到n-1次。

 

分3步走：

1. 初始化
2. n-1次操作，
3. 每次操作都遍历所有边，并试图更新
4. 1次操作，遍历所有边，如果还有边可以被优化，说明存在负环

struct node {
	int v, dis;
	node(int _v, int _dis) :v(_v), dis(_dis) {}
};
vector<node> adj[maxn];//邻接表
int n, d[maxn];

bool bellman(int s) {
	//1  初始化
	fill(d, d + maxn, INF);
	d[s] = 0;

	//2  n-1次操作
	for (int i = 0; i < n - 1; i++) {//n-1次操作
		bool flag = true;

		//3  遍历所有边，并试图更新
		for (int u = 0; u < n; u++) {//邻接表结构，遍历所有头结点
			for (int j = 0; j < adj[u].size(); j++) {//遍历每个头结点所连的每条边
				int v = adj[u][j].v, dis = adj[u][j].dis;
				if (d[u] + dis < d[v]) {
					d[v] = d[u] + dis;
					flag = false;
				}
			}
		}
		if (flag)break;
	}

	//4  判断有无负环
	for (int u = 0; u < n; u++) {//遍历每条边
		for (int j = 0; j < adj[u].size(); j++) {
			int v = adj[u][j].v, dis = adj[u][j].dis;
			if (d[u] + dis < d[v])
				return false;
		}
	}
	return true;
}

Bellman-ford算法里需要注意 如何来统计最短路径条数。此算法每轮操作的内容都相同，所以会多次访问已经访问过的点，所以需要用set<int> pre[maxn]来记录每个点的前驱。因为set不会重复。

当出现和最短路径长度相同的另一条最短路径时，必须重新计算最短路径条数。如下例子。

举例：A1003

1003 Emergency (25分)

As an emergency rescue team leader of a city, you are given a special map of your country. The map shows several scattered cities connected by some roads. Amount of rescue teams in each city and the length of each road between any pair of cities are marked on the map. When there is an emergency call to you from some other city, your job is to lead your men to the place as quickly as possible, and at the mean time, call up as many hands on the way as possible.

Input Specification:

Each input file contains one test case. For each test case, the first line contains 4 positive integers: N (≤500) - the number of cities (and the cities are numbered from 0 to N−1), M - the number of roads, C​1​​ and C​2​​ - the cities that you are currently in and that you must save, respectively. The next line contains N integers, where the i-th integer is the number of rescue teams in the i-th city. Then M lines follow, each describes a road with three integers c​1​​, c​2​​ and L, which are the pair of cities connected by a road and the length of that road, respectively. It is guaranteed that there exists at least one path from C​1​​ to C​2​​.

Output Specification:

For each test case, print in one line two numbers: the number of different shortest paths between C​1​​ and C​2​​, and the maximum amount of rescue teams you can possibly gather. All the numbers in a line must be separated by exactly one space, and there is no extra space allowed at the end of a line.

Sample Input:

5 6 0 2
1 2 1 5 3
0 1 1
0 2 2
0 3 1
1 2 1
2 4 1
3 4 1

Sample Output:

2 4

Bellman算法AC代码：

#include <iostream>
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<string.h>
using namespace std;
#pragma warning(disable:4996)
#include<string>
#include<stack>
#include<map>
#include<queue>
#include<set>
const int maxn = 500 + 10;
const int INF = 0x3fffffff;

struct node {
	int v, dis;
	node(int _v, int _dis) :v(_v), dis(_dis) {}
};
vector<node> adj[maxn];//邻接表
int n, m, start, des, d[maxn];
int weight[maxn], w[maxn] = { 0 }, num[maxn] = { 0 };
set<int> pre[maxn];//

void bellman(int s) {
	//1
	fill(d, d + maxn, INF);
	d[s] = 0;
	w[s] = weight[s];
	num[s] = 1;

	//2
	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, dis = adj[u][j].dis;

				//3
				if (d[u] + dis < d[v]) {
					d[v] = d[u] + dis;
					w[v] = w[u] + weight[v];
					num[v] = num[u];
					pre[v].clear();
					pre[v].insert(u);
				}
				else if (d[u] + dis == d[v]) {
					if (w[u] + weight[v] > w[v])
						w[v] = w[u] + weight[v];
					pre[v].insert(u);
					num[v] = 0;//重新统计num[v]
					for (set<int>::iterator it = pre[v].begin(); it != pre[v].end(); it++)
						num[v] += num[*it];
				}
			}
		}
	}
}

int main() {
	scanf("%d %d %d %d", &n, &m, &start, &des);
	for(int i=0;i<n;i++)
		scanf("%d", &weight[i]);
	int x, y, z;
	for (int i = 0; i < m; i++) {
		scanf("%d %d %d", &x, &y, &z);
		adj[x].push_back(node(y, z));
		adj[y].push_back(node(x, z));
	}
	bellman(start);
	printf("%d %d", num[des], w[des]);
	return 0;
}

优化