回溯法 马周游

实验课程：算法分析与设计

实验名称：回溯法的应用

第一部分实验内容

1．实验目标

（1）熟悉使用回溯法求解问题的基本思路。

（2）掌握回溯算法的程序实现方法。

（3）理解回溯算法的特点。

2. 实验任务

（1）从所给定的题目中选择一题，使用回溯法求解之。

（2）用文字来描述你的算法思路，包括解空间、限界函数、算法主要步骤等。（3）在Windows环境下使用C/C++语言编程实现算法。

（4）记录运行结果，包括输入数据，问题解答及运行时间。

（5）分析算法最坏情况下时间复杂度和空间复杂度。

（6）谈谈实验后的感想，包括关于该问题或类似问题的求解算法的建议。3. 实验设备及环境

PC；C/C++等编程语言。

4. 实验主要步骤

(1)根据实验目标，明确实验的具体任务；

(2)设计求解问题的回溯算法，并编写程序实现算法；

(3)设计实验数据并运行程序、记录运行的结果；

(4)分析算法时空性能；

(5)实验后的心得体会。

第二部分问题及算法

1.问题描述

问题1：

在一个8*8的棋盘上，一个放在棋盘上某个位置的马是否可以恰好访问每个方格一次，并且回到起始位置上？

2. 回溯法的一般思路

深度优先搜索，若寻找到满足要求的解，则输出；否则推回上一层往下一个方向搜索。

3. 求解问题的回溯算法描述

对于当前所在位置（x，y），依次枚举8个方向搜索，直到找到一组可行解为止。使用剪枝有3处：第一、使用Warnsdorff's rule，枚举当前解得时候优先选择下一步可行步数最少的方向；第二、若第一点中的方向存在不止一个，则优先选择离中心位置较远的方向；每次都从中心点开始出发，求出一条合法路径后再平移映射回待求路径。

4. 算法实现的关键技巧

在棋盘较大的时候，使用递归会使得函数暴栈，故应当使用非递归方法实现。程序实现时应细心记录清楚当前状态在栈顶。

第三部分实验结果与分析

#include

#include

#include

#include

using namespace std;

const int ix[8] = {1, 2, 2, 1, -1, -2, -2, -1};

const int iy[8] = {2, 1, -1, -2, 2, 1, -1, -2};

int midx, midy;

struct Point {

int x, y, c;

Point(int xx = 0, int yy = 0, int cc = 0):x(xx), y(yy), c(cc) {}

bool operator < (const Point & b) const {

if (c != b.c) return c < b.c;

return abs(x - midx) + abs(y - midy) > abs(b.x - midx) + abs(b.y - midy);

}

};

struct Node {

int x, y;

Node(int xx = 0, int yy = 0):x(xx), y(yy) {}

};

template < class T >

inline void swap(T & a, T & b) {

T t = a; a = b; b = t;

}

int m, n;

bool vis[10][10];

int a[10][10];

inline bool check(int x, int y) {

if (x < 1 || x > n || y < 1 || y > n) return 0;

if (vis[x][y]) return 0;

return 1;

}

bool find(int x, int y) {

for (int i = 0; i < 8; ++i)

if (x + ix[i] == midx && y + iy[i] == midy)

return 1;

return 0;

}

Node ss[10 * 10];

Point b[10 * 10][8], *tb;

int dir[10 * 10], bn[10 * 10], top;

bool dfs(int x, int y) {

int i, j, tbn, nx, ny, mx, my, cnt;

top = 1;

vis[x][y] = 1;

a[x][y] = 0;

ss[top] = Node(x, y);

dir[top] = -1;

while (top) {

if (top == m && find(ss[top].x, ss[top].y)) {

puts("已找到找到一个可行解！");

return 1;

}

if (top == m) {

vis[ ss[top].x ][ ss[top].y ] = 0;

--top;

} else if (dir[top] == -1) {

x = ss[top].x; y = ss[top].y;

tbn = 0;

tb = b[top];

for (i = 0; i < 8; ++i) {

nx = x + ix[i]; ny = y + iy[i];

if (!check(nx, ny)) continue;

cnt = 0;

for (j = 0; j < 8; ++j) {

mx = nx + ix[j]; my = ny + iy[j];

if (check(mx, my)) ++cnt;

}

tb[tbn++] = Point(nx, ny, cnt);

}

if (tbn) {

bn[top] = tbn;

sort(tb, tb + tbn);

tb = b[top];

i = ++dir[top];

vis[ tb[0].x ][ tb[0].y ] = 1;

a[ tb[0].x ][ tb[0].y ] = top;

ss[++top] = Node(tb[0].x, tb[0].y);

dir[top] = -1;

} else {

vis[ ss[top].x ][ ss[top].y ] = 0;

--top;

}

} else if (dir[top] == bn[top] - 1) {

vis[ ss[top].x ][ ss[top].y ] = 0;

--top;

} else {

tb = b[top];

i = ++dir[top];

vis[ tb[i].x ][ tb[i].y ] = 1;

a[ tb[i].x ][ tb[i].y ] = top;

ss[++top] = Node(tb[i].x, tb[i].y);

dir[top] = -1;

}

}

return 0;

}

int main() {

clock_t begin, end;

int i, j, bx, by, k;

while (1) {

printf("请输入骑士初始坐标(1<=x<=8,1<=y<=8)：");

scanf("%d %d", &bx, &by);

while (bx < 1 || bx > 8 || by < 1 || by > 8) {

printf("输入不合法！请重新输入骑士初始坐标(1<=x<=8,1<=y<=8)：");

scanf("%d %d", &bx, &by);

}

n = 8;

midx = midy = n / 2;

begin = clock();

memset(vis, 0, sizeof(vis));

m = n * n;

dfs(midx, midy);

end = clock();

printf("所用时间：%.0lfms\n", double(end - begin));

if (n <= 20) {

k = m - a[bx][by];

for (i = 1; i <= n; ++i) {

for (j = 1; j <= n; ++j) {

a[i][j] = (a[i][j] + k) % m + 1;

printf("%4d", a[i][j]);

}

puts("");

}

}

puts("");

}

return 0;

}

1.实验数据及结果

2.实验分析及结果

首先先说明上面的数值的意思。上面的数值排成8*8的方阵，每个代表棋盘上的格子，而数字的大小表示骑士走到这个格子的次序，即骑士是第n步走到这个格子的。

从上面是几个实验结果看，程序均能准确地找出一条路径，使得骑士能够遍历整个棋盘，且运行的时间均为0ms。

第四部分心得与展望

1.自我评价及心得体会

该程序本来采用递归函数，后来发现运行很慢，后来在小组同学的讨论下决定不用递归，通过参考不少程序才完成此次实验的，在实验的过程中加深了对回溯法的算法思想的理解。2.展望

对程序进行稍微的修改，使其可以在n*n的棋盘上运行。