蓝桥杯 历届试题 九宫重排 解题报告（BFS，双向BFS优化）

最新推荐文章于 2021-05-23 14:43:39 发布
最新推荐文章于 2021-05-23 14:43:39 发布
阅读量725 收藏 2
点赞数
分类专栏： 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/o0Roy/article/details/71424188
版权


 历届试题 九宫重排  
时间限制：1.0s   内存限制：256.0MB
       
锦囊1
搜索。
锦囊2
比较经典的搜索题，可以直接搜索或者使用双向搜索优化。
问题描述
　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。

　　我们把第一个图的局面记为：12345678.
　　把第二个图的局面记为：123.46758
　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。
　　本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。
输入格式
　　输入第一行包含九宫的初态，第二行包含九宫的终态。
输出格式
　　输出最少的步数，如果不存在方案，则输出-1。
样例输入
12345678.
123.46758
样例输出
3
样例输入
13524678.
46758123.
样例输出
22

分析：题意说的很清晰，就是移动白块使初状态和末状态一致，移动可以用广搜模拟，但是我们会发现即使白块处于同一个位置，状态仍然可能不一样，以第一组数据初状态为例：

同样是在（2,1）的位置（x，y从0开始），不同的走法状态不一样：

走法1：                                                           走法2：


对应状态分别为（1234857.6） 和（1234567.8） ===》这就要求我们每次移动记录矩阵相应的状态，故需要引入HashMap<String,Integer>(String 存状态，Integer存步数)进行记录，

思路：从始态的空白格开始进行广搜，对其上下左右进行广搜，搜一次，对调一次值，将其所对应的状态（如12345678.）放入进行判重，最后只要判断搜到终态空白区域的X,Y且状态一致，就可以得到次数，如果，最后结束仍搜不到，即不可达，输出-1；

搜索图例：


直接搜索：

1.结点(Node)类，里面包含属性，方法：

class Node {
	public int x, y;//当前空白格位置坐标
	public int sum;//空白格移至当前坐标所需次数
	public String s;//此时的矩阵的状态(字符串型,存hashMap时要用)
	public char[][] ch;//此时的矩阵的状态(矩阵型)

	public Node(int ax, int ay, char[][] a, int sum) {//构造方法
		this.x = ax;
		this.y = ay;
		this.ch = a;
		this.sum = sum;
		this.s = getString();
	}

	public char[][] getMap() {//获取矩阵状态
		char[][] t = new char[3][3];
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				t[i][j] = ch[i][j];
			}
		}
		return t;
	}

	private String getString() {//获取字符串型状态
		//比StringBuilder和直接String s节省时间
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				sb.append(ch[i][j]);
			}
		}
		return sb.toString();
	}

	public String toString() {//调试时方便查看
		return "(" + x + "," + y + ") " + sum;
	}
}

2.Main函数 

	static Map<String, Integer> map1;//HashMap 判重
	static int dir[][] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };// 方向数组 上 下 左 右
	public static void main(String args[]) {

		Scanner in = new Scanner(System.in);

		while (in.hasNext()) {
			map1 = new HashMap<String, Integer>();
			char[] aa = in.next().toCharArray();//读字符串
			char[] bb = in.next().toCharArray();//读字符串
			char[][] a = new char[3][3];
			char[][] b = new char[3][3];
			int ax = 0, ay = 0, bx = 0, by = 0, len = 0;
			for (int i = 0; i < 3; i++) {//字符串转3*3二维数组
				for (int j = 0; j < 3; j++) {
					a[i][j] = aa[len];
					b[i][j] = bb[len++];
					if (a[i][j] == '.') {//记录空白位置始态的坐标
						ax = i;
						ay = j;
					}
					if (b[i][j] == '.') {//记录空白位置终态的坐标
						bx = i;
						by = j;
					}
				}
			}
			Node no1 = new Node(ax, ay, a, 0);//始态结点(传入坐标，二维数组及步数)
			Node no2 = new Node(bx, by, b, 0);//终态结点
			map1.put(no1.s, 0);//将初始的状态存入HashMap
			Queue<Node> qNode1 = new LinkedList<Node>();
			qNode1.add(no1);//始态入队
			int count = BFS(qNode1,no2);
			System.out.println(count);
		}
		in.close();
	}

3.BFS函数解析： 

	private static int BFS(Queue<Node> q1, Node no2) {
		while (!q1.isEmpty()) {
				Node n = q1.poll();
				int x = n.x;
				int y = n.y;
				for (int i = 0; i < 4; i++) {
					int xx = x + dir[i][0];
					int yy = y + dir[i][1];
					if (!(0 <= xx && xx < 3 && 0 <= yy && yy < 3))
						continue;
					char[][] a = n.getMap();
					a[x][y] = a[xx][yy];
					a[xx][yy] = '.';
					Node t = new Node(xx, yy, a, n.sum + 1);
					if(xx == no2.x && yy == no2.y && t.s.equals(no2.s))//搜到终态位置且状态一致
						return t.sum;
					if (!map1.containsKey(t.s)) {//如果状态不存在，即放入HashMap
						q1.add(t);//入队继续判断
						map1.put(t.s, t.sum);
					}
				}
			
		}
		return -1;//如果搜索完，说明没找到，返回-1


单向搜索AC代码：


import java.io.BufferedReader;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;

public class Main {

	static Map<String, Integer> map1;//HashMap 判重
	static int dir[][] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };// 方向数组 上 下 左 右
	public static void main(String args[]) {

		Scanner in = new Scanner(System.in);

		while (in.hasNext()) {
			map1 = new HashMap<String, Integer>();
			char[] aa = in.next().toCharArray();//读字符串
			char[] bb = in.next().toCharArray();//读字符串
			char[][] a = new char[3][3];
			char[][] b = new char[3][3];
			int ax = 0, ay = 0, bx = 0, by = 0, len = 0;
			for (int i = 0; i < 3; i++) {//字符串转3*3二维数组
				for (int j = 0; j < 3; j++) {
					a[i][j] = aa[len];
					b[i][j] = bb[len++];
					if (a[i][j] == '.') {//记录空白位置始态的坐标
						ax = i;
						ay = j;
					}
					if (b[i][j] == '.') {//记录空白位置终态的坐标
						bx = i;
						by = j;
					}
				}
			}
			Node no1 = new Node(ax, ay, a, 0);//始态结点(传入坐标，二维数组及步数)
			Node no2 = new Node(bx, by, b, 0);//终态结点
			map1.put(no1.s, 0);//将初始的状态存入HashMap
			Queue<Node> qNode1 = new LinkedList<Node>();
			qNode1.add(no1);//始态入队
			int count = BFS(qNode1,no2);
			System.out.println(count);
		}
		in.close();
	}

	private static int BFS(Queue<Node> q1, Node no2) {
		while (!q1.isEmpty()) {
				Node n = q1.poll();
				int x = n.x;
				int y = n.y;
				for (int i = 0; i < 4; i++) {
					int xx = x + dir[i][0];
					int yy = y + dir[i][1];
					if (!(0 <= xx && xx < 3 && 0 <= yy && yy < 3))
						continue;
					char[][] a = n.getMap();
					a[x][y] = a[xx][yy];
					a[xx][yy] = '.';
					Node t = new Node(xx, yy, a, n.sum + 1);
					if(xx == no2.x && yy == no2.y && t.s.equals(no2.s))//搜到终态位置且状态一致
						return t.sum;
					if (!map1.containsKey(t.s)) {//如果状态不存在，即放入HashMap
						q1.add(t);//入队继续判断
						map1.put(t.s, t.sum);
					}
				}
			
		}
		return -1;//如果搜索完，说明没找到，返回-1
	}
}

class Node {
	public int x, y;//当前空白格位置坐标
	public int sum;//从始态到当前，走了几步
	public String s;//此时的矩阵的状态(字符串型,存hashMap时要用)
	public char[][] ch;//此时的矩阵的状态(矩阵型)

	public Node(int ax, int ay, char[][] a, int sum) {//构造方法
		this.x = ax;
		this.y = ay;
		this.ch = a;
		this.sum = sum;
		this.s = getString();
	}

	public char[][] getMap() {//获取矩阵状态
		char[][] t = new char[3][3];
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				t[i][j] = ch[i][j];
			}
		}
		return t;
	}

	private String getString() {//获取字符串型状态
		//比StringBuilder和直接String s节省时间
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				sb.append(ch[i][j]);
			}
		}
		return sb.toString();
	}

	public String toString() {//调试时方便查看
		return "(" + x + "," + y + ") " + sum;
	}
}


但是，交上去后发现，单向搜索过于耗时，那么我们就可以用到双向搜索




双向BFS（时间比单向的更快）：

定义两个HashMap，map1（始态），map2（终态），始态和终态同时搜索，假设始态的白块要移动到某个位置A，我们先判断一下A点这个位置是否有被终态搜索过，即判断map2是否已经存在该点的状态，如果存在，直接将其步数取出再加上现在所走的步数，即为答案，如果未存在，就把A点的状态存到map1，继续搜索；同理，终态的白块也可以访问map1的状态，这样，就可以实现双向搜索，原理同单向搜索，出口改为map1，map2交界的状态。

双向AC代码：

import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;

public class Main {

	static Map<String, Integer> map1;
	static Map<String, Integer> map2;
	static int dir[][] = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };// 方向数组 上
																		// 下 左 右

	public static void main(String args[]) {

		Scanner in = new Scanner(System.in);

		while (in.hasNext()) {
			map1 = new HashMap<String, Integer>();
			map2 = new HashMap<String, Integer>();
			char[] aa = in.next().toCharArray();
			char[] bb = in.next().toCharArray();
			char[][] a = new char[3][3];
			char[][] b = new char[3][3];
			int ax = 0, ay = 0, bx = 0, by = 0, len = 0;
			for (int i = 0; i < 3; i++) {
				for (int j = 0; j < 3; j++) {
					a[i][j] = aa[len];
					b[i][j] = bb[len++];
					if (a[i][j] == '.') {
						ax = i;
						ay = j;
					}
					if (b[i][j] == '.') {
						bx = i;
						by = j;
					}
				}
			}
			Node no1 = new Node(ax, ay, a, 0);
			Node no2 = new Node(bx, by, b, 0);
			map1.put(no1.s, 0);
			map2.put(no2.s, 0);
			Queue<Node> qNode1 = new LinkedList<Node>();
			qNode1.add(no1);
			Queue<Node> qNode2 = new LinkedList<Node>();
			qNode2.add(no2);
			int count = BFS(qNode1, qNode2);
			System.out.println(count);
		}

	}

	private static int BFS(Queue<Node> q1, Queue<Node> q2) {
		while (!q1.isEmpty() || !q2.isEmpty()) {
			Node n;
			if (!q1.isEmpty()) {
				n = q1.poll();
				int x = n.x;
				int y = n.y;
				for (int i = 0; i < 4; i++) {
					int xx = x + dir[i][0];
					int yy = y + dir[i][1];
					if (!(0 <= xx && xx < 3 && 0 <= yy && yy < 3))
						continue;
					char[][] a = n.getMap();
					a[x][y] = a[xx][yy];
					a[xx][yy] = '.';
					Node t = new Node(xx, yy, a, n.sum + 1);
					if (map2.containsKey(t.s)) {
						return t.sum + map2.get(t.s);
					}
					if (!map1.containsKey(t.s)) {
						q1.add(t);
						map1.put(t.s, t.sum);
					}
				}
			}

			if (!q2.isEmpty()) {
				n = q2.poll();
				int x = n.x;
				int y = n.y;
				for (int i = 0; i < 4; i++) {
					int xx = x + dir[i][0];
					int yy = y + dir[i][1];
					if (!(0 <= xx && xx < 3 && 0 <= yy && yy < 3))
						continue;
					char[][] a = n.getMap();
					a[x][y] = a[xx][yy];
					a[xx][yy] = '.';
					Node t = new Node(xx, yy, a, n.sum + 1);
					if (map1.containsKey(t.s)) {
						return t.sum + map1.get(t.s);
					}
					if (!map2.containsKey(t.s)) {
						q2.add(t);
						map2.put(t.s, t.sum);
					}
				}
			}
		}
		return -1;
	}
}

class Node {
	public int x, y, sum;
	public String s;
	public char[][] ch;

	public Node(int ax, int ay, char[][] a, int sum) {
		this.x = ax;
		this.y = ay;
		this.ch = a;
		this.sum = sum;
		this.s = getString();
	}

	public char[][] getMap() {
		char[][] t = new char[3][3];
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				t[i][j] = ch[i][j];
			}
		}
		return t;
	}

	private String getString() {
		StringBuffer sb = new StringBuffer();
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				sb.append(ch[i][j]);
			}
		}
		return sb.toString();
	}

	public String toString() {
		return "(" + x + "," + y + ") " + sum;
	}
}




hsq_roy
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
九宫重排（BFS）
林伏案的博客
05-19 1227
#include #include #include #include using namespace std; struct Node { string code; int d; Node(const string& c, int d): code(c), d(d) {} Node() {} }; string bState, eState; string moveSqu
题目 1426: [蓝桥杯][历届试题]九宫重排
韩绘锦的博客
10-10 232
题目 1426: [蓝桥杯][历届试题]九宫重排 时间限制: 1Sec 内存限制: 128MB 提交: 2574 解决: 767 题目描述 如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 我们把第一个图的局面记为：12345678. 把第二个图的局面记为：123.46758 显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可
蓝桥杯 历届试题 九宫重排 BFS+搜索
wxh_silence的博客
10-15 642
历届试题 九宫重排 题目描述 如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 我们把第一个图的局面记为：12345678. 把第二个图的局面记为：123.46758 显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。 输入 输入第一行包含九宫的初态，第二行包含九宫的终态。 输出
[蓝桥杯][历届试题]九宫重排
Stillboring的博客
03-15 152
我
蓝桥杯训练题1426: [蓝桥杯][历届试题]九宫重排【方法一：bfs和map判重】【方法二：双向bfs+map判重】
zhoupingqi2017的博客
03-25 570
题目链接： https://www.dotcpp.com/oj/problem1426.html 题目大意： 思路： 大概说明：这题主要就是求最短路径的问题，像这种用bfs最好，如果用dfs的话容易超时。因为bfs只要查找到就可以直接输出了，而dfs是一直查下去。然后这题不仅仅需要用到bfs，因为会有被覆盖的情况，如下： 我们会发现从④到⑤的步骤就出现了走之前走过的地方，单单一个bfs是没法解决...
用Java实现九宫重排问题
最新发布
03-28
蓝桥杯历届试题解法：蓝桥杯竞赛中的九宫重排题目提供了多种解法，包括使用BFS结合集合进行判重和使用单向BFS结合集合进行判重等。这些解法都是围绕如何高效地找到从初始状态到目标状态的路径而设计的。
九宫重排介绍1.zip
03-28
在计算机科学中，九宫重排问题通常被用来作为算法设计的练习，例如使用深度优先搜索（DFS）、广度优先搜索（BFS）或者A*搜索算法等来实现自动求解。这些算法的核心思想是状态空间搜索，通过定义状态（即当前的九宫格...
搜索算法解决九宫重排问题
12-02
在九宫重排问题中，我们可以将每个可能的九宫格状态视为一个节点，每一步操作（比如改变一个格子的数字）作为边，从初始状态开始，BFS会按照“先来后到”的原则依次访问节点。BFS的优势在于能够找到最短的解，但不...
魔方-BFS-输入_魔方bfs_魔方降群法+双向bfs_魔方降群_
09-29
在IT领域，尤其是在算法和计算机科学中，"魔方-BFS-输入_魔方bfs_魔方降群法+双向bfs_魔方降群_"这个标题涉及到的是使用广度优先搜索（Breadth First Search, BFS）解决魔方问题的高级技巧。魔方是一种三维旋转拼图...
重排九宫三种算法
06-14
重排九宫问题，也称为8皇后问题，是经典的计算机科学和算法问题。它要求在8×8的棋盘上放置8个皇后，使得任意两个皇后都不能在同一行、同一列或同一条对角线上。这个问题的扩展版可以是9皇后在9×9的棋盘上，也就是...
【双向BFS】九宫重排
张^老头的博客
04-09 300
题目 1426: [蓝桥杯][历届试题]九宫重排 链接:C语言网——九宫重排 题目描述 如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 我们把第一个图的局面记为：12345678. 把第二个图的局面记为：123.46758 显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。 输
历届试题 九宫重排 (bfs 八数码问题)
cyh
03-26 4404
问题描述 　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 　　我们把第一个图的局面记为：12345678. 　　把第二个图的局面记为：123.46758 　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 　　本题目的任务是已知九宫的初态和终态，求最少经过
【蓝桥杯】九宫重排（BFS+康拓展开）
学无止境
03-20 413
问题描述 　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 　　 　　我们把第一个图的局面记为：12345678. 　　把第二个图的局面记为：123.46758 　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 　　本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动...
重排九宫格的c语言算法实现,九黎祠的九宫格走法C语言源代码
weixin_30719609的博客
05-23 632
仙剑五九黎祠的九宫格对于我这种没有窍门,没有经验的人来说还真是挺难为我的.一开始左右两个目的地我竟然神乎其技地蒙过去了,最后要到达对面我试了很久都通不过,我知道网上肯定已经有解法了,可是就这么放弃总有点不甘心啊!所以我就开始试着编写一个程序让计算机为我解开这个迷宫.进行广度优先搜索,就是试探上下左右一次移动能否拼出从起点到终点有通路的图,要是不行的话就递归进入第二步再次试探.判断是否有一条通路的思...
蓝桥杯， 历届试题 九宫重排 （八数码）
青山绿水之辈 专栏
02-27 2979
问题描述 　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 　　我们把第一个图的局面记为：12345678. 　　把第二个图的局面记为：123.46758 　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 　　本题目的任务是已知九宫的初态和终态，求最少经过
蓝桥杯【历届试题】九宫重排
i逆天耗子
03-21 8778
问题描述 　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 　　我们把第一个图的局面记为：12345678. 　　把第二个图的局面记为：123.46758 　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 　　本题目的任务是已知九宫的初态和终态，求最少经过多少
BFS-九宫格重排(详解)
weixin_34344677的博客
03-08 1274
BFS将近两年没练过题了,今天重新回忆下以前刷的蓝桥杯题:九宫格重排 样例输入  123456780 //初始状态 123046758 //终点状态 样例输出  3 //最短步数 样例输入  135246780 //初始状态 467581230 //终点状态 样例输出  22 /...
九宫重排—题解
First_sight的专栏
03-26 1486
历届试题 九宫重排   时间限制：1.0s   内存限制：256.0MB        问题描述 　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 　　我们把第一个图的局面记为：12345678. 　　把第二个图的局面记为：123.46758
双向BFS算法在搜索策略中的应用
"本文将探讨双向BFS（Bidirectional Breadth First Search）搜索算法，这是一种在图或状态空间中寻找路径的有效方法。与传统的BFS不同，双向BFS同时从起点和终点开始搜索，从而提高了解决问题的效率。在ACM/ICPC等...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值