nyoj 吝啬的国度 http://blog.csdn.net/code_pang/article/details/7719221

2012-07-05 16:47  1659人阅读  评论(0)  收藏  举报

吝啬的国度

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 3

描述

在一个吝啬的国度里有N个城市，这N个城市间只有N-1条路把这个N个城市连接起来。现在，Tom在第S号城市，他有张该国地图，他想知道如果自己要去参观第T号城市，必须经过的前一个城市是几号城市（假设你不走重复的路）。

输入

第一行输入一个整数M表示测试数据共有M(1<=M<=5)组
每组测试数据的第一行输入一个正整数N(1<=N<=100000)和一个正整数S(1<=S<=100000)，N表示城市的总个数，S表示参观者所在城市的编号
随后的N-1行，每行有两个正整数a,b(1<=a,b<=N)，表示第a号城市和第b号城市之间有一条路连通。

输出

每组测试数据输N个正整数，其中，第i个数表示从S走到i号城市，必须要经过的上一个城市的编号。（其中i=S时，请输出-1）

样例输入

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

样例输出

-1 1 10 10 9 8 3 1 1 8

很明显，这个些城市和道路构成了一个极小连通子图，也就是生成树。而出发的城市S就相当于这棵树的树根，一种较易想到的解法就是从出发城市开始，对整个地图进行深度搜索，过程中记录下前一个城市的编号，如下，采用邻接表存储地图：

[cpp]  view plain copy print ?

1. #include <stdio.h>  
2.   
3. struct node  
4. {  
5.     int num;  
6.     node *next;  
7. };  
8.   
9. struct data_type  
10. {  
11.     int priorCity;  
12.     node *linkedCity;  
13. }map[100005];  
14.   
15. void MyDelete(int cityNum)  
16. {  
17.     int i;  
18.     node *p, *q;  
19.     for (i = 1; i <= cityNum; i++)  
20.     {  
21.         p = map[i].linkedCity;  
22.         while (p != NULL)  
23.         {  
24.             q = p->next;  
25.             delete p;  
26.             p = q;  
27.         }  
28.     }  
29. }  
30.   
31. void Travel(int currentCity, int priorCity)  
32. {  
33.     map[currentCity].priorCity = priorCity;  
34.     node *linkedCity = map[currentCity].linkedCity;  
35.     while (linkedCity != NULL)  
36.     {  
37.         if (map[linkedCity->num].priorCity == 0)  
38.         {  
39.             Travel(linkedCity->num, currentCity);  
40.         }  
41.         linkedCity = linkedCity->next;  
42.     }  
43. }  
44.   
45. int main()  
46. {  
47.     int i, testNum, cityNum, startCity, cityA, cityB;  
48.     node *p;  
49.     scanf("%d", &testNum);  
50.     while (testNum-- != 0)  
51.     {  
52.         scanf("%d%d", &cityNum, &startCity);  
53.         for (i = 0; i <= cityNum; i++)  
54.         {  
55.             map[i].priorCity = 0;  
56.             map[i].linkedCity = NULL;  
57.         }  
58.         for (i = 1; i < cityNum; i++)  
59.         {  
60.             scanf("%d%d", &cityA, &cityB);  
61.             p = new node;  
62.             p->num = cityB;  
63.             p->next = map[cityA].linkedCity;  
64.             map[cityA].linkedCity = p;  
65.             p = new node;  
66.             p->num = cityA;  
67.             p->next = map[cityB].linkedCity;  
68.             map[cityB].linkedCity = p;  
69.         }  
70.         Travel(startCity, -1);  
71.         for (i = 1; i < cityNum; i++)  
72.         {  
73.             printf("%d ", map[i].priorCity);  
74.         }  
75.         printf("%d\n", map[i].priorCity);  
76.         MyDelete(cityNum);  
77.     }  
78.     return 0;  
79. }  

上面的地图相当于一个无向图，而在深度搜索时，需要的只是一个以出发城市为中心，向四周辐射的有向图。改进算法是在输入数据的同时，就进行搜索地图，因为数据输入未完成，所以输入时得到的是一个子图，这个子图分两种情况，一种是子图中包含出发城市，子图是一个有向图，所以可以根据输入的两个城市哪一个离出发城市更近，确定结果；另一种子图中不包含出发城市，此时，无法确定哪个城市离出发城市更近，所以先用邻接表将这个无向子图存储起来，等到它与出发城市相连时，在对这个子图进行深度搜索。

例如输入的测试数据为：

10 1

8 10

10 3

3 7

10 4

1 9

1 8

8 6

1 2

9 5

则首先得到一个不包含出发城市的子图：

在输入数据1  8时之后，上面的子图与出发城市相连，图中红色方块代表出发城市，虚线箭头代表并未在邻接表中建立此联系：

[cpp]  view plain copy print ?

1. #include <stdio.h>  
2.   
3. struct node  
4. {  
5.     int num;  
6.     node *next;  
7. };  
8.   
9. struct data_type  
10. {  
11.     int priorCity;  
12.     bool start;  
13.     node *linkedCity;  
14. }map[100005];  
15.   
16. void InitMap(int cityNum, int startCity)  
17. {  
18.     int i;  
19.     for (i = 0; i <= cityNum; i++)  
20.     {  
21.         map[i].priorCity = 0;  
22.         map[i].start = false;  
23.         map[i].linkedCity = NULL;  
24.     }  
25.     map[startCity].start = true;  
26.     map[startCity].priorCity = -1;  
27. }  
28.   
29. void MyDelete(int cityNum)  
30. {  
31.     int i;  
32.     node *p, *q;  
33.     for (i = 1; i <= cityNum; i++)  
34.     {  
35.         p = map[i].linkedCity;  
36.         while (p != NULL)  
37.         {  
38.             q = p->next;  
39.             delete p;  
40.             p = q;  
41.         }  
42.     }  
43. }  
44.   
45. void Travel(int currentCity, int priorCity)  
46. {  
47.     map[currentCity].priorCity = priorCity;  
48.     map[currentCity].start = true;  
49.     node *linkedCity = map[currentCity].linkedCity;  
50.     while (linkedCity != NULL)  
51.     {  
52.         if (map[linkedCity->num].priorCity == 0)  
53.         {  
54.             Travel(linkedCity->num, currentCity);  
55.         }  
56.         linkedCity = linkedCity->next;  
57.     }  
58. }  
59.   
60. int main()  
61. {  
62.     int i, testNum, cityNum, startCity, cityA, cityB;  
63.     node *p;  
64.     scanf("%d", &testNum);  
65.     while (testNum-- != 0)  
66.     {  
67.         scanf("%d%d", &cityNum, &startCity);  
68.         InitMap(cityNum, startCity);  
69.         for (i = 1; i < cityNum; i++)  
70.         {  
71.             scanf("%d%d", &cityA, &cityB);  
72.             if (map[cityA].start)  
73.             {  
74.                 if (map[cityB].linkedCity != NULL)  
75.                 {  
76.                     Travel(cityB, cityA);  
77.                 }  
78.                 else  
79.                 {  
80.                     map[cityB].priorCity = cityA;  
81.                     map[cityB].start = true;  
82.                 }  
83.             }  
84.             else if (map[cityB].start)  
85.             {  
86.                   
87.                 if (map[cityA].linkedCity != NULL)  
88.                 {  
89.                     Travel(cityA, cityB);  
90.                 }  
91.                 else  
92.                 {  
93.                     map[cityA].priorCity = cityB;  
94.                     map[cityA].start = true;  
95.                 }  
96.             }  
97.             else  
98.             {  
99.                 p = new node;  
100.                 p->num = cityB;  
101.                 p->next = map[cityA].linkedCity;  
102.                 map[cityA].linkedCity = p;  
103.                 p = new node;  
104.                 p->num = cityA;  
105.                 p->next = map[cityB].linkedCity;  
106.                 map[cityB].linkedCity = p;  
107.             }  
108.         }  
109.         for (i = 1; i < cityNum; i++)  
110.         {  
111.             printf("%d ", map[i].priorCity);  
112.         }  
113.         printf("%d\n", map[i].priorCity);  
114.         MyDelete(cityNum);  
115.     }  
116.     return 0;  
117. }