华容道（huarongdao）C++ BFS求解

已于 2023-05-03 23:45:33 修改
阅读量466 收藏 6
点赞数
文章标签： c++ 算法 bfs
于 2023-04-30 00:46:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/myccmj/article/details/130445502
版权

用C++编了个解传统益智游戏华容道的程序，不到1s可给出横刀立马通关步骤。主要用到bfs加上记录已遇到的局面（包括其对称的局面）帮助剪枝。简单修改初始化可解其它初始排布下的华容道。

 上图即为横刀立马开局

#include <bits/stdc++.h>
using namespace std;

const int M=5,N=4;
const int caocao_qzIdx=1;
const string NAME[10]={"张飞","曹操","马超","黄忠","关羽","赵云","兵","兵","兵","兵"};
string templateStrMap="";
inline int e(int i,int j)
{
	return i*N+j;
}
struct QZ{
	int m=1,n=1;
	int i=0,j=0;
	int type=1,id=0;
	string name;
	QZ()
	{
	}
	QZ(int _m,int _n,int _i,int _j,int _id=0)
	{
		m=_m;
		n=_n;
		i=_i;
		j=_j;
		if(m==1)
		{
			if(n==1)
				type=1;
			else
				type=3;
		}
		else
		{
			if(n==1)
				type=2;
			else
				type=4;
		}
		id=_id;
		name=NAME[id];
	}
	void set(int _m,int _n,int _i,int _j)
	{
		m=_m;
		n=_n;
		i=_i;
		j=_j;
		if(m==1)
		{
			if(n==1)
				type=1;
			else
				type=3;
		}
		else
		{
			if(n==1)
				type=2;
			else
				type=4;
		}
	}
};
struct Move{
	int qzIdx,dir;
	string lastStrMap;
	vector<QZ> lastQZs;
};
map<string,Move> path;
void print(int Map[M][N])
{
			for(int i=0;i<M;i++)
		{
		
			for(int j=0;j<N;j++)
			{
				cout<<Map[i][j]<<" ";
			}
			cout<<endl;
		}
	cout<<endl;
}
void print(vector<QZ> &QZs)
{
	for(int i=0;i<QZs.size();i++)
	{
		QZ &tmp=QZs[i];
		cout<<"i,j:"<<tmp.i<<","<<tmp.j<<" m,n:"<<tmp.m<<","<<tmp.n<<" "<<tmp.type<<endl;
	}
}
void print(string &s)
{
	for(int i=0;i<M;i++)
	{
		for(int j=0;j<N;j++)
		{
			cout<<int(s[e(i,j)])<<" ";
		}
		cout<<endl;
	}
	cout<<endl;
}
struct MAP{
	//int Map[M][N]={{2,4,4,2},{2,4,4,2},{2,3,3,2},{2,1,1,2},{1,0,0,1}};//0为空，1为1*1的兵，2为2*1的武将，3为1*2的武将，4为2*2的曹操
	string strMap="2442;2442;2332;2112;1001";
	vector<QZ> QZs;
	int d=0;
	MAP()
	{
		QZs.push_back(QZ(2,1,0,0,0));
		QZs.push_back(QZ(2,2,0,1,1));
		QZs.push_back(QZ(2,1,0,3,2));
		QZs.push_back(QZ(2,1,2,0,3));
		QZs.push_back(QZ(1,2,2,1,4));
		QZs.push_back(QZ(2,1,2,3,5));
		QZs.push_back(QZ(1,1,3,1,6));
		QZs.push_back(QZ(1,1,3,2,7));
		QZs.push_back(QZ(1,1,4,0,8));
		QZs.push_back(QZ(1,1,4,3,9));
	}
	MAP(string &s,vector<QZ> &_QZs,int _d=0)
	{
		strMap=s;
		QZs=_QZs;
		d=_d; 
	}

	void testQZs()
	{
		int map1[M][N]={0};
		for(int i=0;i<QZs.size();i++)
		{
			QZ &temp=QZs[i];
			for(int I=0;I<temp.m;I++)
				for(int J=0;J<temp.n;J++)
					map1[temp.i+I][temp.j+J]=temp.m+0.1*temp.n;
		}
		print(map1);
	}
	//0为左，1为上，2为右，3为下 
	bool ifmove(int QZ_idx,int dir)
	{
		QZ &temp=QZs[QZ_idx];
		int i=temp.i,j=temp.j,m=temp.m,n=temp.n;
		//cout<<"ifmove:"<<i<<" "<<j<<" "<<dir<<endl;
		if(dir==0)
		{
			if(j>0&&strMap[e(i,j-1)]==0)
			{
				if(temp.m==1||strMap[e(i+1,j-1)]==0)
					return true;
			}
		}
		else if(dir==1)
		{
			if(i>0&&strMap[e(i-1,j)]==0)
			{
				if(temp.n==1||strMap[e(i-1,j+1)]==0)
					return true;
			}
		}
		else if(dir==2)
		{
			if(m==1)
			{
				if(n==1)
				{
					if(j+1<N&&strMap[e(i,j+1)]==0)
						return true;
				}
				else
				{
					if(j+2<N&&strMap[e(i,j+2)]==0)
						return true;
				}
			}
			else
			{
				if(n==1)
				{
					if(j+1<N&&strMap[e(i,j+1)]==0&&strMap[e(i+1,j+1)]==0)
						return true;
				}
				else
				{
					if(j+2<N&&strMap[e(i,j+2)]==0&&strMap[e(i+1,j+2)]==0)
						return true;
				}
			}
		}
		else
		{
			if(m==1)
			{
				if(n==1)
				{
					if(i+1<M&&strMap[e(i+1,j)]==0)
						return true;
				}
				else
				{
					if(i+1<M&&strMap[e(i+1,j)]==0&&strMap[e(i+1,j+1)]==0)
						return true;
				}
			}
			else
			{
				if(n==1)
				{
					if(i+2<M&&strMap[e(i+2,j)]==0)
						return true;
				}
				else
				{
					if(i+2<M&&strMap[e(i+2,j)]==0&&strMap[e(i+2,j+1)]==0)
						return true;
				}
			}
		}
		return false;
	}
	void move(int QZ_idx,int dir)
	{
		QZ &temp=QZs[QZ_idx];
		string &tmpMap=strMap;
		for(int i=0;i<temp.m;i++)
			for(int j=0;j<temp.n;j++)
			{
				int I=temp.i+i,J=temp.j+j;
				tmpMap[e(I,J)]=0;
			}
		for(int i=0;i<temp.m;i++)
			for(int j=0;j<temp.n;j++)
			{
				int I=temp.i+i,J=temp.j+j;
				if(dir==0)
				{
					tmpMap[e(I,J-1)]=temp.type;

				}
				else if(dir==1)
				{
					tmpMap[e(I-1,J)]=temp.type;

				}
				else if(dir==2)
				{
					tmpMap[e(I,J+1)]=temp.type;

				}
				else
				{
					tmpMap[e(I+1,J)]=temp.type;
				}
			}
		if(dir==0)
				{
					temp.j--;

				}
				else if(dir==1)
				{
					temp.i--;

				}
				else if(dir==2)
				{
					temp.j++;

				}
				else
				{
					temp.i++;
				}
		
	}
	string move2string(int QZ_idx,int dir)
	{
		QZ &temp=QZs[QZ_idx];
		string tmpMap=strMap;
		for(int i=0;i<temp.m;i++)
			for(int j=0;j<temp.n;j++)
			{
				int I=temp.i+i,J=temp.j+j;
				tmpMap[e(I,J)]=0;
			}
			for(int i=0;i<temp.m;i++)
			for(int j=0;j<temp.n;j++)
			{
				int I=temp.i+i,J=temp.j+j;
				if(dir==0)
				{
					tmpMap[e(I,J-1)]=temp.type;

				}
				else if(dir==1)
				{
					tmpMap[e(I-1,J)]=temp.type;

				}
				else if(dir==2)
				{
					tmpMap[e(I,J+1)]=temp.type;

				}
				else
				{
					tmpMap[e(I+1,J)]=temp.type;
				}
			}
			//cout<<"finish"<<endl;
			return tmpMap;
		
	}
//	string genString()
//	{
//		string s="";
//		for(int i=0;i<M;i++)
//		{
//			for(int j=0;j<N;j++)
//			{
//				s+=to_string(int(Map[i][j]));
//			}
//			s+=";";
//		}
//		return s;
//	}
	string genString(int _Map[M][N])
	{
		string s="";
		for(int i=0;i<M;i++)
		{
			for(int j=0;j<N;j++)
			{
				s+=int(_Map[i][j]);
			}
		}
		//cout<<"s finish"<<endl;
		return s;
	}
	void genMap(string &s)
	{
		int Map[M][N]={0};
		for(int i=0;i<M;i++)
			for(int j=0;j<N;j++)
			{
				int idx=i*N+j;
				Map[i][j]=s[idx];
			}
	}
//	void genQZs()
//	{
//		int tmpMap[M][N];
//		memcpy(tmpMap,Map,sizeof(Map));
//		int I=0;
//		for(int i=0;i<M;i++)
//			for(int j=0;j<N;j++)
//			{
//				if(tmpMap[i][j]==2)
//				{
//					tmpMap[i+1][j]=-2;
//					QZs[I++].set(2,1,i,j);
//				}
//				else if(tmpMap[i][j]==4)
//				{
//					tmpMap[i][j+1]=-4;
//					tmpMap[i+1][j+1]=-4;
//					tmpMap[i+1][j]=-4;
//					QZs[I++].set(2,2,i,j);
//					caocao_qzIdx=I-1;
//				}
//				else if(tmpMap[i][j]==3)
//				{
//					tmpMap[i][j+1]=-3;
//					QZs[I++].set(1,2,i,j);
//				}
//				else if(tmpMap[i][j]==1)
//				{
//					QZs[I++].set(1,1,i,j);
//				}
//			}
//	}
	bool ifEnd()
	{
		QZ &temp=QZs[caocao_qzIdx];
		if(temp.i==3&&temp.j==1)
			return true;
		return false;
	}
}mymap;

string mirror(string &s)
{
	string s1=s;
	for(int i=0;i<M;i++)
		for(int j=0;j<N;j++)
		{
			s1[e(i,N-j-1)]=s[e(i,j)];
		}
	return s1;
}
string genResStr(vector<QZ> &QZs)
{
	string s=templateStrMap;
	for(int I=0;I<QZs.size();I++)
	{
		QZ &q=QZs[I];
		int i=q.i,j=q.j;
		if(q.type==1)
		{
			s.replace(i*(2*N+1)+2*j,2,"兵"); 
		}
		else if(q.type==2)
		{
			s.replace(i*(2*N+1)+2*j,2,q.name.substr(0,2)); 
			s.replace((i+1)*(2*N+1)+2*j,2,q.name.substr(2,2)); 
		}
		else if(q.type==3)
		{
			s.replace(i*(2*N+1)+2*j,2,q.name.substr(0,2)); 
			s.replace(i*(2*N+1)+2*(j+1),2,q.name.substr(2,2)); 
		}
		else
		{
			s.replace(i*(2*N+1)+2*j,4,q.name); 
			s.replace((i+1)*(2*N+1)+2*j,4,q.name); 
		}
	}
	return s;
}
void writeRes(vector<Move> &resPath)
{
	ofstream wr;
	wr.open("hrd_out.txt",ios::app);
	for(int i=resPath.size()-1;i>=0;i--)
	{
		Move &m=resPath[i];
		for(int i=0;i<M;i++)
		{
			for(int j=0;j<N;j++)
			{
				
			}
			wr<<endl;
		}
	}
} 
string bfs()
{
	queue<MAP> q;
	q.push(mymap);
	unordered_set<string> visited;
	visited.insert(mymap.strMap);
	int D=0;
	while(!q.empty())
	{
		MAP tmpNode=q.front();
		string &s0=tmpNode.strMap;
		//print(s0);
		vector<QZ> &QZs=tmpNode.QZs;
		//print(QZs);
		int d=tmpNode.d;
		q.pop();
		if(d>D)
		{
			D=d;
			cout<<d<<endl;
		}
		if(tmpNode.ifEnd())
		{
			return s0;
		}
		for(int i=0;i<QZs.size();i++)
		{
			QZ &temp=QZs[i];
			//cout<<"i="<<i<<endl;
			for(int dir=0;dir<4;dir++)
			{
				//cout<<"dir"<<dir<<endl;
				if(tmpNode.ifmove(i,dir))
				{
					//cout<<temp.i<<" "<<temp.j<<" "<<dir<<endl;
					//mymap.move(i,dir);
					string s1=tmpNode.move2string(i,dir);
					//cout<<"next"<<endl;
					if(!visited.count(s1))
					{
						//cout<<"next0"<<endl;
						visited.insert(s1);
						visited.insert(mirror(s1));
						path[s1]={i,dir,s0,QZs};
						MAP map1(s1,QZs,d+1);
						QZ &temp1=map1.QZs[i]; 
						if(dir==0)
						{
							temp1.j--;
		
						}
						else if(dir==1)
						{
							temp1.i--;
		
						}
						else if(dir==2)
						{
							temp1.j++;
		
						}
						else
						{
							temp1.i++;
						}
						if(map1.ifEnd())
						{
							return s1;
						}
						q.push(map1);
						//cout<<s1<<endl;
						//cout<<"next1"<<endl;
					}

				}
			}
		}
	}
}



int main()
{
	
	cout<<"huarongdao"<<endl;
	//mymap.testQZs();
	int Map[M][N]={{2,4,4,2},{2,4,4,2},{2,3,3,2},{2,1,1,2},{1,0,0,1}};
	for(int i=0;i<M;i++)
	{
		for(int j=0;j<N;j++)
		{ 
			mymap.strMap[e(i,j)]=Map[i][j];
			templateStrMap+="  ";
		} 
		templateStrMap+="\n";
	}
	//string s1="2442;2442;2332;2112;0110";
	//mymap.strMap=s1;
	//mymap.genMap(mymap.strMap);
	//mymap.genQZs();
	print(mymap.strMap);
	cout<<endl;
	cout<<templateStrMap;
	cout<<genResStr(mymap.QZs)<<endl; 
//	for(int I=0;I<2;I++)
//	for(int i=0;i<mymap.QZs.size();i++)
//	{
//		QZ &temp=mymap.QZs[i];
//		for(int dir=0;dir<4;dir++)
//		{
//		
//		if(mymap.ifmove(i,dir))
//		{
//		cout<<temp.i<<" "<<temp.j<<" "<<dir<<endl;
//			mymap.move(i,dir);
//			
//			print(mymap.strMap);
//			print(mymap.QZs);
//			cout<<endl;
//		}
//	}
//	}
	string s=bfs();
	print(s);
	vector<Move> resPath;
	while(path.count(s))
	{
		resPath.push_back(path[s]);
		s=path[s].lastStrMap;
	} 
	for(int i=resPath.size()-1;i>=0;i--)
	{
		cout<<genResStr(resPath[i].lastQZs)<<endl;
	}
	return 0;
}

myccmj
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++的华容道解法
10-11
这是几年前写的一个程序，可以实现功能，速度也很快。界面直接用window API写的。生成的可执行文件很小，另外，在程序中可以自定义布局，用5*4数表示。其中0-空格，1-卒子，2到6 将，7曹操。
华容道算法简洁版
03-21
华容道算法简洁版，
华容道解法（1）——横刀立马
夏敏捷的专栏
06-18 4907
华容道解法（1）——横刀立马首先规定一下棋子的名称：最大的“曹”，横着放的关羽的“关”，竖着放的张飞的“飞”，最小的“兵”。一个棋子一次能作的最大移动算一步（折线算一步），两个棋子同时移动算两步。横刀立马 81步兵左1格，飞下，关右，兵下，飞右，兵上1格，兵左，飞下，关左，兵上折右，兵上，飞右，兵右折下，关下，二兵左，二飞上，二兵右，关下，兵下折左，二飞左，飞下，曹右，飞右
华容道
weixin_34029680的博客
08-24 182
描述 小 B 最近迷上了华容道，可是他总是要花很长的时间才能完成一次。于是，他想到用编程来完成华容道：给定一种局面，华容道是否根本就无法完成，如果能完成，最少需要多少时间。 小 B 玩的华容道与经典的华容道游戏略有不同，游戏规则是这样的： 在一个 n*m 棋盘上有 n*m 个格子，其中有且只有一个格子是空白的，其余 n*m-1个格子上每个格子上有一个棋子，每个棋子的大小都是 ...
Python三国华容道程序-广度优先
CQZHOUZR的博客
12-16 1472
上文完成了Python用深度优先算法求解三国华容道，本文在上文的基础上，将算法改为广度优先的算法，深度优先算法可以获得较快的求解速度，但棋子移动步骤较长。广度优先算法可以获得较短的移动步骤，但求解速度较慢。
NOIP2013华容道（BFS+乱搞）
weixin_33682719的博客
09-01 115
n<=30 * m<=30 的地图上，0表示墙壁，1表示可以放箱子的空地。q<=500次询问，每次问：当空地上唯一没有放箱子的空格子在(ex,ey)时，把位于(sx,sy)的箱子移动到(tx,ty)的最小步数。 Solution 一开始听说这道题很难，所以刚拿到题就开始打暴力，emmm。。。 比较。。。。。的思路是记录当前点的位置和空白点的位置，然后暴力转移。 但这个状态...
华容道(C++版)
qq_41788234的博客
06-21 7344
大一结束，为了检验自身实力，专业内的任务是实现华容道最快求解。这里我只针对华容道经典棋局--横刀立马进行分析。 一.棋子设置 华容道棋子 主要有五种：曹操，横将，竖将，小兵，空格。对于移动的方法，有两种：一，移动空格；二，移动棋子。相对于效率来说，移动空格会更快一点，我才用的就是移动空格。至于设置棋盘，可以建立节点存储一个棋盘，棋盘可以有三种形式：二维数组，一维数组，一个lon...
重构华容道自动求解
mu399的专栏
12-31 2575
之前的关于华容道自动求解的代码，变量名的命名很不规范，结构也不太容易理解，过一段时间后，重新来看，又会不知道以前的代码的意思了，明明之前已经看懂，结果现在又不懂了，很浪费时间。所以，应该自己再来针对代码的可读写进行重构。package game.hrd.game.hrd.refactor;import java.util.ArrayList;/** * Created by huangcongji
八数码、解华容道(bfs，全局择先，A*搜索)
shengshanlaolin_的博客
06-30 920
数阵问题 每个局面是三行三列的数字方阵，每个位置为0-8的一个数码且互不相同，求从初始局面（自己设定）如何“最快”移动到终止局面（自己设定）。 移动规则：每次只能0与其上下左右四个方向相邻的某个数字交换！可能有解，可能无解。
经典华容道游戏(含bfs求解)
qq_63000037的博客
11-25 1218
这是数据结构的课设作业，也是我第一次写的千行代码小游戏。学习EasyX图形库+写完程序一共用了三天时间，可以说是相当熬人了。当然，第一次写，难免不怎么好，比如无动画、无音乐、丑得不行的ui等等，体验时请多多海涵。（下载链接见文章末尾）算法思路bfs思路：先通过bfs找到胜利局面状态，在过程中记录每个状态的经怎样的操作由上一个状态转换而来(即from)；在知道有解后，由胜利状态通过from递归至初始状态，其中经过的状态作为元素压入栈中，输出该栈便得到解法。
C/C++项目实战：华容道游戏开发丨570 行源码分享来啦~
致力于C语言C++知识分享！
01-11 2160
通过移动各个棋子，帮助曹操从初始位置移到棋盘最下方中部，从出口逃走。不允许跨越棋子，还要设法用最少的步数把曹操移到出口。
八数码问题（数字华容道，九宫格）深度搜索（DFS）广度搜索（BFS）和A*算法C++源码
03-27
本C++代码解决了八数码问题，采用深度优先，广度优先和A*算法实现，基于visual studio 2017
华容道游戏求解最少步骤C++
01-06
华容道游戏求解最少步骤C++
华容道游戏 VC++
03-04
用VC++编写的一个华容道游戏，可以选关，每一关有不同的时间限制......
简单的华容道算法c++实现
12-02
参考网上资料写的很烂的算法，运算时间很长，用了一个链表树的结构，穷举棋盘状态并进行结果判断和重复性判断，未用到哈希表结构所以时间很长。
huarongdao.rar_华容道
09-21
此压缩包“huarongdao.rar”中包含的“华容道算法.txt”文件，是对华容道游戏的一种编程实现的源代码。 首先，我们来分析华容道的基本规则：棋盘上有一块代表曹操的大块，周围有若干小块代表不同的武将，目标是通过...
huarongdao.zip_华容道
09-21
本文将详细介绍如何通过C++语言编写一个简单的华容道程序。 首先，我们要理解华容道的游戏规则。华容道的棋盘通常由15个格子组成，其中有一个空格，其余14块木块上分别刻有数字或文字，目标是通过移动其他木块，...
HuaRongDao.rar_华容道 jar 7723
09-23
总结来说，"HuaRongDao.jar_华容道 7723"是一个利用Java语言开发的华容道游戏应用，它展示了Java在游戏开发领域的应用，以及如何通过编程实现经典游戏的现代化。其中的后退功能是其亮点之一，体现了编程中状态管理和...
huarongdao.rar_华容道_华容道游戏
09-14
本文将以“huarongdao.rar”这个压缩包中的“huarongdao.c”源代码文件为例，详细解析华容道游戏的开发过程和关键技术。 首先，我们要理解游戏的基本规则。华容道游戏的目标是通过移动棋盘上的棋子，使得曹操从起始...
bfs算法可用来求解华容道的最小解吗
最新发布
01-12
BFS算法（广度优先搜索算法）可以用来求解华容道的最小解。华容道是一种经典的益智游戏，目标是将一组方块按照规定的顺序和方向移动，最终将特定的方块移动到指定位置，形成特定的图案或排列。 BFS算法是一种在图或树结构上进行搜索的算法，它从起始顶点开始，逐层遍历相邻的顶点，直到找到目标顶点为止。在华容道中，我们可以将每个游戏状态（即方块的排列）看作图中的一个顶点，而每次移动操作可以看作是从一个顶点到另一个相邻的顶点的一条边。 使用BFS算法，我们可以从初始状态开始，逐步搜索所有可能的移动路径，直到找到最优解为止。由于BFS算法的特性，它能够保证找到的解一定是最短的，因此可以用来求解华容道的最小解。 总之，BFS算法可以有效地应用于求解华容道的最小解，通过逐层搜索所有可能的移动路径，最终找到最优解。通过合理的建模和算法设计，我们可以利用BFS算法来帮助解决华容道这类益智游戏，为玩家提供更好的游戏体验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值