马周游问题非递归算法（不要求回到起点）

一、  原题中文大意;

对于一个8*8的棋盘，用下列的方式编号 

如果它走63步正好经过除起点外的其他位置各一次，这样一种走法则称马的周游路线，设计一个算法，从给定的起点出发，找出它的一条周游路线。马的走法是“日”字形路线。 

 Input

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

 Output

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

1. 二、  算法思想及解题用到的主要数据结构;

最本质的还是图的遍历的问题。这里使用深度优先搜索，不用广度优先是因为通常在寻找路径或者迷宫之类的题目中，都是探寻的问题，用深度优先比广度优先容易比较快地找到解。

涉及到回溯算法，即走到一个“死胡同”后，返回上一步，选择其他方向。这里就是到达一个不能往其他任何方向走的位置。

回溯和深度优先确定了，然后就是选择非递归算法，因为自己确实理解能力有限，递归的方法不能完全想明白。于是就自己思考加上查阅资料，使用非递归算法。

其中要提高效率，需要剪枝，即每次选择下一位置时，要通过一定筛选策略选择比较快速高效的一步。这里选择下一步位置具有最少可行步数的一步。

 

主要数据结构：

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;
}