Sicily1153-马的周游问题:启发式搜索

代码地址： https://github.com/laiy/Datastructure-Algorithm/blob/master/sicily/1153.c

题目如下：

1153. 马的周游问题

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB , Special Judge

Description

和题目C同样的任务，这里只是把棋盘扩大到标准的国际象棋。对这样一个8 * 8的棋盘用同样的方法编号如下：

1     2     3       4     5     6       7     8

9     10       11    12       13    14       15    16

17    18       19    20       21    22       23    24

25    26       27    28       29    30       31    32

33    34       35    36       37    38       39    40

41    42       43    44       45    46       47    48

49    50       51    52       53    54       55    56

57    58       59    60       61    62       63    64

Input

输入有若干行。每行一个整数N(1<=N<=64)，表示马的起点。最后一行用-1表示结束，不用处理。

Output

对输入的每一个起点，求一条周游线路。对应地输出一行，有64个整数，从起点开始按顺序给出马每次经过的棋盘方格的编号。相邻的数字用一个空格分开。

典型的搜索问题，1152数据规模较小，直接DFS就可以过，然而1153不行，以下为超时代码（>0.99s）：

 // Problem#: 1153
 // Submission#: 3914599
 // The source code is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
 // URI: http://creativecommons.org/licenses/by-nc-sa/3.0/
 // All Copyright reserved by Informatic Lab of Sun Yat-sen University
 #include <cstdio>
 #include <cstring>

 bool visited[][];
 int y_direction[] = {-, -, -, -, , , , };
 int x_direction[] = {-, , , -, , -, -, };
 int record[];
 bool found;

 inline bool is_valid(int x, int y) {
     return x >=  && x <  && y >=  && y < ;
 }

 inline int get_number(int x, int y) {
     return x *  + y + ;
 }

 void dfs(int x, int y, int step) {
     if (visited[x][y] || found)
         return;
     visited[x][y] = true;
     record[step] = get_number(x, y);
     if (step == ) {
         found = true;
         return;
     }
     int temp_x, temp_y;
     for (int i = ; i < ; i++) {
         temp_x = x + x_direction[i], temp_y = y + y_direction[i];
         if (is_valid(temp_x, temp_y) && !visited[temp_x][temp_y])
             dfs(temp_x, temp_y, step + );
     }
     visited[x][y] = false;
 }

 int main() {
     int n;
     while (scanf("%d", &n) && n != -) {
         found = false;
         memset(visited, , sizeof(visited));
         dfs((n - ) / , (n - ) % , );
         for (int i = ; i < ; i++)
             printf("%d ", record[i]);
         printf("%d\n", record[]);
     }
     return ;
 }

怎么优化？

答案是： 启发式搜索。

启发式搜索其实很简单，就是在DFS的时候正常情况下是按照固定的顺序对树的节点进行访问的（例如从左到右）。

而启发式搜索则是在DFS搜索的时候对树节点的访问加入一个贪心策略，让每次往下搜索的顺序是有策略性的，有启发性的。（这个贪心策略是为了指向最终的终点）。

那么在马周游问题里面怎么在DFS里面加入这个贪心策略使这个搜索更聪明呢？（更快找到终点）

之前Wansdorff在1823年给出了这个启发策略。

Warnsdorff's rule

Warnsdorf's rule is a heuristic for finding a knight's tour. We move the knight so that we always proceed to the square from which the knight will have the fewest onward moves. When calculating the number of onward moves for each candidate square, we do not count moves that revisit any square already visited. It is, of course, possible to have two or more choices for which the number of onward moves is equal; there are various methods for breaking such ties, including one devised by Pohl ^[14] and another by Squirrel and Cull.^[15]

好，尝试一下，在延伸树的支点的时候对每个支点加权排序之后再遍历。

代码如下：

 #include <cstdio>
 #include <cstring>
 #include <vector>
 #include <algorithm>

 bool visited[][];
 int y_direction[] = {-, -, -, -, , , , };
 int x_direction[] = {-, , , -, , -, -, };
 int record[];
 bool found;

 struct Node {
     int x, y, weight;
     Node(int x, int y, int weight) {
         this->x = x;
         this->y = y;
         this->weight = weight;
     }
     bool operator<(const Node &node) const {
         return weight < node.weight;
     }
 };

 inline bool is_valid(int x, int y) {
     return x >=  && x <  && y >=  && y < ;
 }

 inline int get_number(int x, int y) {
     return x *  + y + ;
 }

 inline int get_weight(int x, int y) {
     int temp_x, temp_y, weight = ;
     for (int i = ; i < ; i++) {
         temp_x = x + x_direction[i], temp_y = y + y_direction[i];
         if (is_valid(temp_x, temp_y) && !visited[temp_x][temp_y])
             weight++;
     }
     return weight;
 }

 void dfs(int x, int y, int step) {
     if (visited[x][y] || found)
         return;
     visited[x][y] = true;
     record[step] = get_number(x, y);
     if (step == ) {
         found = true;
         return;
     }
     int temp_x, temp_y;
     std::vector<Node> v;
     for (int i = ; i < ; i++) {
         temp_x = x + x_direction[i], temp_y = y + y_direction[i];
         if (is_valid(temp_x, temp_y) && !visited[temp_x][temp_y])
             v.push_back(Node(temp_x, temp_y, get_weight(temp_x, temp_y)));
     }
     std::sort(v.begin(), v.end());
     for (int i = ; (size_t)i < v.size(); i++)
         dfs(v[i].x, v[i].y, step + );
     visited[x][y] = false;
 }

 int main() {
     int n;
     while (scanf("%d", &n) && n != -) {
         found = false;
         memset(visited, , sizeof(visited));
         dfs((n - ) / , (n - ) % , );
         for (int i = ; i < ; i++)
             printf("%d ", record[i]);
         printf("%d\n", record[]);
     }
     return ;
 }

运用此策略惊人的达到了0.00s，在性能的提升上我确实没想到能提升这么多。

以下为两个版本代码提交截图：