用BFS解决八数码难题

最新推荐文章于 2023-09-30 21:11:26 发布

Anne_Aust

最新推荐文章于 2023-09-30 21:11:26 发布

阅读量1.3k

点赞数 1

文章标签：宽度优先算法

本文链接：https://blog.csdn.net/Anne_Aust/article/details/130399263

版权

一、什么是八数码难题

二、解决问题的大致流程

1.用“树”来进行穷举，理解问题的整个过程

这里使用了宽度优先搜索树，对每一结点都要找出它的孩子结点

2.解决该问题的大致流程图

3、使用的数据结构

如上图所示，各个状态用一维数组来表示，空格用零来表示，使用的队列存储各个状态来进行遍历，各状态的子状态要用动态数组来存储；

4、代码编写的过程

1、定义各个子状态

用类来实现各个子状态，对各个子状态进行的操作分别有：输入数据、按照九宫格来展示、生成子状态、判定与终态是否相同

（1）在头文件中进行类的定义

#pragma once
#ifndef STATE_H
#define STATE_H
#include <vector>
#define BD_SIZE 3
using namespace std;
class State
{
public:
	State();
	void display();
	void generateChildren(vector<State>& result);
	bool operator ==(State& rv);
private:
	int m_data[BD_SIZE * BD_SIZE];
};

#endif

（2）数据的输入与展示

State::State()//按照一维数组进行输出
{
	for (int i = 0; i < BD_SIZE * BD_SIZE; i++)
	{
		cin >> m_data[i];
	}
}
void State::display()
{
	for (int i = 0; i < BD_SIZE * BD_SIZE; i++)
	{
		if (i % BD_SIZE == BD_SIZE - 1)
			cout << m_data[i] << endl;
		else
			cout << m_data[i] << " ";
	}
}

（3）边界条件的判定

void State::generateChildren(vector<State> &result)
{
	int iZero = -1;
	for (int i = 0; i < BD_SIZE * BD_SIZE; i++)
	{
		if (m_data[i] == 0)
			iZero = i;
	}
	//向上移动
	if (iZero >= BD_SIZE)
	{
		State child = *this;
		child.m_data[iZero] = child.m_data[iZero - BD_SIZE];
		child.m_data[iZero - BD_SIZE] = 0;
		result.push_back(child);//将child添加到该状态的子状态中来
	}
	//向下移动
	if (iZero<BD_SIZE*(BD_SIZE-1))
	{
		State child = *this;
		child.m_data[iZero] = child.m_data[iZero + BD_SIZE];
		child.m_data[iZero + BD_SIZE] = 0;
		result.push_back(child);//将child添加到该状态的子状态中来
	}
	//向左移动
	if (iZero%BD_SIZE!=0)
	{
		State child = *this;
		child.m_data[iZero] = child.m_data[iZero-1];
		child.m_data[iZero -1] = 0;
		result.push_back(child);//将child添加到该状态的子状态中来
	}
	//向右移动
	if (iZero % BD_SIZE != BD_SIZE-1)
	{
		State child = *this;
		child.m_data[iZero] = child.m_data[iZero + 1];
		child.m_data[iZero + 1] = 0;
		result.push_back(child);//将child添加到该状态的子状态中来
	}
}

（4）重载操作符判定是否相同

这一部除了可以重载操作符，还可以定义函数来实现，下面的代码是使用了重载操作符，参数为另一个状态，这里的输入应为终态；

bool State::operator==(State& rv)
{
	for (int i = 0; i < BD_SIZE * BD_SIZE; i++)
	{
		if (m_data[i] != rv.m_data[i])
			return false;
	}
	return true;
}

2、定义各个结点

（1）结点的构造函数定义

输出路径时，从子状态要访问父结点，所以在构建每一个结点时，一定要包括指向父结点的指针

定义的结点类如下

class Node
{
public:
	Node(State &state);
	Node(State& state,Node* m_pParent);
	State GetState() { return m_state; }
	void PrintPath();
private:
	State m_state;
	Node* m_pParent;
};

构造函数的实现如下

Node::Node(State &state):m_state(state),m_pParent(NULL)
{
}
Node::Node(State& state, Node* pParent) :m_state(state), m_pParent(pParent)
{
}

（2）输出具体的路径

这一步是该程序的重点，将其定义为结点类“Node”的函数，由终态对应的子结点出发，由下到上，逐层访问父结点，并将父结点从上到下依次输出，可以利用递归来实现，因为递归使用了栈这个数据结构，可以实现将路径从上往下输出。

void Node::PrintPath()
{
	if (m_pParent)//根结点的父节点不存在
	{
		m_pParent->PrintPath();
		m_state.display();
	}
	else
	{
		m_state.display();//展示根结点
	}
	cout << endl;
}

3、主函数的具体实现

（1）输入初态和终态

cout << "请输入初态：" << endl;
	State Ss;
	Ss.display();
	cout << "请输入终态：" << endl;
	State Sd;
	Sd.display();

（2）输出路径

if (Ss.operator==(Sd))
	{
		cout << "初态=终态！" << endl;
		return 0;
	}
	else//不相同
	{
		Node node_s(Ss);
		list<Node*> queue;
		queue.push_back(&node_s);//将初状态入队
		while (queue.size())
		{
			Node* pCurrent = queue.front();
			queue.pop_front();//删除队列头部元素并返回其值
			vector<State> children;//用动态数组来表示子状态
			pCurrent->GetState().generateChildren(children);
			for (int i = 0; i < children.size(); i++)
			{
				Node* pChild =new Node(children[i], pCurrent);
				if (children[i].operator==(Sd))
				{	
					cout << "路径如下" << endl;
					pChild->PrintPath();
					return 0;
				}
				queue.push_back(pChild);
			}
		}
		cout << "无解！" << endl;
	}

完整的代码

main.cpp

#include <iostream>
#include <list>
#include "State.h"
#include "node.h"
int main()
{
	cout << "请输入初态：" << endl;
	State Ss;
	Ss.display();
	cout << "请输入终态：" << endl;
	State Sd;
	Sd.display();
	if (Ss.operator==(Sd))
	{
		cout << "初态=终态！" << endl;
		return 0;
	}
	else//不相同
	{
		Node node_s(Ss);
		list<Node*> queue;
		queue.push_back(&node_s);//将初状态入队
		while (queue.size())
		{
			Node* pCurrent = queue.front();
			queue.pop_front();//删除队列头部元素并返回其值
			vector<State> children;//用动态数组来表示子状态
			pCurrent->GetState().generateChildren(children);
			for (int i = 0; i < children.size(); i++)
			{
				Node* pChild =new Node(children[i], pCurrent);
				if (children[i].operator==(Sd))
				{	
					cout << "路径如下" << endl;
					pChild->PrintPath();
					return 0;
				}
				queue.push_back(pChild);
			}
		}
		cout << "无解！" << endl;
	}
}

State.h

#pragma once
#ifndef STATE_H
#define STATE_H
#include <vector>
#define BD_SIZE 3
using namespace std;
class State
{
public:
	State();
	void display();
	void generateChildren(vector<State>& result);
	bool operator ==(State& rv);
private:
	int m_data[BD_SIZE * BD_SIZE];
};

#endif

State.cpp

#include <iostream>
#include "State.h"
using namespace std;
State::State()//按照一维数组进行输出
{
	for (int i = 0; i < BD_SIZE * BD_SIZE; i++)
	{
		cin >> m_data[i];
	}
}
void State::display()
{
	for (int i = 0; i < BD_SIZE * BD_SIZE; i++)
	{
		if (i % BD_SIZE == BD_SIZE - 1)
			cout << m_data[i] << endl;
		else
			cout << m_data[i] << " ";
	}
}
void State::generateChildren(vector<State> &result)
{
	int iZero = -1;
	for (int i = 0; i < BD_SIZE * BD_SIZE; i++)
	{
		if (m_data[i] == 0)
			iZero = i;
	}
	//向上移动
	if (iZero >= BD_SIZE)
	{
		State child = *this;
		child.m_data[iZero] = child.m_data[iZero - BD_SIZE];
		child.m_data[iZero - BD_SIZE] = 0;
		result.push_back(child);//将child添加到该状态的子状态中来
	}
	//向下移动
	if (iZero<BD_SIZE*(BD_SIZE-1))
	{
		State child = *this;
		child.m_data[iZero] = child.m_data[iZero + BD_SIZE];
		child.m_data[iZero + BD_SIZE] = 0;
		result.push_back(child);//将child添加到该状态的子状态中来
	}
	//向左移动
	if (iZero%BD_SIZE!=0)
	{
		State child = *this;
		child.m_data[iZero] = child.m_data[iZero-1];
		child.m_data[iZero -1] = 0;
		result.push_back(child);//将child添加到该状态的子状态中来
	}
	//向右移动
	if (iZero % BD_SIZE != BD_SIZE-1)
	{
		State child = *this;
		child.m_data[iZero] = child.m_data[iZero + 1];
		child.m_data[iZero + 1] = 0;
		result.push_back(child);//将child添加到该状态的子状态中来
	}
}
bool State::operator==(State& rv)
{
	for (int i = 0; i < BD_SIZE * BD_SIZE; i++)
	{
		if (m_data[i] != rv.m_data[i])
			return false;
	}
	return true;
}

node.h

#pragma once
#ifndef NODE_H
#include <iostream>
#include "State.h"
class Node
{
public:
	Node(State &state);
	Node(State& state,Node* m_pParent);
	State GetState() { return m_state; }
	void PrintPath();
private:
	State m_state;
	Node* m_pParent;
};
#define NODE_H
#endif // !NODE_H

node.cpp

#include <iostream>
#include "node.h"
#include <stack>
Node::Node(State &state):m_state(state),m_pParent(NULL)
{
}
Node::Node(State& state, Node* pParent) :m_state(state), m_pParent(pParent)
{
}
void Node::PrintPath()
{
	if (m_pParent)//根结点的父节点不存在
	{
		m_pParent->PrintPath();
		m_state.display();
	}
	else
	{
		m_state.display();//展示根结点
	}
	cout << endl;
}