百度编程大赛的9宫图代码及解析

最新推荐文章于 2021-10-08 16:18:41 发布

最新推荐文章于 2021-10-08 16:18:41 发布 · 185 阅读

本文详细介绍了使用深度优先搜索算法解决九宫格谜题的过程，包括类定义、状态编码与解码、BFS搜索算法实现及应用实例。通过编码和解码功能，将九宫格状态转换为整数进行搜索，有效解决了从初始状态到目标状态的路径寻找问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先放代码，算法设计过程我随后再放上去

//author:1025679612@qq.com

//csdn:http://blog.youkuaiyun.com/wind_2008_06_29/article/details/7706531

#include <iostream>
#include <list>
using std::cout;
using std::endl;
using std::cin;
using std::list;

bool	bVisitTag[387420489]=	{false};	//9^9用来表示其中的一种状态是否被访问过

//=========================================================================
//begin class	Point	define
//=========================================================================
class	Point{
public:
	Point();
	Point(const	Point&	rhs);
public:
	bool	operator==(const	Point&	rhs);
	bool	operator!=(const	Point&	rhs);
	Point&	operator= (const	Point&	rhs);
public:
	int		m_iRow;		//
	int		m_iCol;
};

Point::Point(){}

Point::Point(const	Point&	rhs){
	m_iRow		=rhs.m_iRow;
	m_iCol		=rhs.m_iCol;
}

bool	Point::operator!=(const	Point&	rhs){
	return	!operator==(rhs);
}

bool	Point::operator==(const	Point&	rhs){
	return	(m_iRow==	rhs.m_iRow)&&(m_iCol== rhs.m_iCol);
}

Point&	Point::operator= (const	Point&	rhs){
	m_iRow		=	rhs.m_iRow;
	m_iCol		=	rhs.m_iCol;
	return	*this;
}
//=========================================================================
//end of class	Point	define
//=========================================================================




//=========================================================================
//begin class	CState	define
//=========================================================================
class CState{			//存储9宫的状态
public:
	CState(const	CState&	rhs);
	CState();

public:
	CState&	operator=(const	CState&	rhs);
	bool	operator==(const	CState&	rhs);

public:
	int		vValue[3][3];
	Point	m_Center;	//我们设0的位置是Center
};

CState::CState(const CState& rhs):m_Center(rhs.m_Center){
	for(int iRow= 0; iRow< 3; ++iRow){
		for(int iCol= 0; iCol< 3; ++iCol)
			vValue[iRow][iCol]	=	rhs.vValue[iRow][iCol];
	}
}

CState::CState(){}

CState&	CState::operator= (const	CState&	rhs){
	m_Center		=	rhs.m_Center;
	for(int iRow= 0; iRow< 3; ++iRow){
		for(int iCol= 0; iCol< 3; ++iCol)
			vValue[iRow][iCol]	=	rhs.vValue[iRow][iCol];
	}
	return	*this;
}

bool	CState::operator==(const	CState&	rhs){
	if(m_Center !=	rhs.m_Center)
		return	false;
	for(int iRow= 0; iRow< 3; ++iRow){
		for(int iCol= 0; iCol< 3; ++iCol)
			if(vValue[iRow][iCol]	!=	rhs.vValue[iRow][iCol])
				return	false;
	}
	return	true;
}
//=========================================================================
//end of class	CState	define
//========================================================================= 


CState		StateBegin, StateEnd;	//开始和结束状态
int			Search();
int			StateToInt(const	CState&	state);//编码
CState		IntToState(int		iState);	   //解码


int	main(){
	for(int	iRow=	0; iRow< 3; ++iRow){
		for(int	iCol= 0; iCol< 3; ++iCol){
			cin>>StateBegin.vValue[iRow][iCol];
			if(StateBegin.vValue[iRow][iCol]== 0){
				StateBegin.m_Center.m_iRow=	iRow;
				StateBegin.m_Center.m_iCol=	iCol;
			}
		}
	}

	for(int	iRow=	0; iRow< 3; ++iRow){
		for(int	iCol= 0; iCol< 3; ++iCol){
			cin>>StateEnd.vValue[iRow][iCol];
			if(StateEnd.vValue[iRow][iCol]== 0){
				StateEnd.m_Center.m_iRow=	iRow;
				StateEnd.m_Center.m_iCol=	iCol;
			}
		}
	}
	cout<<Search()<<endl;
}


int			StateToInt(const	CState&	state){//编码
	int		iValue	=	0;
	for(int	iRow=	2; iRow>= 0; --iRow){
		for(int	iCol=2; iCol>= 0; --iCol){
			iValue*= 9;
			iValue+= state.vValue[iRow][iCol];
		}
	}
	return	iValue;
}

CState		IntToState(int		iState){	   //解码
	CState	state;
	for(int	iRow= 0; iRow< 3; ++iRow){
		for(int	iCol= 0; iCol< 3; ++iCol){
			state.vValue[iRow][iCol]	=	iState%9;
			iState/= 9;
			if(state.vValue[iRow][iCol]== 0){
				state.m_Center.m_iRow	=	iRow;
				state.m_Center.m_iCol	=	iCol;
			}
		}
	}
	return	state;
}

//=========================================================================
//BFS search
//========================================================================= 
int			Search(){
	list<CState>	buffer1, buffer2;
	int				iStep= 0;
	list<CState>	*lpListUsed;		//存放当前这一步
	list<CState>	*lpListNextStep;	//存放下一步
	if(StateBegin==	StateEnd)
		return	0;			//直接到达的话就是0了
	lpListUsed			=	&buffer1;
	lpListNextStep		=	&buffer2;
	lpListUsed->push_back(StateBegin);
	int		iPosition	=	StateToInt(StateBegin);
	bVisitTag[iPosition]		=	true;
	//bVisitTag[StateToInt(StateBegin)]=	true;	//打标记
	while(!lpListUsed->empty()){
		CState	StateNow;
		CState	StateNext;
		++iStep;
		while(!lpListUsed->empty()){
			StateNow=	lpListUsed->front();
			lpListUsed->pop_front();
			if(StateNow==	StateEnd){
				return	iStep-1;
			}
			if(StateNow.m_Center.m_iRow-1>= 0){
				StateNext	=	StateNow;
				--StateNext.m_Center.m_iRow;
				StateNext.vValue[StateNow.m_Center.m_iRow][StateNow.m_Center.m_iCol]	=StateNow.vValue[StateNext.m_Center.m_iRow][StateNext.m_Center.m_iCol];
				StateNext.vValue[StateNext.m_Center.m_iRow][StateNext.m_Center.m_iCol]	=	0;
				int	iPosition	=	StateToInt(StateNext);
				if(!bVisitTag[iPosition]){
					bVisitTag[iPosition]=	true;
					lpListNextStep->push_back(StateNext);
				}
			}
			if(StateNow.m_Center.m_iRow+1< 3){
				StateNext	=	StateNow;
				++StateNext.m_Center.m_iRow;
				StateNext.vValue[StateNow.m_Center.m_iRow][StateNow.m_Center.m_iCol]	=StateNow.vValue[StateNext.m_Center.m_iRow][StateNext.m_Center.m_iCol];
				StateNext.vValue[StateNext.m_Center.m_iRow][StateNext.m_Center.m_iCol]	=	0;
				int	iPosition	=	StateToInt(StateNext);
				if(!bVisitTag[iPosition]){
					bVisitTag[iPosition]=	true;
					lpListNextStep->push_back(StateNext);
				}
			}
			if(StateNow.m_Center.m_iCol-1>= 0){
				StateNext	=	StateNow;
				--StateNext.m_Center.m_iCol;
				StateNext.vValue[StateNow.m_Center.m_iRow][StateNow.m_Center.m_iCol]	=StateNow.vValue[StateNext.m_Center.m_iRow][StateNext.m_Center.m_iCol];
				StateNext.vValue[StateNext.m_Center.m_iRow][StateNext.m_Center.m_iCol]	=	0;
				int	iPosition	=	StateToInt(StateNext);
				if(!bVisitTag[iPosition]){
					bVisitTag[iPosition]=	true;
					lpListNextStep->push_back(StateNext);
				}
			}
			if(StateNow.m_Center.m_iCol+1< 3){
				StateNext	=	StateNow;
				++StateNext.m_Center.m_iCol;
				StateNext.vValue[StateNow.m_Center.m_iRow][StateNow.m_Center.m_iCol]	=StateNow.vValue[StateNext.m_Center.m_iRow][StateNext.m_Center.m_iCol];
				StateNext.vValue[StateNext.m_Center.m_iRow][StateNext.m_Center.m_iCol]	=	0;
				int	iPosition	=	StateToInt(StateNext);
				if(!bVisitTag[iPosition]){
					bVisitTag[iPosition]=	true;
					lpListNextStep->push_back(StateNext);
				}
			}
		}
		std::swap(lpListUsed, lpListNextStep);
	}
	return	-1;
}