UVa 208 Firetruck

Firetruck

The Center City fire department collaborates with the transportation department to maintain maps of the city which reflects the current status of the city streets. On any given day, several streets are closed for repairs or construction. Firefighters need to be able to select routes from the firestations to fires that do not use closed streets.

Central City is divided into non-overlapping fire districts, each containing a single firestation. When a fire is reported, a central dispatcher alerts the firestation of the district where the fire is located and gives a list of possible routes from the firestation to the fire. You must write a program that the central dispatcher can use to generate routes from the district firestations to the fires.

Input

The city has a separate map for each fire district. Streetcorners of each map are identified by positive integers less than 21, with the firestation always on corner #1. The input file contains several test cases representing different fires in different districts.

• The first line of a test case consists of a single integer which is the number of the streetcorner closest to the fire.
• The next several lines consist of pairs of positive integers separated by blanks which are the adjacent streetcorners of open streets. (For example, if the pair 4 7 is on a line in the file, then the street between streetcorners 4 and 7 is open. There are no other streetcorners between 4 and 7 on that section of the street.)
• The final line of each test case consists of a pair of 0's.

Output

For each test case, your output must identify the case by number (CASE #1, CASE #2, etc). It must list each route on a separate line, with the streetcorners written in the order in which they appear on the route. And it must give the total number routes from firestation to the fire. Include only routes which do not pass through any streetcorner more than once. (For obvious reasons, the fire department doesn't want its trucks driving around in circles.)

Output from separate cases must appear on separate lines.

The following sample input and corresponding correct output represents two test cases.

Sample Input

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

Sample Output

CASE 1:
1 2 3 4 6
1 2 3 5 6
1 2 4 3 5 6
1 2 4 6
1 3 2 4 6
1 3 4 6
1 3 5 6
There are 7 routes from the firestation to streetcorner 6.
CASE 2:
1 3 2 5 7 8 9 6 4
1 3 4
1 5 2 3 4
1 5 7 8 9 6 4
1 6 4
1 6 9 8 7 5 2 3 4
1 8 7 5 2 3 4
1 8 9 6 4
There are 8 routes from the firestation to streetcorner 4.

#include 
#include 
#include 
#include 
#include 
using namespace std;
// visit[i] = 1 代表该节点被访问过
// visit[i] = 0 代表该节点未被访问过
int visit[25];

// next[i]代表和i街区相连的街区
vector next[25];

// 代表此次路径
int path[25];

// 此次路径长度
int path_length;

// 总共路径个数
int path_count;

// 终点路径街区
int target;

// 街区总数
int street_count;

void dfs_search(int x);

int main()
{
	int g_count = 1;
	while(scanf("%d", &target) == 1)
	{
		// 读入各个街区情况
		memset(visit, 0, sizeof(visit));
		path_count = 0;
		street_count = 0;
		for(int i = 0; i < 25; i++)
			next[i] = vector();

		int x, y;
		while(scanf("%d %d", &x, &y) == 2 && !(x == 0 && y == 0))
		{
			next[x].push_back(y);
			next[y].push_back(x);
			if(x > street_count)
				street_count = x;
			if(y > street_count)
				street_count = y;
		}		

		for(int i = 0; i < street_count; i++)
			sort(next[i].begin(), next[i].end());
		
		// 宽度优先搜索
		queue my_queue;
		visit[1] = 1;
		my_queue.push(1);
		int find_flag = 0;
		while(my_queue.size() > 0)
		{
			int x = my_queue.front();
			my_queue.pop();
			if(x == target)
			{
				find_flag = 1;
				break;
			}
			for(int i = 0; i < next[x].size(); i++)
			{
				if(visit[next[x][i]] == 0)
				{
					my_queue.push(next[x][i]);
					visit[next[x][i]] = 1;
				}
			}
		}	
		if(find_flag == 0)
		{
			printf("CASE %d:\n", g_count);
			printf("There are 0 routes from the firestation to streetcorner %d.\n", target);
			g_count++;
			continue;
		}
		memset(visit, 0, sizeof(visit));	
		// 深度优先搜索来遍历出所有路径
		path[0] = 1;
		visit[1] = 1;
		path_length = 1;
		printf("CASE %d:\n", g_count);
		dfs_search(1);
		printf("There are %d routes from the firestation to streetcorner %d.\n", path_count, target);	
		g_count++;
	}	
	return 0;	
}

// 深度优先搜索来遍历出所有路径
// x为当前所访问的节点
void dfs_search(int x)
{
	// 如果遍历到终点节点，打印路径
	if(x == target)
	{
		for(int i = 0; i < path_length; i++)
		{
			if(i == 0)
				printf("%d", path[i]);
			else
				printf(" %d", path[i]);
		}	
		printf("\n");	
		path_count++;
		return;
	}	

	// 否则检查该节点的所有相连节点，可能的话进行遍历
	for(int i = 0; i < next[x].size(); i++)
	{
		if(visit[next[x][i]] == 0)
		{
			visit[next[x][i]] = 1;
			path[path_length] = next[x][i];
			path_length++;
			dfs_search(next[x][i]);
			path_length--;
			visit[next[x][i]] = 0;	
		}	
	}		
		
}

一开始写了个DFS，然后超时了。

感觉这个题目有点坑，不过也提供了一个思路。

如果起始点到终止点之间不连通，就不需要DFS来寻找路径了。

首先从起始点BFS判断是否能到达终止点，如果可以，再用DFS寻找所有路径。