Sicily 1153. 马的周游问题

最新推荐文章于 2018-03-21 11:39:24 发布

L1858

最新推荐文章于 2018-03-21 11:39:24 发布

阅读量369

点赞数

CC 4.0 BY-SA版权

分类专栏：算法文章标签： sicily

本文链接：https://blog.youkuaiyun.com/u013038899/article/details/40714145

算法专栏收录该内容

12 篇文章

订阅专栏

本文介绍了一种解决骑士周游问题的方法，采用深度优先搜索（DFS）算法，并通过剪枝策略来提高效率。通过对棋盘上每个位置的可达路径数量进行排序，优先选择可达路径较少的位置进行尝试，从而有效地找到了从指定起点出发覆盖整个棋盘的路径。

// DFS，须剪枝
#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

int k, res[64];
bool visit[64];
int direct[][2] = { { -2, 1 }, { -1, 2 }, { 1, 2 }, { 2, 1 }, { 2, -1 },
		{ 1, -2 }, { -1, -2 }, { -2, -1 } };
struct Grid {
	int num;
	int way;
} g[8];

bool cmp(Grid a, Grid b) {
	return a.way < b.way;
}

void count(int now) {
	int x = now / 8;
	int y = now % 8;

	for (int i = 0; i < 8; i++) {
		int nx = x + direct[i][0];
		int ny = y + direct[i][1];
		int next = nx * 8 + ny;

		if (0 <= nx && nx < 8 && 0 <= ny && ny < 8 && !visit[next]) {
			g[k].way = 0;    // 可扩展数
			g[k].num = i;    // 方向
			for (int j = 0; j < 8; j++) {
				int nxx = nx + direct[j][0];
				int nyy = ny + direct[j][1];
				int nextt = nxx * 8 + nyy;

				if (0 <= nxx && nxx < 8 && 0 <= nyy && nyy < 8 && !visit[nextt])
					g[k].way++;
			}
			k++;
		}
	}
}

bool dfs(int now, int cnt) {
	if (cnt == 64)
		return true;

	// 对当前格子的可扩展格子的可扩展数进行排序
	k = 0;
	count(now);
	sort(g, g + k, cmp);

	int x = now / 8;
	int y = now % 8;

	// 先走可扩展数较小的格子
	for (int i = 0; i < k; i++) {
		int nx = x + direct[g[i].num][0];
		int ny = y + direct[g[i].num][1];
		int next = nx * 8 + ny;

		// 注意逻辑
		if (0 <= nx && nx < 8 && 0 <= ny && ny < 8 && !visit[next]) {
			visit[next] = true;
			res[cnt] = next;
			if (dfs(next, cnt + 1))
				return true;
			visit[next] = false;
		}
	}
	return false;
}

int main(int argc, char **argv) {
	int src;
	while (cin >> src && src != -1) {
		memset(visit, false, sizeof(visit));

		res[0] = src;
		visit[src - 1] = true;
		dfs(src - 1, 1);

		cout << res[0];
		for (int i = 1; i < 64; i++)
			cout << " " << res[i] + 1;
		cout << endl;
	}
	return 0;
}