UVA208—— Firetruck【DFS + 并查集】

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.

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.

题目大意：从起点1到给定的终点n为一共有多少条路可以走，并且按照字典序的大小输出。

大致思路：最开始看到这道题时以为就是简单的DFS搜索一下就可以了，然后就超时了。其实这道题科已优化一下，我们把已经不可能到达的店标记一下，在搜索的时候就不在访问这些点，这样优化过后就可以过了。那么我们怎么知道这些点是否可以到达终点呢？我们可以用并查集在输入图的时候处理一下就可以了，把所有与起点相连的店都归为一类就行了。

#include <bits/stdc++.h>
using namespace std;

int target;
int maze[22][22];
int ans[1000010];
bool vis[22];
int cnt;
int pre[22];

void init(){
	for(int i = 1; i <= 21; i++)
		pre[i] = i;
}

inline int find(int x){
	if(x == pre[x]) return pre[x];
	else{
		pre[x] = find(pre[x]);
		return pre[x];
	}
}

inline void join(int x,int y){
	int fx = find(x),fy = find(y);
	if(fx != fy){
		pre[fx] = fy;
	}
}

void DFS(int st,int d){
	if(st == target){
		cnt++;
		for(int i = 0; i < d - 1; i++)
			printf("%d ",ans[i]);
		printf("%d\n",ans[d - 1]);
		return;
	}
	for(int i = 1 ; i <= 21; i++){
		if(!vis[i] && maze[st][i]){
			ans[d] = i;
			vis[i] = 1;
			DFS(i,d + 1);
			vis[i] = 0;
		}
	}
}

int main(int argc, char const *argv[])
{
	int kase = 0;
	while(~scanf("%d",&target)){
		int to,next;
		cnt = 0;
		init();
		memset(maze,0,sizeof(maze));
		while(~scanf("%d %d",&to,&next)){
            if(to == 0 && next == 0) break;
			maze[to][next] = 1;
			maze[next][to] = 1;
			if(find(to) != find(next)){
				join(to,next);
			}
		}
		memset(vis,0,sizeof(vis));
		vis[1] = 1;
		for(int i = 1; i <= 21; i++){
			if(find(i) != find(target)) vis[i] = 1;
		}
		printf("CASE %d:\n",++kase);
		ans[0] = 1;
		DFS(1,1);
		printf("There are %d routes from the firestation to streetcorner %d.\n",cnt,target);
	}
	return 0;
}