闭合路径的骑士巡游问题（国际棋盘马的遍历（8*8网格）)

一片青春不负

已于 2025-02-24 21:36:33 修改

阅读量706

点赞数 27

分类专栏：小项目文章标签： github c++

于 2025-02-24 19:41:27 首次发布

本文链接：https://blog.csdn.net/2303_80017896/article/details/145835403

版权

小项目专栏收录该内容

1 篇文章

订阅专栏

闭合路径的骑士巡游问题（国际棋盘马的遍历（8*8网格））

0. 写在前面
1.问题背景与描述
2.算法运用
3. j.c.Warnsdorff 规则运用与遍历算法实现
- 3.1实现 j.c.Warnsdorff 规则
- 3.2遍历算法实现
4.可视化展示

0. 写在前面

该小项目是作者的课程作业，部分内容可能参考网络内容，如有侵权，请联系作者删除。

完整代码已上传至GitHub（可能需要科学上网）
网址：https://github.com/tyuou2/Knight-tour

大家觉得不错的话，记得给个star哦！！！

本项目基于Qt框架，主要使用C++语言进行编写。作者使用的Qt版本为Qt5.14.2,若Qt版本不同可能会无法运行（感觉应该没啥事，无法运行可能性应该很小）。

1.问题背景与描述

国际象棋的棋盘有 8×8＝64 个格子。马在这 64 个格子的某一个格子上，它的跳动规则是：如它现在在（x， y）位置，它下一步可以跳到（x±1，y±2）或（x±2， y±1）（所有的“±”之间没有相关性），每个位置下一步最多可以有八种跳法。但是不能跳出这 64 个格子。

2.算法运用

主要使用递归、回溯、贪心相关知识。

3. j.c.Warnsdorff 规则运用与遍历算法实现

j.c.Warnsdorff规则: 在所有可跳的方格中,马只可能走这样一个方格:从该方格出发,马能跳的方格数为最少； 如果可跳的方格数相等,则从当前位置看,方格序号小的优先。

3.1实现 j.c.Warnsdorff 规则

在每次走下一步之前，计算 8 个可能位置的下一步可行步数，优先选择后续可走位置较少的方向，以更高效地遍历整个棋盘。

在最初，初始化 dir_x[8]、 dir_y[8]的数组，每一个索引 i代表一个方向，并初始化 j_c_Warnsdorff_sortarray[8]数组，代表8 个方向的优先级顺序。在走下一步前调用sort_j_c_Warnsdorff 函数。

然后首先初始化数组sorted_by[8]，代表 8 个方向的后续可行步数。然后通过两次循环，得到每一个方向后续可走位置的数量，存入 sorted_by 数组中，然后调用 sort_index 函数，根据 sorted_by 数组中存储的每一个位置的可行步数对j_c_Warnsdorff_sortarray[8]数组进行排序，得到后续位置遍历的优先级顺序，从而实现j_c_Warnsdorff 规则。

void horse::sort_j_c_Warnsdorff(int x, int y)
{
    int next_x1, next_y1, next_x1_next, next_y1_next;
    int sorted_by[8] = {8, 8, 8, 8, 8, 8, 8, 8};
    for (int i = 0; i < size_x; i++)
    {
        int step_cnt = 0;
        next_x1 = x + dir_x[i], next_y1 = y + dir_y[i];
        if (in_grid(next_x1, next_y1) == 1)
        {
            for (int j = 0; j < size_y; j++)
            {
                next_x1_next = next_x1 + dir_x[j], next_y1_next = next_y1 + dir_y[j];
                if (in_grid(next_x1_next, next_y1_next) == 1)
                {
                    step_cnt++;
                }
            }
        }
        sorted_by[i] = step_cnt;
    }
    //从上面的递归程序中获得下一个位置的可行个数与方向
    
    sort_index(sorted_by, j_c_Warnsdorff_sortarray, size_x); // 按照 j.c.Warnsdorff规则进行排序
}

3.2遍历算法实现

首先对一些数据进行初始化操作，避免上次遍历结果影响本次遍历。

然后调用 hores_traversal 函数进行遍历，得到代表遍历顺序的二维数组。在这个过程中，首先对于几个状态较多位置进行贪心处理，减少程序运行时间，做到程序迅速响应。然后进行遍历操作。

在每次运行中调用sort_j_c_Warnsdorff 函数，得到后续位置的优先级排序，根据优先级排序进行走下一步，计算下一个位置的 X、 Y 坐标，每次先判断已经遍历的位置数，当达到 64 时，且最后一个位置能够回到起点，递归程序结束。然后调用 in_grid 函数判断下一个位置是否在棋盘内，若是，则进行下一次递归，若这次递归返回值为 1，则继续，若返回 0，则代表当前位置不符合条件，并
将当前棋盘位置还原为初始值。

最终已经遍历的位置数达到 64 时，且最后一个位置能够回到起点时，递归程序结束，完成棋盘遍历操作。

int horse::hores_traversal(int x, int y, int deep)
{
    every_init(deep);
    int i, next_x1, next_y1;
    sort_j_c_Warnsdorff(x, y); // 对八个方向进行排序
    for (i = 0; i < able_step; i++)
    {
        next_x1 = x + dir_x[j_c_Warnsdorff_sortarray[i]];
        next_y1 = y + dir_y[j_c_Warnsdorff_sortarray[i]];
        int absx = abs(next_x1 - begin_x + 1);
        int absy = abs(next_y1 - begin_y + 1);
        if (in_grid(next_x1, next_y1) == 1) // 检查
        {
            grid[next_x1][next_y1] = deep;
            int go_to_begin = absx * absx + absy * absy;
            if (deep >= Total_step && (go_to_begin == 5))
            {
                return 1;
            }
            if (hores_traversal(next_x1, next_y1, deep + 1) == 1)
            {
                return 1;
            }
            else
            {
                grid[next_x1][next_y1] = 0; // 将棋盘还原
            }
        }
    }
    return 0;
}