PAT A1003 Emergency

一、题目大意

1. PAT A1003
2. 给出 n 个城市，m 条无向边，每个城市都有一定数目的救援小组，所有边的边权已知。现在给出起点和终点，求最短路径的条数以及最短路径上的救援小组数目之和。如果有多条最短路径，则输出数目之和最大的。

二、解题思路

1. 使用 dijkstra 最短路径算法，本题在求解最短路径的同时需要求解另外两个信息：最短路径条数和最短路径上的最大点权之和，只需要在更新 d[v] 的同时更新这两个数组即可。

三、参考代码

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 505;
const int INF = 1000000000;
int n, m, c1, c2;
int num[maxn], weight[maxn], w[maxn], d[maxn];
int G[maxn][maxn];
bool vis[maxn] = { false };

void dijkstra() {
	fill(d, d + maxn, INF);
	fill(w, w + maxn, 0);
	fill(num, num + maxn, 0);
	d[c1] = 0;
	w[c1] = weight[c1];
	num[c1] = 1;
	for (int i = 0; i < n; i++) {
		int u = -1, min = INF;
		for (int j = 0; j < n; j++)
			if (!vis[j] && d[j] < min) {
				u = j;
				min = d[j];
			}
		if (u == -1) return;
		vis[u] = true;
		for (int v = 0; v < n; v++) {
			if (!vis[v] && G[u][v] != INF)
				if (d[u] + G[u][v] < d[v]) {
					d[v] = d[u] + G[u][v];
					w[v] = w[u] + weight[v];
					num[v] = num[u];
				}
				else if (d[u] + G[u][v] == d[v]) {
					num[v] += num[u];
					if (w[u] + weight[v] > w[v])
						w[v] = w[u] + weight[v];
				}
		}
	}
}

int main() {
	fill(G[0], G[0] + maxn * maxn, INF);
	cin >> n >> m >> c1 >> c2;
	for (int i = 0; i < n; i++)
		cin >> weight[i];
	int ca, cb, L;
	for (int i = 0; i < m; i++) {
		cin >> ca >> cb >> L;
		G[ca][cb] = G[cb][ca] = L;
	}
	dijkstra();
	cout << num[c2] << ' ' << w[c2] << endl;
	return 0;
}

四、解题感悟

1. 算法笔记真是不可多得的好书。
2. 这里再给出 Bellman-Ford 算法供参考。

#include<iostream>
#include<vector>
#include<set>
#include<algorithm>
using namespace std;
const int maxn = 505;
const int INF = 1000000000;
struct node { int v, dis; node(int v, int d) :v(v), dis(d) {} };
int n, m, c1, c2;
int weight[maxn], w[maxn], d[maxn], num[maxn];
vector <node> adj[maxn];
set <int> pre[maxn];

void bellman() {
	fill(d, d + maxn, INF);
	fill(w, w + maxn, 0);
	fill(num, num + maxn, 0);
	d[c1] = 0;
	w[c1] = weight[c1];
	num[c1] = 1;
	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[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;
					for (auto it = pre[v].begin(); it != pre[v].end(); it++)
						num[v] += num[*it];
				}
			}
		}
	}
}

int main() {
	cin >> n >> m >> c1 >> c2;
	for (int i = 0; i < n; i++)
		cin >> weight[i];
	for (int i = 0; i < m; i++) {
		int ca, cb, dis;
		cin >> ca >> cb >> dis;
		adj[ca].push_back(node(cb, dis));
		adj[cb].push_back(node(ca, dis));
	}
	bellman();
	cout << num[c2] << ' ' << w[c2] << endl;
	return 0;
}