八数码问题（C++）

已于 2022-07-03 15:24:17 修改
阅读量2.5k 收藏 20
点赞数 2
分类专栏： c++ 文章标签： c++ 算法
于 2022-07-03 15:17:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44757221/article/details/125584530
版权

问题描述

在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始状态和目标状态，找到一种最少步骤的移动方法，实现从初始状态到目标状态的转变。
例如：
在这里插入图片描述

输入样例：

输入棋子在棋盘的初始状态及目标状态，注第一个3×3为初始状态，第二个3×3为目标状态，且数字之间以空格分开，如：

3 1 2
4 0 5
6 7 8
0 1 2
3 4 5
6 7 8

输出样例：

输出棋盘初始状态及每步的移动结果，直到目标状态，如：

initial
3 1 2
4 0 5
6 7 8

step 1
3 1 2
0 4 5
6 7 8
step 2
0 1 2
3 4 5
6 7 8

总代码

1.盲搜（无向导搜索）
采用广搜的方法，实现无向导搜索。

#include<iostream>
#include<map>
#include<queue>

using namespace std;

queue<int>Qtmp;
map<int,int>pointex;
map<int,int>count;
map<int,int>qifazhi;
map<int,int>pointdir;
int resultsum[100];

int dir[4][2]={-1,0,0,1,1,0,0,-1};
int point[3][3];
int r,c;

int qifa(int sum0,int end0){
    int result=0;
    if((sum0/100000000==0)&&(end0/100000000==0)){
        result++;
    }
    while((sum0%10!=0)&&(end0%10!=0)&&(sum0/10!=0)){
        if(sum0%10==end0%10){
            result++;
        }
        sum0=sum0/10;
        end0=end0/10;
    }
    return result;
}

int move(int u,int d)
{
	int tmp=0;      
	int nr=r+dir[d][0];
	int nc=c+dir[d][1];
	point[r][c]=point[nr][nc];
	point[nr][nc]=0;
	for(int i=0;i<3;i++)
	{
		for(int j=0;j<3;j++)
			tmp=tmp*10+point[i][j];
	}
	return tmp;
}

int formulate(int s,int endsum0)
{
	Qtmp.push(s);
	pointex[s]=1;
	count[s]=0;
    int number=0;
	while(Qtmp.size())
	{
		int u,v;
		u=Qtmp.front();
		Qtmp.pop();
		if(u==endsum0){
            return count[u];
        }
        int minqifa=move(u,0);
		for(int i=0;i<4;i++)
		{
			bool fool=true;
			int uu=u;
				for(int ii=2;ii>=0;ii--)
	{
		for(int jj=2;jj>=0;jj--)
		{
			point[ii][jj]=uu%10;
			uu/=10;
			if(point[ii][jj]==0)
			{
				r=ii;
				c=jj;
			}
		}
	}
	if((i==0&&r==0)||(i==1&&c==2)||(i==2&&r==2)||(i==3&&c==0)){
		fool=false;
	}

			if(fool)
			{
				v=move(u,i);
                
				if(!pointex[v])
				{
                    int qifatmp=qifa(v,endsum0);
                    if(qifatmp<=minqifa){
                        pointex[v]=1;
					    count[v]=count[u]+1;
                        pointdir[v]=i;
					    Qtmp.push(v);
                        number++;
                    }
				}
			}
		}
        if(number>100){
            return -1;
        }
	}
	return -1;
}

int main()
{
    int end[3][3];
    int endsum=0;
    int beginsum=0;
    int result;
    for(int i=0;i<3;i++){
		for(int j=0;j<3;j++)
		{
			cin>>point[i][j];
			beginsum=beginsum*10+point[i][j];
		}
    }
    for(int i=0;i<3;i++){
		for(int j=0;j<3;j++)
		{
			cin>>end[i][j];
			endsum=endsum*10+end[i][j];
		}
    }
    result=formulate(beginsum,endsum);
    resultsum[result+1]=endsum;
    int endr0,endc0;
    int temp=endsum;
    for(int i=2;i>=0;i--)
	{
		for(int j=2;j>=0;j--)
		{
			end[i][j]=temp%10;
			temp/=10;
			if(end[i][j]==0)
			{
				endr0=i;
				endc0=j;
			}
		}
	}
    int tmpsum;
    //cout<<result<<endl;
    if(result==-1){
        cout<<"no answer"<<endl;
    }
    if(result!=-1){
        for(int i=result;i>0;i--){
            if(pointdir[endsum]==0){
                end[endr0][endc0]=end[endr0+1][endc0];
                end[endr0+1][endc0]=0;
                tmpsum=end[0][0]*100000000+end[0][1]*10000000+end[0][2]*1000000+end[1][0]*100000+end[1][1]*10000+end[1][2]*1000+end[2][0]*100+end[2][1]*10+end[2][2];
                resultsum[i]=tmpsum;
                endr0=endr0+1;
            }
            if(pointdir[endsum]==1){
                end[endr0][endc0]=end[endr0][endc0-1];
                end[endr0][endc0-1]=0;
                tmpsum=end[0][0]*100000000+end[0][1]*10000000+end[0][2]*1000000+end[1][0]*100000+end[1][1]*10000+end[1][2]*1000+end[2][0]*100+end[2][1]*10+end[2][2];
                resultsum[i]=tmpsum;
                endc0=endc0-1;
            }
            if(pointdir[endsum]==2){
                end[endr0][endc0]=end[endr0-1][endc0];
                end[endr0-1][endc0]=0;
                tmpsum=end[0][0]*100000000+end[0][1]*10000000+end[0][2]*1000000+end[1][0]*100000+end[1][1]*10000+end[1][2]*1000+end[2][0]*100+end[2][1]*10+end[2][2];
                resultsum[i]=tmpsum;
                endr0=endr0-1;
            }
            if(pointdir[endsum]==3){
                end[endr0][endc0]=end[endr0][endc0+1];
                end[endr0][endc0+1]=0;
                tmpsum=end[0][0]*100000000+end[0][1]*10000000+end[0][2]*1000000+end[1][0]*100000+end[1][1]*10000+end[1][2]*1000+end[2][0]*100+end[2][1]*10+end[2][2];
                resultsum[i]=tmpsum;
                endc0=endc0+1;
            }
            endsum=tmpsum;
        }
    for(int i=1;i<result+2;i++){
        if(i==1){
            cout<<"initial"<<endl;
        }
        else{
            cout<<"step "<<i-1<<endl;
        }
        int k=0;
        for(int j=100000000;j>0;j=j/10){
            cout<<resultsum[i]/j<<" ";
            resultsum[i]=resultsum[i]-resultsum[i]/j*j;
            k++;
            if(k%3==0){
                cout<<endl;
            }
        }
        cout<<endl;
    }
    }
    system("pause");
    return 0;
}

2.启发式搜索（有向导搜索）
新增启发函数，实现有向导搜索，大大减少搜索时间。

#include<iostream>
#include<map>
#include<queue>

using namespace std;

queue<int>Qtmp;
map<int,int>pointex;
map<int,int>count;
map<int,int>pointdir;
int resultsum[100];

int dir[4][2]={-1,0,0,1,1,0,0,-1};
int point[3][3];
int r,c;

int qifa(int sum0,int end0){
    int result=0;
    if((sum0/100000000==0)&&(end0/100000000==0)){
        result++;
    }
    while((sum0%10!=0)&&(end0%10!=0)&&(sum0/10!=0)){
        if(sum0%10==end0%10){
            result++;
        }
        sum0=sum0/10;
        end0=end0/10;
    }
    return result;
}

int move(int u,int d)
{
	int tmp=0;      
	int nr=r+dir[d][0];
	int nc=c+dir[d][1];
	point[r][c]=point[nr][nc];
	point[nr][nc]=0;
	for(int i=0;i<3;i++)
	{
		for(int j=0;j<3;j++)
			tmp=tmp*10+point[i][j];
	}
	return tmp;
}

int formulate(int s,int endsum0)
{
	Qtmp.push(s);
	pointex[s]=1;
	count[s]=0;
    int number=0;
	while(Qtmp.size())
	{
		int u,v;
		u=Qtmp.front();
		Qtmp.pop();
		if(u==endsum0){
            return count[u];
        }
        int minqifa=100;
		for(int i=0;i<4;i++)
		{
			bool fool=true;
			int uu=u;
				for(int ii=2;ii>=0;ii--)
	{
		for(int jj=2;jj>=0;jj--)
		{
			point[ii][jj]=uu%10;
			uu/=10;
			if(point[ii][jj]==0)
			{
				r=ii;
				c=jj;
			}
		}
	}
	if((i==0&&r==0)||(i==1&&c==2)||(i==2&&r==2)||(i==3&&c==0)){
		fool=false;
	}

			if(fool)
			{
				v=move(u,i);
                
				if(!pointex[v])
				{
                    int qifatmp=qifa(v,endsum0);
                    if(qifatmp<=minqifa){
                        minqifa=qifatmp;
                        pointex[v]=1;
					    count[v]=count[u]+1;
                        pointdir[v]=i;
					    Qtmp.push(v);
                        number++;
                    }
				}
			}
		}
        if(number>100){
            return -1;
        }
	}
	return -1;
}

int main()
{
    int end[3][3];
    int endsum=0;
    int beginsum=0;
    int result;
    for(int i=0;i<3;i++){
		for(int j=0;j<3;j++)
		{
			cin>>point[i][j];
			beginsum=beginsum*10+point[i][j];
		}
    }
    for(int i=0;i<3;i++){
		for(int j=0;j<3;j++)
		{
			cin>>end[i][j];
			endsum=endsum*10+end[i][j];
		}
    }
    result=formulate(beginsum,endsum);
    resultsum[result+1]=endsum;
    int endr0,endc0;
    int temp=endsum;
    for(int i=2;i>=0;i--)
	{
		for(int j=2;j>=0;j--)
		{
			end[i][j]=temp%10;
			temp/=10;
			if(end[i][j]==0)
			{
				endr0=i;
				endc0=j;
			}
		}
	}
    int tmpsum;
    //cout<<result<<endl;
    if(result==-1){
        cout<<"no answer"<<endl;
    }
    if(result!=-1){
        for(int i=result;i>0;i--){
            if(pointdir[endsum]==0){
                end[endr0][endc0]=end[endr0+1][endc0];
                end[endr0+1][endc0]=0;
                tmpsum=end[0][0]*100000000+end[0][1]*10000000+end[0][2]*1000000+end[1][0]*100000+end[1][1]*10000+end[1][2]*1000+end[2][0]*100+end[2][1]*10+end[2][2];
                resultsum[i]=tmpsum;
                endr0=endr0+1;
            }
            if(pointdir[endsum]==1){
                end[endr0][endc0]=end[endr0][endc0-1];
                end[endr0][endc0-1]=0;
                tmpsum=end[0][0]*100000000+end[0][1]*10000000+end[0][2]*1000000+end[1][0]*100000+end[1][1]*10000+end[1][2]*1000+end[2][0]*100+end[2][1]*10+end[2][2];
                resultsum[i]=tmpsum;
                endc0=endc0-1;
            }
            if(pointdir[endsum]==2){
                end[endr0][endc0]=end[endr0-1][endc0];
                end[endr0-1][endc0]=0;
                tmpsum=end[0][0]*100000000+end[0][1]*10000000+end[0][2]*1000000+end[1][0]*100000+end[1][1]*10000+end[1][2]*1000+end[2][0]*100+end[2][1]*10+end[2][2];
                resultsum[i]=tmpsum;
                endr0=endr0-1;
            }
            if(pointdir[endsum]==3){
                end[endr0][endc0]=end[endr0][endc0+1];
                end[endr0][endc0+1]=0;
                tmpsum=end[0][0]*100000000+end[0][1]*10000000+end[0][2]*1000000+end[1][0]*100000+end[1][1]*10000+end[1][2]*1000+end[2][0]*100+end[2][1]*10+end[2][2];
                resultsum[i]=tmpsum;
                endc0=endc0+1;
            }
            endsum=tmpsum;
        }
    for(int i=1;i<result+2;i++){
        if(i==1){
            cout<<"initial"<<endl;
        }
        else{
            cout<<"step "<<i-1<<endl;
        }
        int k=0;
        for(int j=100000000;j>0;j=j/10){
            cout<<resultsum[i]/j<<" ";
            resultsum[i]=resultsum[i]-resultsum[i]/j*j;
            k++;
            if(k%3==0){
                cout<<endl;
            }
        }
        cout<<endl;
    }
    }
    system("pause");
    return 0;
}

运行结果

在这里插入图片描述

啊噗呲咔
关注
  • 2
    点赞
  • 踩
  • 20
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
8数码问题（C++）
MISS_XDY的博客
03-31 960
思路：用数组比较有没有到达最终状态较为繁琐，还需要再创建一个临时数组。 可以将数组转化为一个9位数字，比如左图数组，转化为9位数为207584163，便于比较。使用bfs，从初始态开始搜索，如果某个中间状态可以由上一步走到，且该状态还未出现过（即在移动0时，还没有移动到过当前的位置），则放入队列，继续向下搜索。用map存中间状态。 输入result为终态对应的9位数。（有些偷懒，应...
使用C++解决八数码问题
热门推荐
DaoJiangNanQu的博客
08-01 1万+
八数码问题 问题描述：通过单步移动把下面的矩阵移动成1-8环绕一周的矩阵（即0在中间，1-8顺序排成一圈，1在哪无所谓） 217860345283164705 \begin{matrix} 2 & 8 & 3 \\ 1 & 6 & 4 \\ 7 & 0 & 5 \\ \end{matrix} (1) 分别用宽度和深度搜索进行； (2) 假设启发式的方程为f(n)=d(n)+...
用C++解决八数码问题（包含讲解和代码）
2302_78003776的博客
11-03 704
将九个数码或一个空格加八个数码放入九宫格内，将顺序打乱后获得一个乱序的九宫格。八数码问题就是指如何通过移动一个格子（下面我将其称为移动元），将乱序的九宫格复原，即通过移动左下图中0的格子，使九宫格恢复成右下图的样子。需要用到搜索求解的方法。
【Python】A*八数码问题_求解思路与代码实现
最新发布
I_no_know_answer的博客
05-21 1413
A*八数码，求解思路与代码实现
8数码问题的c++代码
07-31
参见我的博文：http://blog.csdn.net/j56754gefge/article/details/47170967 这是8数码问题的一套完整解决方案，包括问题模型、搜索方法、界面表示等。有问题请给我发邮件，代码里面有我mail
C++解决八数码问题
毕业作品网站
07-14 6406
语言C++环境：Visual Studio 2019八数码问题是指这样一种游戏：将分别标有数字 1，2，3，…，8 的八块正方形数码牌任意地放在一块 3 * 3 的数码盘上。放牌时要求不能重叠。于是，在 3*3 的数码盘上出现了一个空格。现在要求按照每次只能将与空格相邻的数码牌与空格交换的原则，将任意摆放的数码盘逐步摆成某种特殊的排列。八数码问题包括一个初始状态和目标状态，所谓解八数码问题就是在两个状态间寻找一系列可过渡状态。从一个状态出发，找到空位后有最多四种变换方式，一层一层创建树形结构。这个状态可以有
八数码问题C++代码
05-26
八数码问题C++代码
八数码问题C++程序
01-16
在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标面局（目标状态），找到一种移动方法，实现...
AI_code.rar_八数码_八数码问题_八数码问题 c++
09-21
在“AI_code.rar_八数码_八数码问题_八数码问题 c++”这个压缩包中，包含了用C++语言实现的八数码问题解决方案。 八数码问题是一个二维网格上的智力游戏，目标是通过最少的移动次数将打乱顺序的数字方块恢复到1到8...
人工智能八数码问题C++实现
01-11
人工智能八数码问题C++实现 人工智能八数码问题是人工智能领域中的一个经典问题，旨在解决八个数字的排列问题。八数码问题的目标是将初始状态的数字排列变换为目标状态的数字排列，通过搜索和推理技术来实现。 在...
bsm.rar_BSM_八数码_八数码问题_八数码问题 c++
07-15
标题中的“bsm.rar_BSM_八数码_八数码问题_八数码问题 c++”表明这是一个关于八数码问题（也称为滑动拼图游戏）的C++实现，名为"BSM"，可能代表了一种特定的算法或方法。八数码问题是一个经典的计算机科学问题，涉及...
A*算法解决八数码问题（C++）
12-26
A*算法解决八数码问题（C++），用数组实现的
人工智能 A*算法 八数码问题 C++ 报告+代码+详细注释
03-29
使用C++语言完整的实现了A星算法解决八数码问题 内容：完整代码和详细注释； 主要函数的功能说明； 评价函数的设计； 运行测试结果
八数码问题C语言代码
04-18
任意始末状态八数码问题，运行通过。纯C编写。可在VC++上运行。
C语言8数码问题
12-15
语言解八数码问题之人工智能实验报告
c++解决8数码问题
qq_44920859的博客
06-17 1039
问题简介： 所谓八数码问题是指这样一种游戏：将分别标有数字1，2，3，…，8的八块正方形数码牌任意地放在一块3×3的数码盘上。放牌时要求不能重叠。于是，在 3×3的数码盘上出现了一个空格。现在要求按照每次只能将与空格相邻的数码牌与空格交换的原则，将任意摆放的数码盘逐步摆成某种特殊的排列。如下图表示了 一个具体的八数码问题求解。 问题分析： 这个路径搜索问题可以引申为构建一颗四叉树的问题。 把九宫格信息保存在一个节点类里，节点类具有一个父类指针和四个孩子指针。树的根节点存储了初始状态，寻找最短路径的.
c++八数码问题（广搜）
geshengtong的博客
11-09 1151
1571.八数码 时限：5000ms 内存限制：20000K  总时限：10000ms 描述 在九宫格里放在1到8共8个数字还有一个是空格，与空格相邻的数字可以移动到空格的位置，问给定的状态最少需要几步能到达目标状态（用0表示空格）： 1 2 3 4 5 6 7 8 0   输入 输入一个给定的状态。   输出 输出到达目标状态的最小步数。不能到达时输出-1。   输入
【C++算法设计】八数码问题
monkeyduck的专栏
09-17 4255
八数码问题 【题意】 编好为1~8的8个正方形滑块摆成3行3列（一个格子为空），如图所示 每次可以移动空格相邻的滑块到空格，要计算出能移动出目标局面的最小步数，如无法达到则输出-1。 【分析】 我们可以把每一种局面定义为一种“状态”，而每个状态就是由9个格子的编号依次排列组成，如上图左的状态为：1,5,2,4,3,0,7,8,6，同理右的状态为：1,2,3,4,5,6,7
八数码问题c++BFS
08-26
八数码问题的解决方法中，C语言可以使用BFS（广度优先搜索）算法来解决。在C语言中，可以通过实现一个EightDigital类来解决八数码问题。通过BFS算法可以找到从初始状态到目标状态的最短路径。在该算法中，通过队列的方式，一层一层地扩展状态空间，直到找到目标状态。 在该实现中，可以使用一个辅助数组来记录每个状态的前驱状态，以便打印出从初始状态到目标状态的路径。具体实现中，可以使用一个stack来存储路径，从目标状态开始，通过查找前驱状态一直到初始状态，将每个状态压入栈中，最后依次弹出栈顶元素即可得到路径。同时，使用一个变量记录步数，即栈的大小，即可得到解的步数。 除了BFS算法外，还可以使用A*算法来解决八数码问题。A*算法是一种启发式搜索算法，通过评估函数来估计从当前状态到目标状态的代价，并选择代价最小的状态进行扩展。在八数码问题中，可以使用曼哈顿距离作为评估函数，即当前状态到目标状态的每个数字所需的水平和垂直移动的总和。通过A*算法可以更快地找到最优解。 总结起来，八数码问题可以使用C语言中的BFS算法和A*算法来解决。BFS算法可以找到最短路径，A*算法可以更快地找到最优解。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [c++八数码难题全家桶（A*算法、双向BFS、BFS、DFS）](https://blog.csdn.net/qq_54893805/article/details/127440809)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

啊噗呲咔

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值