一、 原题中文大意;
对于一个8*8的棋盘，用下列的方式编号
如果它走63步正好经过除起点外的其他位置各一次，这样一种走法则称马的周游路线，设计一个算法，从给定的起点出发，找出它的一条周游路线。马的走法是“日”字形路线。
Input
输入有若干行。每行一个整数N(1<=N<=64)，表示马的起点。最后一行用-1表示结束，不用处理。
Output
对输入的每一个起点，求一条周游线路。对应地输出一行，有64个整数，从起点开始按顺序给出马每次经过的棋盘方格的编号。相邻的数字用一个空格分开。
二、 算法思想及解题用到的主要数据结构;
最本质的还是图的遍历的问题。这里使用深度优先搜索，不用广度优先是因为通常在寻找路径或者迷宫之类的题目中，都是探寻的问题，用深度优先比广度优先容易比较快地找到解。
涉及到回溯算法，即走到一个“死胡同”后，返回上一步，选择其他方向。这里就是到达一个不能往其他任何方向走的位置。
回溯和深度优先确定了，然后就是选择非递归算法，因为自己确实理解能力有限，递归的方法不能完全想明白。于是就自己思考加上查阅资料，使用非递归算法。
其中要提高效率，需要剪枝，即每次选择下一位置时，要通过一定筛选策略选择比较快速高效的一步。这里选择下一步位置具有最少可行步数的一步。
主要数据结构：
1、路径的树节点，使用自定义结构体，
struct Node {
int x, y, num; // x, y 为矩阵坐标（0~7， 0~7 ，num为对应的数值，由x，y算出
int neighbor[8]; // 下一步数组，每一个为对应的方向数组，在运算中使用坐标值，可以访问为0，反之为1；
};
2、每一个位置对应的走“日”字的方向数组
int dirx[8] = {2,1,-1,-2,-2,-1,1,2}; // x方向数组
int diry[8] = {-1,-2,-2,-1,1,2,2,1}; // y方向数组
queue<node> states;
3、记录访问顺序的数组
int seq[64]; // 记录走的过程
4、深度优先回溯中用到的栈
stack<Node> t_route; // 树节点栈
5、标记数组
int board[8][8]; // 记录已访问的位置，已访问为 1 ，未访问为0
三、 详细解题思路
1、 对于每组数据，首先把board访问数组清零，step值置0，声明一个Node栈的t_route。
将起始位置初始化为一个Node结点，压栈。
2、进入一个while循环，循环判断条件是栈不为空。
取栈顶元素，seq数组中step下标位置为改栈顶元素的num值，记录路径, step++。如果此时step的值等于64，则说明走完了整个棋盘，退出循环。
同时，board数组也将栈顶元素对应坐标位设为1（已访问）
3、针对栈顶元素，遍历它的8个邻居节点，在可行的邻居节点中选择可行步数最少的一个。
找到后，用flag记录该邻居节点的下标值，未找到则flag为-1
4、找到一个可行节点，将栈顶元素的neighbor数组对应下标位设为1（已访问）将该节点的值初始化（x,y,num,neighbor[8]）,压栈。
栈顶元素没有一个可行节点，将step减1，board数组对应下标位置设为0，出栈，回溯。
5、判断step是否等于64，若是，则找到解，一次输出seq数组的值；反之，没有解，输出-1。
其中计算一个位置是否可以到达，调用函数canmove判断，判断条件为该位置坐标不越界合法并且board数组中对应下标位置为0。
每个Node里面有二维数组的坐标值和本身数组，用一个转换函数xy_to_num，可以利用坐标值算出数值。
计算下一步的可行步数时，调用函数next_neighbor计算，函数中用canmove函数计算。
四、 逐步求精算法描述（含过程及变量说明）
变量及函数说明
// 非递归DFS中树节点的结构体
struct Node {
int x, y, num; // x, y 为矩阵坐标（0~7， 0~7 ，num为对应的数值，由x，y算出
int neighbor[8]; // 下一步数组，每一个为对应的方向数组，在运算中使用坐标值，可以访问为0，反之为1；
};
int dirx[8] = {2,1,-1,-2,-2,-1,1,2}; // x方向数组
int diry[8] = {-1,-2,-2,-1,1,2,2,1}; // y方向数组
int seq[64]; // 记录走的过程
int step; // 指向seq对应的下标进行赋值, 每走一步step + 1，回溯一次step – 1
int board[8][8]; // 记录已访问的位置，已访问为 1 ，未访问为0
int xy_to_num(int x, int y); // 计算坐标对应数值，参数为坐标
bool canmove(int x, int y); // 计算该位置是否可行，参数为坐标
int next_neighbor(int x, int y); // 计算下一位置的可行步数,参数为坐标
初始化起始位置结点，board数组，step；
标记board数组，初始结点压栈；
While（栈不为空） {
seq[step] = 栈顶元素的num；
board中栈顶元素设为已访问
step++；
min = 8; //初始化最小步数
if ( step == 64)
找到路径，退出循环；
遍历栈顶元素的邻居节点，计算邻居节点的可行步数
If（找到一个邻居节点）{
栈顶元素的该邻居下标设为1，已访问。
初始化下一步节点的x, y, num, neighbor[8]；
压栈
}
Else {
栈顶元素出栈；
Board对应位置设置为 0；
Step–;
}
}
If (step == 64) // 找到解
输出seq数组
Else
输出“-1“
五、 程序注释清单（重要过程的说明）;
#include<iostream>
#include<stdio.h>
#include<string>
#include<string.h>
#include<cstring>
#include<stack>
using namespace std;
// 非递归DFS中树节点的结构体
struct Node {
int x, y, num; // x, y 为矩阵坐标（0~7， 0~7 ，num为对应的数值，由x，y算出
int neighbor[8]; // 下一步数组，每一个为对应的方向数组，在运算中使用坐标值，可以访问为0， 反之为1；
};
int dirx[8] = {2,1,-1,-2,-2,-1,1,2}; // x方向数组
int diry[8] = {-1,-2,-2,-1,1,2,2,1}; // y方向数组
int seq[64]; // 记录走的过程
int step; // 指向seq对应的下标进行赋值, 每走一步step + 1，回溯一次step - 1
int board[8][8]; // 记录已访问的位置，已访问为 1 ，未访问为0
int xy_to_num(int x, int y); // 计算坐标对应数值，参数为坐标
bool canmove(int x, int y); // 计算该位置是否可行，参数为坐标
int next_neighbor(int x, int y); // 计算下一位置的可行步数,参数为坐标
int main() {
int N, min, flag, step, i, nextloc;
while(scanf("%d", &N) && N != -1) {
if (N >= 1 && N <= 64) {
stack<Node> t_route; // 树节点栈
step = 0;
memset(board, 0, sizeof(int) * 64);
// 初始化根节点状态，压栈
Node ini;
ini.y = (N-1) % 8;
ini.x = (N-1) / 8;
ini.num = N;
for (i = 0; i < 8; i++) {
if(canmove(ini.x + dirx[i], ini.y + diry[i]))
ini.neighbor[i] = 0;
else
ini.neighbor[i] = 1;
}
t_route.push(ini);
while (!t_route.empty()) {
Node temp = t_route.top();
board[temp.x][temp.y] = 1; // 栈顶已访问
seq[step++] = temp.num; // 路径数组赋值
// 找到路径，退出
if (step == 64)
break;
flag = -1; // 记录有最少可行步数的邻居节点的下标
min = 8; // 最少步数
// 寻找最小步数的节点
for (i = 0; i < 8; i++) {
if (temp.neighbor[i] == 0) {
int t = next_neighbor(temp.x + dirx[i], temp.y + diry[i]);
if (t <= min ) {
min = t;
flag = i;
}
}
}
// 找到最小步数的邻居节点
if (flag != -1) {
temp.neighbor[flag] = 1; // 在栈顶结点中将该节点设置为已访问
// 初始化下一步节点的值，压栈
Node newnode;
newnode.x = temp.x + dirx[flag];
newnode.y = temp.y + diry[flag];
newnode.num = xy_to_num(newnode.x, newnode.y);
for (i = 0; i < 8; i++) {
if(canmove(newnode.x + dirx[i], newnode.y + diry[i]))
newnode.neighbor[i] = 0;
else
newnode.neighbor[i] = 1;
}
t_route.push(newnode);
}
// 栈顶节点没有可以行走的下一位置，出栈，设为未访问
else {
t_route.pop();
board[temp.x][temp.y] = 0;
step --; //路径数组下标值同步减1
}
}
// output
if (step == 64) {
for( i = 0; i < 63; i++)
printf("%d ", seq[i]);
printf("%d\n", seq[i]);
}
else
printf("-1\n");
} // end of if (判断起始位置是否合法）
else
printf("-1\n");
}
return 0;
}
int xy_to_num(int x, int y) {
return x * 8 + y + 1;
}
bool canmove(int x, int y) {
if(x >= 0 && x <= 7 && y >= 0 && y <= 7 && board[x][y] == 0)
return true;
return false;
}
int next_neighbor(int x, int y) {
int i, num;
for (i = 0, num = 0; i < 8; i++)
if(canmove(x + dirx[i], y + diry[i]))
num++;
return num;
}
