nyoj 20 吝啬的国度



    

NYOJ 20 吝啬的国度 续

分类： 图论 2012-07-06 18:42 1057人阅读 评论(0)收藏举报

还是《吝啬的国度》，研读了别人的较为高效的代码，无论是时间开销，还是空间开销都要小很多啊，截图为证：

我的所有运行：

52ms的是我参照别人的写的代码，时间开销比我的小将近一半，内存开销仅有我的五分之一。

不过，我自己又将他的改进了一下，虽然内存稍稍大了点，但时间开销为40ms，排名第一啊，哈哈！

WrongAnswer那次是因为忘了在递归中标记start，RuntimeError那次是为了调试时查看数组内容，就把数组开了100，结果调试完忘了改回来，直接提交了，数组越界，唉...

题目中要求从起始城市出发，输出经过每个城市时，之前的那个城市的编号。这样，相邻两个城市之间的关系实质上已经表示出来了，也就是说，存放之前城市编号的那个数组，存储了一个有向图，如下图所示：

输入的测试数据为：

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>  
3.   
4. int map[100005];  
5.   
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. }  
15.   
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. }  

#include <stdio.h>#include <memory.h>int map[100005];void Adjust(int currentCity){int priorCity = map[currentCity];if (priorCity != 0){Adjust(priorCity);map[priorCity] = currentCity;}}int main(){int i, testNum, cityNum, startCity, cityA, cityB;scanf("%d", &testNum);while (testNum-- != 0){scanf("%d%d", &cityNum, &startCity);memset(map, 0, sizeof(int)*cityNum + 1);for (i = 1; i < cityNum; i++){scanf("%d%d", &cityA, &cityB);if (map[cityB] == 0){map[cityB] = cityA;}else{Adjust(cityA);map[cityA] = cityB;}}Adjust(startCity);map[startCity] = - 1;for (i = 1; i < cityNum; i++){printf("%d ", map[i]);}printf("%d\n", map[i]);}return 0;}

---

思路(二)是我自己的，因为我发现不考虑方向建立图时，会出现方向的多次调整，影响效率，所以我就想在建立图的过程中就考虑方向，代码如下：

[cpp] view plaincopyprint?

1. #include <stdio.h>  
2. #include <memory.h>  
3.   
4. int map[100005];  
5. bool flag[100005];  
6.   
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. }  
17.   
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. }  
27.   
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. }