吝啬的国度

来源：互联网发布：java 应用系统界面编辑：程序博客网时间：2024/04/28 07:32

吝啬的国度

时间限制：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）

样例输入

110 11 91 88 1010 38 61 210 49 53 7

样例输出

-1 1 10 10 9 8 3 1 1 8

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

[cpp] view plaincopyprint?

#include <stdio.h>
struct node
{
int num;
node *next;
};
struct data_type
{
int priorCity;
node *linkedCity;
}map[100005];
void MyDelete(int cityNum)
{
int i;
node *p, *q;
for (i = 1; i <= cityNum; i++)
{
p = map[i].linkedCity;
while (p != NULL)
{
q = p->next;
delete p;
p = q;
}
}
}
void Travel(int currentCity, int priorCity)
{
map[currentCity].priorCity = priorCity;
node *linkedCity = map[currentCity].linkedCity;
while (linkedCity != NULL)
{
if (map[linkedCity->num].priorCity == 0)
{
Travel(linkedCity->num, currentCity);
}
linkedCity = linkedCity->next;
}
}
int main()
{
int i, testNum, cityNum, startCity, cityA, cityB;
node *p;
scanf("%d", &testNum);
while (testNum-- != 0)
{
scanf("%d%d", &cityNum, &startCity);
for (i = 0; i <= cityNum; i++)
{
map[i].priorCity = 0;
map[i].linkedCity = NULL;
}
for (i = 1; i < cityNum; i++)
{
scanf("%d%d", &cityA, &cityB);
p = new node;
p->num = cityB;
p->next = map[cityA].linkedCity;
map[cityA].linkedCity = p;
p = new node;
p->num = cityA;
p->next = map[cityB].linkedCity;
map[cityB].linkedCity = p;
}
Travel(startCity, -1);
for (i = 1; i < cityNum; i++)
{
printf("%d ", map[i].priorCity);
}
printf("%d\n", map[i].priorCity);
MyDelete(cityNum);
}
return 0;
}

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

例如输入的测试数据为：

10 1

8 10

10 3

3 7

10 4

1 9

1 8

8 6

1 2

9 5

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

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

[cpp] view plaincopyprint?

#include <stdio.h>
struct node
{
int num;
node *next;
};
struct data_type
{
int priorCity;
bool start;
node *linkedCity;
}map[100005];
void InitMap(int cityNum, int startCity)
{
int i;
for (i = 0; i <= cityNum; i++)
{
map[i].priorCity = 0;
map[i].start = false;
map[i].linkedCity = NULL;
}
map[startCity].start = true;
map[startCity].priorCity = -1;
}
void MyDelete(int cityNum)
{
int i;
node *p, *q;
for (i = 1; i <= cityNum; i++)
{
p = map[i].linkedCity;
while (p != NULL)
{
q = p->next;
delete p;
p = q;
}
}
}
void Travel(int currentCity, int priorCity)
{
map[currentCity].priorCity = priorCity;
map[currentCity].start = true;
node *linkedCity = map[currentCity].linkedCity;
while (linkedCity != NULL)
{
if (map[linkedCity->num].priorCity == 0)
{
Travel(linkedCity->num, currentCity);
}
linkedCity = linkedCity->next;
}
}
int main()
{
int i, testNum, cityNum, startCity, cityA, cityB;
node *p;
scanf("%d", &testNum);
while (testNum-- != 0)
{
scanf("%d%d", &cityNum, &startCity);
InitMap(cityNum, startCity);
for (i = 1; i < cityNum; i++)
{
scanf("%d%d", &cityA, &cityB);
if (map[cityA].start)
{
if (map[cityB].linkedCity != NULL)
{
Travel(cityB, cityA);
}
else
{
map[cityB].priorCity = cityA;
map[cityB].start = true;
}
}
else if (map[cityB].start)
{
if (map[cityA].linkedCity != NULL)
{
Travel(cityA, cityB);
}
else
{
map[cityA].priorCity = cityB;
map[cityA].start = true;
}
}
else
{
p = new node;
p->num = cityB;
p->next = map[cityA].linkedCity;
map[cityA].linkedCity = p;
p = new node;
p->num = cityA;
p->next = map[cityB].linkedCity;
map[cityB].linkedCity = p;
}
}
for (i = 1; i < cityNum; i++)
{
printf("%d ", map[i].priorCity);
}
printf("%d\n", map[i].priorCity);
MyDelete(cityNum);
}
return 0;
}

深度搜索时采用非递归函数：

[cpp] view plaincopyprint?

struct
{
int currentNum;
int priorNum;
}stack[100005], *base = NULL, *top = NULL;
void Travel(int currentCity, int priorCity)
{
node *linkedCity = NULL;
base = top = stack;
top->currentNum = currentCity;
top->priorNum = priorCity;
top++;
while (base != top)
{
currentCity = (--top)->currentNum;
priorCity = top->priorNum;
map[currentCity].priorCity = priorCity;
map[currentCity].start = true;
linkedCity = map[currentCity].linkedCity;
while (linkedCity != NULL)
{
if (map[linkedCity->num].priorCity == 0)
{
top->currentNum = linkedCity->num;
top->priorNum = currentCity;
top++;
}
linkedCity = linkedCity->next;
}
}
}
题目中要求从起始城市出发，输出经过每个城市时，之前的那个城市的编号。这样，相邻两个城市之间的关系实质上已经表示出来了，也就是说，存放之前城市编号的那个数组，存储了一个有向图，如下图所示：
输入的测试数据为：
10 1
8 10
10 3
3 7
10 4
1 9
1 8
8 6
1 2
9 5
红色箭头建立的的图，即为数组中存放之前城市编号所建立的有向图。
按照这种思路建立有向图，需要解决箭头方向的问题，即确定哪个城市离出发城市更近。这里有两种方法：
(一)，建图的过程中，不管箭头方向，在整个图建立完成之后，从出发城市开始调整箭头方向。
(二)，建图的过程中，根据出发城市的位置调整箭头方向，整个图建立完成时，也就是一个正确的有向图。
思路(一)也就是高人的思路，代码如下：
[cpp] view plaincopyprint?
1. #include <stdio.h>
2. #include <memory.h>
4. int map[100005];
6. void Adjust(int currentCity)
7. {
8. int priorCity = map[currentCity];
9. if (priorCity != 0)
10. {
11. Adjust(priorCity);
12. map[priorCity] = currentCity;
13. }
14. }
16. int main()
17. {
18. int i, testNum, cityNum, startCity, cityA, cityB;
19. scanf("%d", &testNum);
20. while (testNum-- != 0)
21. {
22. scanf("%d%d", &cityNum, &startCity);
23. memset(map, 0, sizeof(int)*cityNum + 1);
24. for (i = 1; i < cityNum; i++)
25. {
26. scanf("%d%d", &cityA, &cityB);
27. if (map[cityB] == 0)
28. {
29. map[cityB] = cityA;
30. }
31. else
32. {
33. Adjust(cityA);
34. map[cityA] = cityB;
35. }
36. }
37. Adjust(startCity);
38. map[startCity] = - 1;
39. for (i = 1; i < cityNum; i++)
40. {
41. printf("%d ", map[i]);
42. }
43. printf("%d\n", map[i]);
44. }
45. return 0;
46. }
思路(二)是我自己的，因为我发现不考虑方向建立图时，会出现方向的多次调整，影响效率，所以我就想在建立图的过程中就考虑方向，代码如下：
[cpp] view plaincopyprint?
1. #include <stdio.h>
2. #include <memory.h>
4. int map[100005];
5. bool flag[100005];
7. void AdjustIncludeStart(int currentCity)
8. {
9. int priorCity = map[currentCity];
10. if (priorCity != 0)
11. {
12. AdjustIncludeStart(priorCity);
13. map[priorCity] = currentCity;
14. flag[priorCity] = true;
15. }
16. }
18. void AdjustExcludeStart(int currentCity)
19. {
20. int priorCity = map[currentCity];
21. if (priorCity != 0)
22. {
23. AdjustExcludeStart(priorCity);
24. map[priorCity] = currentCity;
25. }
26. }
28. int main()
29. {
30. int i, testNum, cityNum, startCity, cityA, cityB;
31. scanf("%d", &testNum);
32. while (testNum-- != 0)
33. {
34. scanf("%d%d", &cityNum, &startCity);
35. memset(map, 0, sizeof(int)*cityNum + 1);
36. memset(flag, false, sizeof(bool)*cityNum + 1);
37. map[startCity] = - 1;
38. flag[startCity] = true;
39. for (i = 1; i < cityNum; i++)
40. {
41. scanf("%d%d", &cityA, &cityB);
42. if (flag[cityA])
43. {
44. if (map[cityB] != 0)
45. {
46. AdjustIncludeStart(cityB);
47. }
48. map[cityB] = cityA;
49. flag[cityB] = true;
50. }
51. else if (flag[cityB])
52. {
53. if (map[cityA] != 0)
54. {
55. AdjustIncludeStart(cityA);
56. }
57. map[cityA] = cityB;
58. flag[cityA] = true;
59. }
60. else
61. {
62. if (map[cityB] == 0)
63. {
64. map[cityB] = cityA;
65. }
66. else
67. {
68. AdjustExcludeStart(cityA);
69. map[cityA] = cityB;
70. }
71. }
72. }
73. for (i = 1; i < cityNum; i++)
74. {
75. printf("%d ", map[i]);
76. }
77. printf("%d\n", map[i]);
78. }
79. return 0;
80. }