USACO Riding The Fences 与欧拉路径问题

简单的看，图的路径算法可以分两类：

1. 可达性寻问题：找到一条满足某种条件的路径，如图的连通性问题（简单路径算法），欧拉路径，汉密顿路径等等；
2. 含权图的最优化问题：如点对间的最短路径，欧几里德网；

而一切和图有关的算法，几乎都是DFS和BFS，这两家伙乍一看浓眉大眼的。他们所反映的，是计算机中的逻辑性与次序性，世界纷繁复杂，DFS与BFS是探索这些杂乱无章的一种逻辑很清晰、次序性很明显的思维方式。我当时学习图的时候，第一感觉就是乱糟糟恶心的一拖东西堆着，哪像树呢？多好看？为什么好看呢？因为好理解，不断的分叉下去，是吧，规律性很明显！在Wikipedia上找到了两张图，可以很好的说明思维的次序性问题：

好了，回到fence问题上来，欧拉路径的存在性问题已经有了结论了，请见Robert Sedgewick的《Algorithms in C++》，结论是这样的：

• 对于一个无向图，如果它每个点的度都是偶数，那么它存在一条欧拉回路；
• 如果有且仅有2个点的度为奇数，那么它存在一条欧拉路；
• 如果超过2个点的度为奇数，那么它就不存在欧拉路了。

找出欧拉路的方法就是采用DFS的方式，对于当前的点，把所有点从小到大的搜索，找到和它相连的，找到一个之后删除它们之间的连线，并去搜索新的那个点，如果没有找到点和它相连，那么就把这个点加入输出队列。

以上就是这个题的主题思路了，但是仅仅这么做会超时的。前面说：“世界纷繁复杂，DFS与BFS是探索这些杂乱无章的一种逻辑很清晰、次序性很明显的思维方式”，现在，有了这个思维的主线条了，接下来就是挖掘其中的细节，也就是剪枝。太多的剪枝我也没发现很多，不过有一点是，前面我们说，“找到和它相连的，找到一个之后删除它们之间的连线”，这里是会产生一个问题的，那就是有可能删除了一些要命的边，使得图不连通了：

像上面的，中间那个黄点点挂了，要是左或右还没走完，整个图怎么都走不出一条欧拉回路了。当然图画的有点丑，呵呵~

所以这里又有些考察基础了。Robert的书里有过几个概念：

割点：若一个点删除后（也就是与之相连的边统统去掉），无向图不再连通，那么此点称为割点。
桥：若一条边断去后，无向图不再连通，那么此边称为桥。桥有一个很好的性质，就是DFS一个无向图，那么这个过程必定要经过桥。
块：没有割点的无向图称为2-连通分支，也称作块。

现在应该比较清楚了，也就是说，在进行DFS搜索前，可以先用FloodFill灌水算法判断一下图的连通性，FloodFill算是OIer菜谱上的算法了吧，所以还是基础啊。。。

BTW，FloodFill不一定就是递归的，下面的代码中用的就是一个循环。

1. /*
2. ID:fairyroad
3. LANG:C++
4. TASK:fence
5. */
6. #include <fstream>
7. #include <vector>
8. #include <cstring>
9. using namespace std;
10.  
11. ifstream fin("fence.in");
12. ofstream fout("fence.out");
13.  
14. const int MAX = 505;
15. int edge[MAX][MAX];
16. int nodeCnt[MAX];
17. bool visited[MAX];
18. int F;
19.  
20. vector<int> ans;
21.  
22. bool floodFill(int node)
23. {
24.     memset(visited, 0, sizeof(visited));
25.     visited[node] = true;
26.  
27.     vector<int> Q;
28.     Q.push_back(node);
29.  
30.     while(!Q.empty())
31.     {
32.         node = Q.back();
33.         Q.pop_back();
34.         for (int i = 0; i < MAX; ++i)
35.         {
36.             if(edge[node][i] && !visited[i])
37.             {
38.                 Q.push_back(i);
39.                 visited[i] = true;
40.             }
41.         }
42.     }
43.  
44.     for (int i = 1; i < MAX; ++i)
45.     {
46.         if (!visited[i] && nodeCnt[i])
47.         {
48.             return false;
49.         }
50.     }
51.  
52.     return true;
53. }
54.  
55. bool dfs(int curr)
56. {
57.     if((int)ans.size() == F+1)
58.     {
59.         for(size_t i = 0; i < ans.size(); ++i)
60.             fout << ans[i] << endl;
61.         //exit(0);
62.         return true;
63.     }
64.  
65.     if(!floodFill(curr))
66.         return false;
67.  
68.     for(int i = 1; i < MAX; ++i)
69.     {
70.         if(edge[curr][i])
71.         {
72.             ans.push_back(i);
73.             --edge[curr][i]; --edge[i][curr];
74.             --nodeCnt[curr]; --nodeCnt[i];
75.  
76.             if(dfs(i))
77.                 return true;
78.  
79.             ans.pop_back();
80.             ++edge[curr][i]; ++edge[i][curr];
81.             ++nodeCnt[curr]; ++nodeCnt[i];
82.         }
83.     }
84.  
85.     return false;
86. }
87.  
88. int main()
89. {
90.     fin >> F;
91.     int i, v1, v2;
92.     for(i = 0; i < F; ++i)
93.     {
94.         fin >> v1 >> v2;
95.         ++edge[v1][v2]; ++edge[v2][v1];
96.         ++nodeCnt[v1]; ++nodeCnt[v2];
97.     }
98.  
99.     int start = -1, oddNode = 0;
100.     for(int i = 0; i < MAX; ++i)
101.     {
102.         if(nodeCnt[i] & 0x1u)
103.         {
104.             ++oddNode;
105.             if(start == -1) start = i;
106.         }
107.     }
108.  
109.     if(oddNode != 2) // 题目保证了有解
110.         start = 1;
111.  
112.     ans.push_back(start);
113.     dfs(start);
114.  
115.     return 0;
116. }