BFS 八数码的变形 XTU 1156 Game

最新推荐文章于 2023-09-30 21:11:26 发布
最新推荐文章于 2023-09-30 21:11:26 发布
阅读量1.2k 收藏
点赞数
分类专栏： 搜索题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hnust_xiehonghao/article/details/8657629
版权

Game

Accepted : 21 Submit : 106
Time Limit : 1000 MS Memory Limit : 65536 KB

题目描述

小茹今年生日收到了小思送的一份奇特的礼物。礼物是一个2*3个格子的棋盘，上面有5个数字方块1~5。每次可以把空格子边上的一个数字方块到移动到空余的格子，方块不能移出棋盘。小思要求小茹把它移动到特定的样子，然后可以满足小茹的一个愿望。小茹想度过一个快乐的生日，而不是费脑筋的移动方块，于是她向你求助。请你帮小茹求出移动的最少次数，如果永远不可能达到，输出 "Impossible!"

输入

第一行为数字n，代表有n组样例。每组样例有4行非负整数，空格用数字0代替。第1行和第2行为礼物的起始状态，第3、4行目标状态。

输出

对于每组样例,输出最少的移动次数，如果不能达到输出"Impossible!"。

样例输入
2
0 1 2
3 4 5
1 2 0
3 4 5
1 2 3
4 5 0
1 2 3
4 0 5
样例输出
2
1

Source

XTUCPC2013


http://202.197.224.59/OnlineJudge2/index.php/Problem/read/id/1156

/*
思路：
把矩形抽象为一个字符串  记录状态 看是否走过   然后用BFS搜索  我一开始用DFS 怎么优化都是超时 
这种题目  有个优化  就是初始状态和终止状态的逆序数相同  如果不同则无解    加上这个优化 可以提快好几倍的速度
*/
#include<stdio.h>
#include<string.h>
#include<string>
#include<map>
#include<iostream>
#include <algorithm>
#include<queue>
using namespace std;
int a[6],b[6],mmap[2][3];
string ans,s;
map<string,int>mp;
map<string,int>::iterator  it;

int step;

struct haha
{
	int pos;//0的位置
	string ss;//矩阵对应的字符串
	int sp;//step 走的步数
}temp,q;

void BFS(int k,int sp)
{
	int i;
	
	queue<struct haha>que;
	q.sp=sp;
	q.ss=s;
	q.pos=k;
	que.push(q);
	while(!que.empty())
	{
		string mid;
		temp=que.front();
		que.pop();
		if(temp.ss==ans) {step=temp.sp;return;}
		
		mp[temp.ss]=1;
		if(temp.pos==0)//0可以走的方向
		{
			mid=temp.ss;
			swap(mid[0],mid[1]);
			q.sp=temp.sp+1;
			q.pos=1;
			q.ss=mid;
			if(mp.find(mid)==mp.end()) 
				que.push(q);

			mid=temp.ss;
			swap(mid[0],mid[3]);
			q.sp=temp.sp+1;
			q.pos=3;
			q.ss=mid;
			if(mp.find(mid)==mp.end()) 
				que.push(q);
		}
		else if(temp.pos==1)
		{
			mid=temp.ss;
			swap(mid[1],mid[0]);
			q.sp=temp.sp+1;
			q.pos=0;
			q.ss=mid;
			if(mp.find(mid)==mp.end()) 
				que.push(q);
			
			mid=temp.ss;
			swap(mid[1],mid[2]);
			q.sp=temp.sp+1;
			q.pos=2;
			q.ss=mid;
			if(mp.find(mid)==mp.end()) 
				que.push(q);
			
			mid=temp.ss;
			swap(mid[1],mid[4]);
			q.sp=temp.sp+1;
			q.pos=4;
			q.ss=mid;
			if(mp.find(mid)==mp.end()) 
				que.push(q);
			
		}
		else if(temp.pos==2)
		{
			mid=temp.ss;
			swap(mid[2],mid[5]);
			q.sp=temp.sp+1;
			q.pos=5;
			q.ss=mid;
			if(mp.find(mid)==mp.end()) 
				que.push(q);
			
			mid=temp.ss;
			swap(mid[2],mid[1]);
			q.sp=temp.sp+1;
			q.pos=1;
			q.ss=mid;
			if(mp.find(mid)==mp.end()) 
				que.push(q);
		}
		else if(temp.pos==3)
		{  
				  				  mid=temp.ss;
								  swap(mid[3],mid[0]);
								  q.sp=temp.sp+1;
								  q.pos=0;
								  q.ss=mid;
								  if(mp.find(mid)==mp.end()) 
									  que.push(q);
								  
								  mid=temp.ss;
								  swap(mid[3],mid[4]);
								  q.sp=temp.sp+1;
								  q.pos=4;
								  q.ss=mid;
								  if(mp.find(mid)==mp.end()) 
									  que.push(q);
		}
		else if(temp.pos==4)
		{ 
				  				  mid=temp.ss;
								  swap(mid[4],mid[3]);
								  q.sp=temp.sp+1;
								  q.pos=3;
								  q.ss=mid;
								  if(mp.find(mid)==mp.end()) 
									  que.push(q);
								  
								  mid=temp.ss;
								  swap(mid[4],mid[5]);
								  q.sp=temp.sp+1;
								  q.pos=5;
								  q.ss=mid;
								  if(mp.find(mid)==mp.end()) 
									  que.push(q);
								  
								  mid=temp.ss;
								  swap(mid[4],mid[1]);
								  q.sp=temp.sp+1;
								  q.pos=1;
								  q.ss=mid;
								  if(mp.find(mid)==mp.end()) 
									  que.push(q);
		}
		else if(temp.pos==5)
		{    
				  				  mid=temp.ss;
								  swap(mid[5],mid[2]);
								  q.sp=temp.sp+1;
								  q.pos=2;
								  q.ss=mid;
								  if(mp.find(mid)==mp.end()) 
									  que.push(q);
								  
								  mid=temp.ss;
								  swap(mid[5],mid[4]);
								  q.sp=temp.sp+1;
								  q.pos=4;
								  q.ss=mid;
								  if(mp.find(mid)==mp.end()) 
									  que.push(q);
		}
		
		
	}
}

int main()
{
    int cas,i,j,kk1=0,kk2=0,sx,sy;
    while(scanf("%d",&cas)!=EOF)
    {
        while(cas--)
        { 
			
			s="\0";ans="\0";//注意 string的清空可以用这个方法
            mp.clear();
            step=999999999;
			
            for(i=0;i<6;i++)
            {
				scanf("%d",&a[i]);
				s+=(a[i]+'0');
            }
			int k,kk=0;
			for(i=0;i<2;i++)
				for(j=0;j<3;j++)
				{
					
					scanf("%d",&mmap[i][j]);
					b[kk++]=mmap[i][j];
					ans+=(mmap[i][j]+'0');
					if(mmap[i][j]==0)
					{
						k=i*3+j;//0在字符串中对应的位置
					}
				}
				ans.swap(s);//由于上面的 k我求反了 求成终态的0的位置了 所以我交换一下终态和始态 哪个做终始都一样
			   int n1=0,n2=0;
				for(i=0;i<6;i++)
				{
					for(j=i+1;j<6;j++)
					{
						if(a[i]>a[j]&&a[i]!=0&&a[j]!=0) n1++;
						if(b[i]>b[j]&&b[i]!=0&&b[j]!=0) n2++;
					}
				}
				if(n1%2!=n2%2)  {printf("Impossible!\n");continue;}
				BFS(k,0);
				if(step!=999999999)
					printf("%d\n",step);
				else printf("Impossible!\n");
        }
		
    }
    return 0;
}



chasexie(xiehonghao)
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BFS求解N数码（python）
pyb的博客
03-04 847
import os import time N = 9 T = [1,2,3,4,5,6,7,8,0]#the original state obj = [2,4,3,1,6,0,7,5,8]#the final state factory = [1, 1, 2, 6, 24, 120,720, 5040,40320] def formed_print(L): n = 0;
BFS&Python
No.96
12-24 1378
# 邻接矩阵 graph = [ [0,1,1,0,0,0,0,0], [1,0,1,1,1,0,0,0], [1,1,0,0,1,0,1,1], [0,1,0,0,0,0,0,0], [0,1,1,0,0,1,0,0], [0,0,0,0,1,0,0,0], [0,0,1,0,0,0,0,0], [0,0,1,0,0,0,0,0] ]
宽度优先搜索算法BFS 解决8数码问题
06-13
基于C++的 BFS算法解决8数码问题 没有做界面 直接是输出步骤 算法是亮点
python版的八数码与N皇后
11-26
这是python版本的八数码与N皇后实现，我写的，看不明白请骂我！！！
HDU 4021 八数码变形
源码力量
09-28 756
/******************************************************************************** 水题，先把起始状态的0和终止状态的0全移到里面的4 * 4矩阵中，接着先判一下多出来的那几个角上的 元素是否有不同的，如果有不同的显然无解，否则，再用求逆序数+0的曼哈顿距离mod2判断是否有解 ****************
Java实现 蓝桥杯 算法提高 八数码（BFS）
热门推荐
南 墙
04-28 1万+
试题 算法提高 八数码 问题描述 　　RXY八数码 输入格式 　　输入两个33表格 　　第一个为目标表格 　　第二个为检索表格 输出格式 　　输出步数 样例输入 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 7 0 8 样例输出 1 数据规模和约定 　　33*2 import java.util.*; public class Main { static int[]dx = ...
BFS求解八数码问题
婷子的博客
12-16 2027
问题描述 八数码问题。在3*3的方格盘上，放有八个数码，剩下第九个为空，每一个空格上下左右的数码可移至空格。问题给定初始位置和目标位置，要求通过一系列的数码移动，将初始位置转换为目标位置。求出从初始位置移动到目标位置的步骤，同时还给出了最短移动路径。 算法原理 首先将空格设为数字0，将3*3方格盘中的数字转换为一个字符串，如‘283104765’，将空格上下左右的数码移动看作空格的移动，这样...
【BFS】八数码问题（c++基础算法）
aliyonghang的博客
09-30 4917
作为最经典的一道宽度优先搜索题，它的题面并不是很难懂。题目描述【题意】在3×3的棋盘上摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围上下左右相邻的棋子可以移到空格中。现给出原始状态和目标状态，求实现从初始布局到目标布局的最少步骤（初始状态的步数为0）。如下图，答案为5。【输入格式】第一个3*3的矩阵是原始状态；第二个3*3的矩阵是目标状态。【输出格式】输出移动所用最少的步数。【样例1输入】2 8 3。
洛谷 P1379 八数码难题 题解
weixin_30821731的博客
07-24 228
我个人感觉就是一道bfs的变形，还是对bfs掌握不好的人有一定难度。 本题思路： 大体上用bfs搜，用map来去重，在这里只需要一个队列，因为需要较少步数达到的状态一定在步数较多的状态之前入队列。 1 #include<iostream> 2 #include<cmath> 3 #include<cstring> 4 #inc...
BFS例题详解
Meikesibondwell的博客
08-04 726
这道题目均来自白书第34页-36页； 个人觉得这个例题很好地表现了广度优先搜索是如何与队列先进先出（FIFO）的思想联系起来的，通过不断取得某个状态后能够达到的所有状态并将其加入队列， 并且由于队列本身的特性先加入队列的状态总是先得到处理，这样就达到了一个目的：总是先将需要转移次数更少的状态进行分析处理，换句话说就是总是取得了这个状态的树中更接近根部的节点，又或者是总是让搜索树的
1077 Eight：八数码问题变形：从bfs到双向bfs+hash到A*启发式搜索的进化史
csyifanZhang的博客
04-04 469
题目大意 添加链接描述 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用x来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为12345678x），找到一种移动方法，实现从初始布局到目标布局的转变。如果不行输出unsolved。 思路分析 八数码问题的变化版，八数码的三种解法，无非是多了...
POJ 1077 八数码 BFS +A*（复习的时候看过来！这道题值的看啊啊啊~！！！）
cokomowang的专栏
07-25 677
D - Eight Time Limit:1000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status Description The 15-puzzle has been around for over 100 years; even if you don't k
湖南科技大学OJ Ignatius and the Princess I 加强
hnust_xiehonghao的专栏
07-20 5348
问题 G: Ignatius and the Princess I 加强 时间限制: 2 Sec  内存限制: 128 MB 提交: 23  解决: 13 [提交][状态][讨论版] 题目描述 The Princess has been abducted by the BEelzebub feng5166, our hero Ignatius has to rescue our pr
hdu 2589 正方形划分 大正方形中又多个点 之后分成多个正方形 使得所有的正方形中含有1个点
hnust_xiehonghao的专栏
05-31 3291
正方形划分 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 145    Accepted Submission(s): 60 Problem Description 一个边长为L的正方形可以分成 L*L个小正方形. 有N
hdu 2510 符号三角形 很好的搜索题 要经常看
hnust_xiehonghao的专栏
05-31 3105
符号三角形 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 661    Accepted Submission(s): 317 Problem Description 符号三角形的 第1行有n个由“+”和”-“组成的符号
hdu1026 Ignatius and the Princess I BFS之打印路径 虐死我得一个题
hnust_xiehonghao的专栏
07-20 2907
Ignatius and the Princess I Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 6305    Accepted Submission(s): 1882 Special Judge Problem De
马踏棋盘
hnust_xiehonghao的专栏
03-17 2427
[问题描述] 在一个具有8*8个方格的国际象棋盘上，从棋盘的任何一个方格开始，让马 按照允许的走步规则(L形走法)走遍所有方格，每个方格至少并且只准走过一次 。试设计一个算法实现这个有趣的问题。   思路：  直接DFS虽然可以求出 但是 可能会有很多很多结果      消耗时间是巨大的   而且答案很难唯一 优化：  在每个结点对其子结点进行选取时，优先选择‘出口’最小的进行搜
Civil War "开启时代杯"湘潭市第二届大学生程序设计大赛 优先队列多条件判断
hnust_xiehonghao的专栏
07-20 2334
战争即和平，自由即奴役，无知即力量。 ——乔治.奥威尔   历史书上说，自从统治者Big Brother去世以后，大洋国就陷入了无休止的内战中，随时都可能有新的武装势力出现，随时都可能有战争发生。奇怪的是，每次战争都是在当前国内战斗力最强大的两股势力间进行，我们可以把每股武装势力的战斗力量化成一个值，每次战争都是在当前战斗力值最高的两股势力间进行。如果有多支势力战斗力值相同，则名字字典序大的
华中电子科技大学 oj hust1605 Gene recombination 数字代表字符串的状态解决MLE
hnust_xiehonghao的专栏
12-07 2270
Gene recombination Time Limit: 2 Sec  Memory Limit: 64 MB Submissions: 78  Solved: 9 Description As a gene engineer of a gene engineering project, Enigma encountered a puzzle about gene recombinat
bfs八数码问题java
最新发布
03-25
BFS（广度优先搜索）是一种常用的图搜索算法，用于解决八数码问题等许多问题。八数码问题是一个经典的拼图游戏，目标是将一个3x3的方格中的数字按照特定顺序排列。 在Java中实现BFS八数码问题，可以按照以下步骤进行： 1. 定义一个表示状态的类，可以使用一个3x3的二维数组来表示八数码的当前状态。 2. 创建一个队列（可以使用LinkedList实现），用于存储待搜索的状态。 3. 将初始状态加入队列，并标记为已访问。 4. 进入循环，直到队列为空： - 从队列中取出一个状态。 - 判断是否为目标状态，如果是，则搜索结束。 - 否则，生成当前状态的所有可能下一步状态，并将未访问过的状态加入队列。 5. 如果队列为空仍未找到目标状态，则表示无解。 以下是一个简单的Java代码示例： ```java import java.util.LinkedList; import java.util.Queue; public class BFSEightPuzzle { private static final int[][] DIRECTIONS = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}}; // 上下左右四个方向 public static void main(String[] args) { int[][] startState = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}}; // 初始状态 int[][] targetState = {{1, 2, 3}, {4, 5, 6}, {7, 8, 0}}; // 目标状态 int steps = bfs(startState, targetState); System.out.println("最少步数：" + steps); } private static int bfs(int[][] startState, int[][] targetState) { int steps = 0; Queue<int[][]> queue = new LinkedList<>(); queue.offer(startState); while (!queue.isEmpty()) { int size = queue.size(); for (int i = 0; i < size; i++) { int[][] currentState = queue.poll(); if (isEqual(currentState, targetState)) { return steps; } int[] zeroPos = findZeroPosition(currentState); int zeroRow = zeroPos[0]; int zeroCol = zeroPos[1]; for (int[] direction : DIRECTIONS) { int newRow = zeroRow + direction[0]; int newCol = zeroCol + direction[1]; if (isValid(newRow, newCol { int[][] nextState = cloneState(currentState); swap(nextState, zeroRow, zeroCol, newRow, newCol); queue.offer(nextState); } } } steps++; } return1; // 无解 } private static boolean isEqual(int[][] state1, int[][] state2) { for (int i = 0; i < state1.length; i++) { for (int j = 0; j < state1[0].length; j++) { if (state1[i][j] != state2[i][j]) { return false; } } } return true; } private static int[] findZeroPosition(int[][] state) { int[] pos = new int[2]; for (int i = 0; i < state.length; i++) { for (int j = 0; j < state[0].length; j++) { if (state[i][j] == 0) { pos[0] = i; pos[1] = j; return pos; } } } return pos; } private static boolean isValid(int row, int col) { return row >= 0 && row < 3 && col >= 0 && col < 3; } private static int[][] cloneState(int[][] state) { int[][] newState = new int[state.length][state[0].length]; for (int i = 0; i < state.length; i++) { for (int j = 0; j < state[0].length; j++) { newState[i][j] = state[i][j]; } } return newState; } private static void swap(int[][] state, int row1, int col1, int row2, int col2) { int temp = state[row1][col1]; state[row1][col1] = state[row2][col2]; state[row2][col2] = temp; } } ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值