ZOJ-1053 FDNY to the Rescue!

FDNY to the Rescue!

---

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

The Fire Department of New York (FDNY) has always been proud of their response time to fires in New York City, but they want to make their response time even better. To help them with their response time, they want to make sure that the dispatchers know the closest firehouse to any address in the city. You have been hired to write this software and are entrusted with maintaining the proud tradition of FDNY. Conceptually, the software will be given the address of the fire, the locations of the firehouses, street intersections, and the time it takes to cover the distance between each intersection. It will then use this information to calculate how long it takes to reach an address from each firehouse.

Given a specific fire location in the city, the software will calculate the time taken from all the fire stations located in the city to reach the fire location. The list of fire stations will be sorted from shortest time to longest time. The dispatcher can then pick the closest firestation with available firefighters and equipment to dispatch to the fire.

Input Format:

Line 1:
# of intersections in the city, a single integer (henceforth referred to as N) N<20

Lines 2 to N+1:
A table (square matrix of integer values separated by one or more spaces) representing the time taken in minutes between every pair of intersections in the city. In the sample input shown below the value "3" on the 1st row and the 2nd column represents the time taken from intersection #1 to reach intersection #2.

Similarly the value "9" on the 4th row and the 2nd column represents the time taken from intersection #4 to reach intersection #2.

A value of -1 for time means that it is not possible to go directly from the origin intersection (row #) to the destination intersection (column #). All other values in the table are non-negative.

Line N+2:
An integer value n (<= N) indicating the intersection closest to the fire location followed by one or more integer values for the intersections closest to the fire stations (all on one line, separated by one or more spaces) will follow the input matrix.

Notes on input format:

1. The rows and columns are numbered from 1 to N.
2. All input values are integers
3. All fire locations are guaranteed reachable from all firehouses.
4. All distance calculations are made from the intersection closest to each firehouse to the intersection closest to the fire.

Output Format:

Line 1:
A label line with the headings for each column, exactly as shown in the example.

Line 2 onwards (one line for each fire station):
A sorted list (based on time) showing the fire station (origin), the destination site, time taken and a complete shortest path of nodes from the originating fire station to the fire location.

Notes on output format:
1. Columns are tab separated.
2. If two or more firehouses are tied in time they can be printed in any order.
3. If more than one path exists that has the same minimal time for a given location & firehouse, either one can be printed on the output.
4. If the fire location and the fire station locations happen to be the same intersection, the output will indicate that the origin and destination have the same intersection number, the time will be "0" and the nodes in the shortest path will show just one number, the fire location.

This problem contains multiple test cases!

The first line of a multiple input is an integer N, then a blank line followed by N input blocks. Each input block is in the format indicated in the problem description. There is a blank line between input blocks.

The output format consists of N output blocks. There is a blank line between output blocks.

 

Sample Input:

1

6
0 3 4 -1 -1 -1
-1 0 4 5 -1 -1
2 3 0 -1 -1 2
8 9 5 0 1 -1
7 2 1 -1 0 -1
5 -1 4 5 4 0
2 4 5 6

In the above input the last line indicates that "2" is the location of the fire and "4", "5" and "6" are the intersections where fire stations are located.

Sample Output:

Org     Dest    Time    Path
5       2       2       5       2
4       2       3       4       5       2
6       2       6       6       5       2

————————————————————集训11.4的分割线————————————————————

前言：血坑！POJ上居然改成了单组数据，调试了好几小时才发现……懒省事儿看书上的中文题必然吃大亏，已经不止一次了。ZOJ上是多组，POJ过了之后，ZOJ怎么也过不了。后来发现，测试数据里面有很多制！表！符！！sscanf的WA到死吧。

思路：建图需要一个技巧。因为路只要从消防站到达着火点即可，不需要着火点也能到达消防站，因此着火点是终点。但是，多起点就要跑很多次Dijkstra。因此反向建图。从着火点，单源最短路。这样一来，路径的输出也很简便，不需要倒走迷宫了，正向就是反向。

P.S. 然后这题就是考你输入输出了。输入一行数，不知道有几个数，这之间还有空格、制表符，怎么办？先用gets()，因为它结束条件仅有遇到'\n'，然后对这个字符串模拟一下，isdigit()判断是不是数字，是的话就累加到不是为止。

代码如下：

/*
ID: j.sure.1
PROG:
LANG: C++
*/
/****************************************/
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <stack>
#include <queue>
#include <vector>
#include <map>
#include <string>
#include <iostream>
#define INF 0x3f3f3f3f
using namespace std;
/****************************************/
const int N = 25;
int n, G[N][N], dis[N], fa[N], st, ed[N];
bool vis[N];

void Dijkstra(int st)
{
	memset(vis, 0, sizeof(vis));
	memset(dis, 0x3f, sizeof(dis));
	dis[st] = 0;
	for(int i = 1; i < n; i++) {
		int mini = INF, cur;
		for(int k = 0; k < n; k++) if(!vis[k]) {
			if(mini > dis[k]) {
				mini = dis[k];
				cur = k;
			}
		}
		vis[cur] = true;
		for(int k = 0; k < n; k++) if(!vis[k]) {
			if(dis[k] > G[cur][k] + dis[cur]) {
				fa[k] = cur;
				dis[k] = G[cur][k] + dis[cur];
			}
		}
	}
}

bool cmp(const int i, const int j)
{
	return dis[i] < dis[j];//间接排序
}

int main()
{
#ifdef J_Sure
	freopen("222.in", "r", stdin);
//  freopen(".out", "w", stdout);
#endif
	int T;
	bool fir = false;
	scanf("%d", &T);
	while(T--) {
		memset(fa, -1, sizeof(fa));
		scanf("%d", &n);
		int w;
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				scanf("%d", &w);//技巧：反向建图
				G[j][i] = w;
				if(w == -1)
					G[j][i] = INF;
			}
		}
		scanf("%d", &st); st--;
		int cnt = 0, b;	
		char number[20];
		gets(number);
		int len = strlen(number);
		for(int i = 0; i < len; i++) {
			while(!isdigit(number[i])) i++;
			b = 0;
			while(isdigit(number[i]) && i < len) {
				b += b*10 + (number[i] - '0');
				i++;
			}
			b--;
			ed[cnt++] = b;
		}//烦人的输入
		fa[st] = st;
		Dijkstra(st);
		sort(ed, ed+cnt, cmp);
		if(fir) puts(""); fir = true;
		printf("Org\tDest\tTime\tPath\n");
		for(int i = 0; i < cnt; i++) {
			printf("%d\t%d\t%d\t", ed[i]+1, st+1, dis[ed[i]]);
			int x = ed[i], nn = 0;
			while(x != fa[x]) {
				printf("%d\t", x+1);
				x = fa[x];
			}
			printf("%d\n", st+1);
		}
	}
    return 0;
}