骑士周游问题(马踏棋盘算法)

简述：

        最早由印度棋手在公元前200年的时候直观的提出。该问题用现代语言来描述的话，仍是在一个具体的图中寻找哈密尔顿路径的问题。图G中的哈密尔顿路径指的是经过图G中的每一个顶点，且只经过一次的一条轨迹。如果这条轨迹是一条闭合路径，即从起点出发不重复地遍历所有的点后仍能回到起始点，那么这条路径就成为就称为哈密尔顿路径。本问题是研究马在棋盘上的跳动，能否在每个棋盘的格子里只经过一次而遍历整个棋盘？

        起始点对于整个路径的影响是非常巨大的（比如 0, 0 点），可能要将所有可以走的路径全部测试一遍，粗略的估计需要走将近   次，时间复杂度非常大，我跑了很长时间没跑出来，所以我就放弃了，换了别的起点。

代码实现(C语言)：

#include <stdio.h>
#include <stdlib.h>
 
int chess[8][8] = {0};  // 初始化棋盘
int step = 1;   // 记录步数
 
void recurse(int x, int y)
{
    if ( x-2 >= 0 && y-1 >= 0 && 0 == chess[x-2][y-1] )
    {
        step ++;
        chess[x-2][y-1] = step;
        recurse(x-2, y-1);
        chess[x-2][y-1] = 0;
        step --;
    }
    if ( x-2 >= 0 && y+1 <= 7 && 0 == chess[x-2][y+1] )
    {
        step ++;
        chess[x-2][y+1] = step;
        recurse(x-2, y+1);
        chess[x-2][y+1] = 0;
        step --;
    }
    if ( x-1 >= 0 && y-2 >= 0 && 0 == chess[x-1][y-2] )
    {
        step ++;
        chess[x-1][y-2] = step;
        recurse(x-1, y-2);
        chess[x-1][y-2] = 0;
        step --;
    }
    if ( x-1 >= 0 && y+2 <= 7 && 0 == chess[x-1][y+2] )
    {
        step ++;
        chess[x-1][y+2] = step;
        recurse(x-1, y+2);
        chess[x-1][y+2] = 0;
        step --;
    }
    if ( x+1 <= 7 && y-2 >= 0 && 0 == chess[x+1][y-2] )
    {
        step ++;
        chess[x+1][y-2] = step;
        recurse(x+1, y-2);
        chess[x+1][y-2] = 0;
        step --;
    }
    if ( x+1 <= 7 && y+2 <= 7 && 0 == chess[x+1][y+2] )
    {
        step ++;
        chess[x+1][y+2] = step;
        recurse(x+1, y+2);
        chess[x+1][y+2] = 0;
        step --;
    }
    if ( x+2 <= 7 && y-1 >= 0 && 0 == chess[x+2][y-1] )
    {
        step ++;
        chess[x+2][y-1] = step;
        recurse(x+2, y-1);
        chess[x+2][y-1] = 0;
        step --;
    }
    if ( x+2 <= 7 && y+1 <= 7 && 0 == chess[x+2][y+1] )
    {
        step ++;
        chess[x+2][y+1] = step;
        recurse(x+2, y+1);
        chess[x+2][y+1] = 0;
        step --;
    }
    if ( 64 == step )
    {
        for (int i = 0; i < 8; i++)
        {
            for (int j = 0; j < 8; j++)
            {
                printf("%-3d  ", chess[i][j]);
            }
            printf("\n");
        }
        exit(0);
    }
}
 
int main(void)
{
    chess[2][0] = 1;    // 初始化起点
    recurse(2, 0);
    return 0;
}

结果：

9     2     11   14   7     4     21   18   
12   15   8     3     20   17   24   5    
1     10   13   16   25   6    19    22   
32   29   26   51   34   23   58   49   
27   52   33   30   59   50   35   40   
62   31   28   43   36   39   48   57   
53   44   63   60   55   46   41   38   
64   61   54   45   42   37   56   47