八数码问题BFS算法

最新推荐文章于 2024-04-04 21:30:06 发布

李子园啊

最新推荐文章于 2024-04-04 21:30:06 发布

阅读量1.7k

点赞数 4

分类专栏：算法文章标签：算法宽度优先

本文链接：https://blog.csdn.net/weixin_50672810/article/details/121852945

版权

算法专栏收录该内容

1 篇文章 0 订阅

订阅专栏

八数码问题

在一个3*3的棋盘上放置编号为1~8的八个方块，每个方块占一格，另外还有一个空格。与空格相邻的数字方块可以移动到空格上。任务一：指定初始棋盘和目标棋盘，计算出最少的移动步数；任务2：输出数码的移动序列。

把空格看成0，一共9个数字。

输入样例：在这里插入图片描述
1 2 3 0 8 4 7 6 5
1 0 3 8 2 4 7 6 5
输出样例
2
把一个棋局看成一个状态图，总共有9！=362880个状态。从初始棋局开始，每次移动转到下一个状态，到达目标棋局后停止。

下图是样例的转移过程。该图的起点为（A，0），A表示状态,即{1 2 3 0 8 4 7 6 5}这个棋局；0是距离起点的步数。从初始状态A出发，移动数字0到邻居位置，按上下左右的顺序，有3个转移状态B，C，D；目标状态是F，停止。
在这里插入图片描述

用队列描述这个BFS过程：

（1）A进队，当前队列是{A};

（2）A出队，A的邻居B，C，D进队，当前队列是{B，C，D}，步数为1；

（3）B出队，E进队，当前队列是{C，D，E}，E的步数是2；

（4）C出队，转移到F，检验F是目标状态，停止，输出F的步数2。

仔细分析上述过程，发现从B状态出发实际上有E，X两个转移方向，而X正好是初始状态A，重复了。同理Y状态也是重复的。如果不去掉这些重复状态，程序会产生很多无效操作，复杂度大大增加。因此，八树码的重要问题其实是判重。

如果用暴力的方法判重，每次把新状态与9！=362880个状态对比，可能有9！*9！次检查，不可行。因此需要一个快速的判断方法。本文章使用数学方法“康托展开”来判重。
代码实现如下

#include<Bits.h>
#include<queue>
#include<cstdio>
#include<iostream>
using namespace std;
const int LEN = 362880;//状态共9！=362880种
struct node {
	int state[9];//记录一个八数码的排列，即一个状态
	int dis;//记录到起点的距离
};

int dir[4][2] = { {-1,0},{0,-1},{1,0},{0,1} };//左、右、上、下顺时针方向，左上角的坐标为（0，0）
int visited[LEN];//与每个状态对应的记录，Cantor()函数对它置数，并判重
int start[9];//开始状态
int goal[9];//目标状态
long int factoty[] = { 1,1,2,6,24,120,720,5040,40320,362880 };//康托用到的常数


bool Cantor(int str[], int n) {
	long result = 0;
	for (int i = 0; i < n; i++) {
		int counted = 0;
		for (int j = i + 1; j < n; j++) {
			if (str[i] > str[j])
				++counted;
		}
		result += counted * factoty[n - i - 1];
	}
	if (!visited[result]) {
		visited[result] = 1;
		return 1;
	}
	else
		return 0;
}

int bfs() {
	node head;
	memcpy(head.state, start, sizeof(head.state));//复制起点的状态
	head.dis = 0;
	queue<node> q;//队列中的内容是记录状态
	Cantor(head.state, 9);//用康托展开判重，目的是对起点的visited[]赋初值
	q.push(head);
	while (!q.empty()) {
		head = q.front();
		if (memcmp(head.state, goal, sizeof(goal)) == 0)//与目标状态对比
			return head.dis;//到达目标状态，返回距离，结束
		q.pop();
		int z;
		for (z = 0; z < 9; z++)//寻找0的位置
			if (head.state[z] == 0)
				break;
		int x = z % 3;//横坐标
		int y = z / 3;//纵坐标
		for (int i = 0; i < 4; i++) {
			int newx = x + dir[i][0];//元素0转移后的新坐标
			int newy = y + dir[i][1];
			int nz = newx + (3 * newy);//转化为一维
			if (newx >= 0 && newx < 3 && newy >= 0 && newy < 3) {//未越界
				node newnode;
				memcpy(&newnode, &head, sizeof(struct node));//复制这个新的状态
				swap(newnode.state[z], newnode.state[nz]);//把0移动到新的位置
				newnode.dis++;
				if (Cantor(newnode.state, 9))//用康托展开判重
					q.push(newnode);//把新的状态放入队列
			}
		}
	}
	return -1;//没找到
}


int main() {
	memset(visited, 0, sizeof visited);
	for (int i = 0; i < 9; i++)cin >> start[i];//初始状态
	cout << "终态";
	for (int j = 0; j < 9; j++)cin >> goal[j];//目标状态
	int num = bfs();
	if (num != -1)cout << num << endl;
	else cout << "Impossible" << endl;
	return 0;
}

更多八数码求解可转八数码八境界
在这里插入图片描述