BFS:八数码问题求解

八数码原题

剖析一下BFS

        BFS算法是一种图遍历算法,它从起点开始,逐层扩展搜索范围,直到找到目标节点为止。        

        BFS算法一般选择队列作为节点存储的数据结构,我们将搜索目标节点的问题抽象为寻找目标状态,那么队列存储的对象就是每一种状态。

        对于状态的含义与变化过程,BFS算法如下要求(为了讲解得更加透彻,举走迷宫问题为例):

  1. 初始以及其拓展出开的状态都要存储在队列中。在走迷宫问题中,队列q存储已走过的点 ,点代表位置状态,基于一个点可以拓展出它四周的点;
  2. 问题的求解必须有初始状态最终状态。在走迷宫问题中,起点(0,0)便是初始状态,而终点(n,n)是最终状态;
  3. 问题的状态次数是有限的已出现的状态一般需要被记录下来。在走迷宫问题中,dis[i][j]表示从起点到达点(i,j)的距离。当dis的所有元素被初始化为0时,如果dis[i][j]非零时,就说明点(i,j)已被记录过;
  4. 当前状态preState可以拓展出其他状态State,如果State已经出现过或者不符合要求,那么该状态无法加入队列中.

八数码问题的求解 

问题描述

        八数码,在3×3的方格棋盘上,摆放着1到8这八个数码,有1个方格放置字符x,其初始状态如图所示,要求对字符x执行x左移、x右移、x上移和x下移这四个操作使得棋盘从初始状态到目标状态。

        BFS:八数码问题求解_第1张图片

        基于上述状态能够拓展出如下四种状态:

BFS:八数码问题求解_第2张图片

         八数码问题要求是,对字符x进行若干次唯一操作,得到目标状态并且求算操作次数: 

BFS:八数码问题求解_第3张图片

 求解思路

  1. 每一个矩阵的里面的元素能够用一个字符串来存储,例如存储最终状态string s = "12345678x";
  2. 本问题借助state结构体存储每一种状态,state的分量为:s,pos,step.其中,s代表该状态对应的字符串,pos代表x在s字符串中的位置,step代表本状态由初始转台经过了step次操作得来;
  3. 定义一个mapst映射,记录该字符串(即新拓展出来的状态)曾经是否出现过,即已出现的状态需要被记录下来;
  4. 当前状态preState包含三个分量{s,pos,step},根据pos与s值,拓展出其他至多四种状态,具体实现将代码的genOtherState函数.

        好啦,大功告成~~其他细节部分见代码后,也许会有更加深刻的体会(代码有详细注释,所谓优秀的代码本身就是学习文档!!!)

代码实现

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include
using namespace std;

//	come from Acwing

//	记录状态
struct state {
	string s;
	int pos;	//	x的位置
	int step;	//	step次交换
};

string str;
mapst;	//	记录某个状态是否曾出现
queueq;	//	状态队列

//	产生其他状态
void genOtherState(const state& sta) {
	string s;
	state t;
	//	判断是否能够交换x与它上面字符的位置
	if (sta.pos - 3 >= 0) {
		//	交换两个字符的位置
		s = sta.s;
		swap(s[sta.pos], s[sta.pos - 3]);
		if (!st[s]) {
			q.push(state{ s,sta.pos - 3,sta.step + 1 });
			st[s] = true;
		}
	}

	//	判断是否能够交换x与它下面字符的位置
	if (sta.pos + 3 <= 8) {
		s = sta.s;
		swap(s[sta.pos], s[sta.pos + 3]);
		if (!st[s]) {
			q.push(state{ s,sta.pos + 3,sta.step + 1 });
			st[s] = true;
		}
	}

	// 判断是否能够交换x与它右边字符的位置
	if (sta.pos % 3<=1) {
		s = sta.s;
		swap(s[sta.pos], s[sta.pos + 1]);
		if (!st[s]) {
			q.push(state{ s,sta.pos + 1,sta.step + 1 });
			st[s] = true;
		}
	}

	// 判断是否能够交换x与它左边字符的位置
	if (sta.pos % 3 >= 1) {
		s = sta.s;
		swap(s[sta.pos], s[sta.pos - 1]);
		if (!st[s]) {
			q.push(state{ s,sta.pos - 1,sta.step + 1 });
			st[s] = true;
		}
	}
}

int bfs(int pos) {
	string target = "12345678x";	//	目标状态
	
	// 初始化
	state init = state{ str,pos,0 };
	q.push(init);
	st[str] = true;

	while (q.size()) {
		auto t = q.front();	//	取出队头状态进行拓展
		q.pop();
		if (t.s == target) {
			return t.step;
		}

		//	当前状态拓展出其余状态
		genOtherState(t);
	}

	return -1;
}

int main() {
	int cnt = 9;
	int pos = 0;
	
	//	输入
	for (int i = 0;i <= 8;i++) {
		char a;
		cin >> a;
		if (a == 'x') {
			pos = i;
		}
		str += a;
	}

	int res = bfs(pos);
	cout << res << endl;
	return 0;
}

     实在不好意思,上述程序由于状态的存储与状态的拓展过于繁杂,所以导致了Time Limit Exceeded了,如下提供优化状态存储版本的程序如下:

优化版本的八数码算法

#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#include 
using namespace std;

/*
	改进的地方:
	1.每一种状态的步数通过unorder_map实现映射
	减少了存储状态的内存消耗
	2.采用string的find()函数查找,x的位置;
	3.通过运算直接获取原状态可以拓展的状态
*/

string start;	//	其实状态
string End = "12345678x";	//	最终状态

int bfs() {
	queueq;	//	存储状态
	unordered_mapd;	//	d.count(t)表示t进入容器的次数

	//	初始化
	q.push(start);
	d[start] = 0;

	while (q.size()) {
		auto t = q.front();
		q.pop();

		int pos = t.find('x');	//	查找x的位置
		int distance = d[t];
		int dx[4] = { -1,0,1,0 }, dy[4] = { 0,1,0,-1 };	//	拓展的位移

		if (t == End) {
			return d[t];
		}

		for (int i = 0;i < 4;i++) {
			int a = pos / 3 + dx[i];
			int b = pos % 3 + dy[i];

			if (a >= 0 && a <= 2 && b >= 0 && b <= 2) {
				swap(t[pos], t[3 * a + b]);
				//	如果不是第一次加入队列
				if (!d.count(t)) {
					q.push(t);
					d[t] = distance + 1;
				}
				swap(t[pos], t[3 * a + b]);
			}
		}
	}
	return -1;	//	没有达到最终状态
}

int main() {
	int cnt = 9;

	while (cnt--) {
		char a;
		cin >> a;
		start += a;
	}
	cout << bfs() << endl;
	return 0;
}

总结

        本博客先解释了BFS的存储队列节点的抽象含义,将每一个节点看作一种状态,并从状态存储、状态记录、状态拓展等角度解答了BFS算法如何解决遍历问题。

        紧接着,我们借助BFS算法的状态处理方法给出了八数码问题的求解思路。我们以字符串存储了八数码的每一种状态,每一种状态记录{s,pos,step}三个分量,借助st映射记录新拓展出的状态,并于代码中给出状态拓展的方法。

        实际上,八数码问题只是抽象BFS问题的一种实例化,当我们判断一个问题是否属于BFS问题时,需要判断问题是否存在初始状态与最终状态?每一种状态如何存储,有哪些分量?如何记录每一种状态?每一种状态拓展出其他状态的方式是否是规律的且有限的?掌握了如上的思考方式,相信你能够在下一次遇到或判断一个问题是否属于BFS问题时,你能够更加游刃有余!!!

你可能感兴趣的:(数据结构与算法,C++,BFS算法,八数码问题)