A1003 Emergency (25分)

一、技术总结

1. 这是一道考查Djiktra算法的题目，主要是求解最短路径的前提下，求每个城市点权的最大值，同时最短路径的条数。
2. 只需要在Djikstra算法的基本架构下，添加一些条件即可，点权是添加一个数组weight存储每个点的权值，然后再创建数组w，用于存储。初始化是，除了起点s，w[s]=weight[s],其余都初始化为0，使用memset(w, 0, sizeof(w)),进行初始化。
3. 而对于最短路径的条数，设置数组num，然后初始化，num[s] = 1,其余都是初始化为0，memset(num, 0, sizeof(num))。
4. 还有就是书写的问题，注意关系。具体参考代码。

二、参考代码

• Djikstra版本

#include<bits/stdc++.h>
using namespace std;
const int maxn = 510;
const int INF = 100000000;
int n, G[maxn][maxn];
bool vis[maxn] = {false};
int d[maxn];//用于记录最短路径
int num[maxn];//用于记录最短路径的条数
int weight[maxn];//记录城市中可以调动的人数 
int w[maxn];
void Djikstra(int s){
	fill(d, d+maxn, INF);
	memset(num, 0, sizeof(num));
	memset(w, 0, sizeof(w));
	//fill(num, num+maxn, 0);
	//fill(w, w+maxn, 0);
	d[s] = 0;
	num[s] = 1;
	w[s] = weight[s];
	for(int i = 0; i < n; i++){
		int u = -1, MIN = INF;
		for(int j = 0; j < n; j++){
			if(vis[j] == false && 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] == false && 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(){
	int m, c1, c2;
	scanf("%d%d%d%d", &n, &m, &c1, &c2);
	for(int i = 0; i < n; i++){
		scanf("%d", &weight[i]);
	}
	int id1, id2, L;//城市编号和他们之间的距离 
	fill(G[0], G[0]+maxn*maxn, INF);
	for(int i = 0; i < m; i++){
		scanf("%d %d %d", &id1, &id2, &L);
		G[id1][id2] = L;
		G[id2][id1] = L;
	}
	Djikstra(c1);
	printf("%d %d", num[c2], w[c2]);
	return 0;
}

• Bellman_Ford版本

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 510;
const int INF = 0x3fffffff;
struct node{
	int v, dis;
	node(int _v, int _dis) : v(_v), dis(_dis) {}
};
vector<int> Adj[MAXN];
int n, m, id1, id2;
int d[MAXN], w[MAXN], num[MAXN];
int weight[MAXN];
set<int> pre[MAXN];

void Bellman_Ford(int s){
	fill(d, d+MAXN, INF);
	memset(num, 0, sizeof(num));
	memset(w, 0, sizeof(w));
	d[s] = 0;
	w[s] = weight[s];
	num[s] = 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);
//这里为啥要清零，然后统计最短路径的条数，
//是因为在Bellman-Ford算法中hui反复统计算法的顶点，所以当遇见一条最短
//路径相同的时候，必须重新计算最短路径的数量
					num[v] = 0;
					for(auto it = pre[v].begin(); it != pre[v].end(); it++){
						num[v] += num[*it];
					}
				}
			} 
		}
	}
}
int main(){
	scanf("%d%d%d%d", &n, &m, &id1, &id2);
	for(int i = 0; i < n; i++){
		scanf("%d", &weight[i]);
	}
	int u, v, wt;
	for(int i = 0; i < m; i++){
		scanf("%d%d%d", &u, &v, &wt);
		Adj[u].push_back(node(v, wt));
		Adj[v].push_back(node(u, wt));
	}
	Bellman_Ford(id1);
	printf("%d %d", num[id2], w[id2]);
	return 0;
}