【再认真理解】1003. Emergency (25) Dijastra最优路径算法修改版求解

1003. Emergency (25)

时间限制

400 ms

内存限制

65536 kB

代码长度限制

16000 B

判题程序

Standard

作者

CHEN, Yue

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

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, C1 and C2 - 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 c1, c2 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 C1 to C2.

Output

For each test case, print in one line two numbers: the number of different shortest paths between C1 and C2, 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

这个题要用图论的相关算法求解，一开始看到这题就晕了，反复看了网上的讲解，大部分人用 Dijastra最优路径算法求解，有的也用DFS遍历方式求解。

特别说明，题目要求的不是最短路径，而是最短路径的数量和能获得的最大救援队伍的数量。这题对于我来说，难度绝对是五星，做了三天，才勉强把它整明白，从 Dijastra算法思想到对应于这个题的解法。有空还需要再好好思考这个题。很好的一道题

#include<vector>
#include <sstream>
#include<cmath>
#include<iomanip>
#include<iostream>
#include <ctype.h>
#include <stdlib.h>
#include <algorithm>

using namespace std;


const int MAX_required = 505;
const int Max_int = 0x7fffffff;
int map[MAX_required][MAX_required];
int callnum[MAX_required];


struct  CITY
{
	int dist;
	bool visited;
	int number;
	int call;
}city[MAX_required];//新建数组，存放类型为CITY，当中包含了该结点至源节点的最短距离，是否被访问过，最短路径数量，求援队伍数量


void Dijkstra(int start, int end,int n)
{
	
	for (int i = 0; i < n; i++)//初始化所有的项
	{
		city[i].dist = Max_int;
		city[i].visited = 0;
		city[i].number = 0;
		city[i].call = 0;
	}


	city[start].dist = 0;
	city[start].number = 1;
	city[start].call = callnum[start];


	//求最短路径及其位置
	for (int cnt = 0; cnt < n; cnt++)//控制总共循环的次数
	{
		int Min = Max_int, pos = -1;//min记录最小路径，pos记录下一个访问结点的标记


		//找到最短距离，以及对应下标，作为下一次的起始节点
		for (int i = 0; i < n; i++)
		{
			if ((city[i].visited == 0) && (city[i].dist < Min))
			{
				Min = city[i].dist;
				pos = i;
			}
		}


		if (pos == -1)
			break;


		city[pos].visited = 1;


		//根据下一个结点在矩阵中对应的值，调整结点到原点距离的最小值和对应的救援团队数量
		for (int j = 0; j < n; j++)
		{
			if ((city[j].visited == 0) && (map[pos][j] != Max_int))
			{
				if (city[j].dist>city[pos].dist + map[pos][j])
				{
					city[j].dist = city[pos].dist + map[pos][j];
					city[j].number = city[pos].number;
					city[j].call = city[pos].call+callnum[j];
				}
				else if (city[j].dist==(city[pos].dist + map[pos][j]))
				{
					city[j].number += city[pos].number;
					if (city[j].call < city[pos].call + callnum[j])
						city[j].call = city[pos].call + callnum[j];
				}
			}
		}
	}


	cout << city[end].number << " " << city[end].call;
}


int main()
{
		int n, m, start, end;
	
		cin >> n >> m >> start >> end;
		int i;
		for (i = 0; i<n; i++)//输入每个城市救援队数目
			cin >> callnum[i];
		int a, b, l;	
		for (int i = 0; i < n; i++)
		{
			for (int j = 0; j < n; j++)
			{
				map[i][j] = Max_int;
			}
		}
		for (i = 0; i<m; i++)//输入城市间距离
		{
			cin >> a >> b >> l;
			map[a][b] = l;
			map[b][a] = l;
		}


		//调试使用
		//int n = 6, m = 9;
		//int start = 0, end = 4;
		//int number_of_team_in_city[6] = { 3, 2, 1, 3, 3, 4 };
		//int map[6][6] = {
		//	{ MAX_required, 7, 9, MAX_required, MAX_required, 14 },
		//	{ 7, MAX_required, 10, 15, MAX_required, MAX_required },
		//	{ 9, 10, MAX_required, 11, MAX_required, 2 },
		//	{ MAX_required, 15, 11, MAX_required, 6, MAX_required },
		//	{ MAX_required, MAX_required, MAX_required, 6, MAX_required, 9 },
		//	{ 14, MAX_required, 2, MAX_required, 9, MAX_required }
		//};


		Dijkstra(start, end, n);


		return 0;
}

【参考代码】http://www.cnblogs.com/echobfy/p/3545917.html