第四届蓝桥杯决赛题-九宫重排（双向广搜）.java

最新推荐文章于 2023-03-15 22:10:57 发布
最新推荐文章于 2023-03-15 22:10:57 发布
阅读量2.4k 收藏 2
点赞数
分类专栏： 搜索 文章标签： 双向广搜
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangyiacm/article/details/20801505
版权

问题描述
　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。

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

/*
 * 132757	张燚	九宫重排	  2014-03-08 21:56	5.209KB	JAVA	正确	 100	156ms	33.90MB	评测详情  
 * 
 * 
 */
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Queue;
public class Main{//双向广搜
	private static HashMap<String,Integer> hm1=null,hm2=null;
	public static void main(String[] args) {
		BufferedReader bf=new BufferedReader(new InputStreamReader(System.in));
		try {
			String start=bf.readLine();
			String end=bf.readLine();
			char a[][]=new char[3][3];
			char b[][]=new char[3][3];
			int c=0;
			int x1=0,y1=0,x2=0,y2=0;
			for(int i=0;i<3;i++){
				for(int j=0;j<3;j++){
					a[i][j]=start.charAt(c);
					b[i][j]=end.charAt(c);
					if(a[i][j]=='.'){
						x1=i;
						y1=j;
					}
					if(b[i][j]=='.'){
						x2=i;
						y2=j;
					}
					c++;
				}
			}
			Node node1=new Node(a,0,x1,y1);
			Node node2=new Node(b,0,x2,y2);
			Queue<Node> q1=new LinkedList<Node>();
			Queue<Node> q2=new LinkedList<Node>();
			hm1=new HashMap<String, Integer>();
			hm2=new HashMap<String, Integer>();
			hm1.put(start, 0);
			hm2.put(end, 0);
			q1.add(node1);
			q2.add(node2);
			System.out.println(bfs(q1,q2));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	private static int bfs(Queue<Node> q1,Queue<Node> q2) {
		while(!q1.isEmpty()||!q2.isEmpty()){
			if(!q1.isEmpty()){
				
				Node node1=q1.poll();
			//	System.out.println(node1.getTuString()+"----1");
				if(hm2.containsKey(node1.getTuString())){
					return node1.getSum()+hm2.get(node1.getTuString());
				}
				int x=node1.getX();
				int y=node1.getY();
				if(x>0){
					char a[][]=node1.getTuCopy();
					a[x][y]=a[x-1][y];
					a[x-1][y]='.';
					Node n=new Node(a,node1.getSum()+1,x-1,y);
					String s=n.getTuString();
					if(hm2.containsKey(s)){
						return n.getSum()+hm2.get(s);
					}
					if(!hm1.containsKey(s)){
						hm1.put(s, n.getSum());
						q1.add(n);
					}
				}
				if(x<2){
					char a[][]=node1.getTuCopy();
					a[x][y]=a[x+1][y];
					a[x+1][y]='.';
					Node n=new Node(a,node1.getSum()+1,x+1,y);
					String s=n.getTuString();
					if(hm2.containsKey(s)){
						return n.getSum()+hm2.get(s);
					}
					if(!hm1.containsKey(s)){
						hm1.put(s, n.getSum());
						q1.add(n);
					}
				}
				if(y>0){
					char a[][]=node1.getTuCopy();
					a[x][y]=a[x][y-1];
					a[x][y-1]='.';
					Node n=new Node(a,node1.getSum()+1,x,y-1);
					String s=n.getTuString();
					if(hm2.containsKey(s)){
						return n.getSum()+hm2.get(s);
					}
					if(!hm1.containsKey(s)){
						hm1.put(s, n.getSum());
						q1.add(n);
					}
				}
				if(y<2){
					char a[][]=node1.getTuCopy();
					a[x][y]=a[x][y+1];
					a[x][y+1]='.';
					Node n=new Node(a,node1.getSum()+1,x,y+1);
					String s=n.getTuString();
					if(hm2.containsKey(s)){
						return n.getSum()+hm2.get(s);
					}
					if(!hm1.containsKey(s)){
						hm1.put(s, n.getSum());
						q1.add(n);
					}
				}
			}
			
			
			if(!q2.isEmpty()){
				
				Node node2=q2.poll();
			//	System.out.println(node2.getTuString()+"----2");
				if(hm1.containsKey(node2.getTuString())){
					return node2.getSum()+hm1.get(node2.getTuString());
				}
				int x=node2.getX();
				int y=node2.getY();
				if(x>0){
					char a[][]=node2.getTuCopy();
					a[x][y]=a[x-1][y];
					a[x-1][y]='.';
					Node n=new Node(a,node2.getSum()+1,x-1,y);
					String s=n.getTuString();
					if(hm1.containsKey(s)){
						return n.getSum()+hm1.get(s);
					}
					if(!hm2.containsKey(s)){
						hm2.put(s, n.getSum());
						q2.add(n);
					}
				}
				if(x<2){
					char a[][]=node2.getTuCopy();
					a[x][y]=a[x+1][y];
					a[x+1][y]='.';
					Node n=new Node(a,node2.getSum()+1,x+1,y);
					String s=n.getTuString();
					if(hm1.containsKey(s)){
						return n.getSum()+hm1.get(s);
					}
					if(!hm2.containsKey(s)){
						hm2.put(s, n.getSum());
						q2.add(n);
					}
				}
				if(y>0){
					char a[][]=node2.getTuCopy();
					a[x][y]=a[x][y-1];
					a[x][y-1]='.';
					Node n=new Node(a,node2.getSum()+1,x,y-1);
					String s=n.getTuString();
					if(hm1.containsKey(s)){
						return n.getSum()+hm1.get(s);
					}
					if(!hm2.containsKey(s)){
						hm2.put(s, n.getSum());
						q2.add(n);
					}
				}
				if(y<2){
					char a[][]=node2.getTuCopy();
					a[x][y]=a[x][y+1];
					a[x][y+1]='.';
					Node n=new Node(a,node2.getSum()+1,x,y+1);
					String s=n.getTuString();
					if(hm1.containsKey(s)){
						return n.getSum()+hm1.get(s);
					}
					if(!hm2.containsKey(s)){
						hm2.put(s, n.getSum());
						q2.add(n);
					}
				}
			}
		}
		return -1;
	}
}
class Node{
	char tu[][]=new char[3][3];
	int sum=0;
	int x=0,y=0;
	public Node(char[][] tu, int sum, int x, int y) {
		super();
		this.tu = tu;
		this.sum = sum;
		this.x = x;
		this.y = y;
	}
	public char[][] getTuCopy() {
		char a[][]=new char[3][3];
		for(int i=0;i<3;i++)
			for(int j=0;j<3;j++)
				a[i][j]=tu[i][j];
		return a;
	}
	public String getTuString() {
		StringBuffer sb=new StringBuffer("");
		for(int i=0;i<3;i++)
			for(int j=0;j<3;j++)
				sb.append(tu[i][j]);
		return sb.toString();
	}
	public void setTu(char[][] tu) {
		this.tu = tu;
	}
	public int getSum() {
		return sum;
	}
	public void setSum(int sum) {
		this.sum = sum;
	}
	public int getX() {
		return x;
	}
	public void setX(int x) {
		this.x = x;
	}
	public int getY() {
		return y;
	}
	public void setY(int y) {
		this.y = y;
	}
}




Main-zy
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
java九宫排序算法
12-14
通过网页式文件调用.class文件，选取多种方法实现九宫排序
搜索专项---双向广搜模型
qq_67458830的博客
02-16 378
本篇主要是讲解搜索中的双向广搜模型
第四届蓝桥杯JavaB组国赛-九宫重排
m0_52238102的博客
02-04 1012
题目描述 如图1的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。 与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成图2所示的局面。 　　我们把图1的局面记为：12345678. 　　把图2的局面记为：123.46758 显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。 例如： 　　输入数据为： 　　12345678. 　　123.46758 　　则,程序应该输
蓝桥杯_九宫重排 java
Mr.L的博客
03-15 138
题目描述如下图的九宫格中，放着 1 ~ 8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成图 2 所示的局面。我们把上图的局面记为：12345678.把下图的局面记为：123.46758显然是按从上到下，从左到右的顺序记录数字，空格记为句点。题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出 -1。输入描述输入第一行包含九宫的初态，第二行包含九宫的终态。输出描述。
蓝桥杯：九宫重排(Java满分解法)
爱敲代码的三毛的博客
05-22 976
题目 如下图的九宫格中，放着 1 ~ 8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。 经过若干次移动，可以形成图 2 所示的局面。 我们把上图的局面记为：12345678. 把下图的局面记为：123.46758 显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出 -1。 输入描述 输入第一行包含九宫的初态，第二行包含九宫的终态。 输出描述 输出最少的步数，如果不存在方
九宫重排介绍1.zip
03-28
九宫重排，也称为“数独变种”或“幻方扩展”，是基于数独游戏的一种数学逻辑问题。在传统的数独游戏中，我们通常面对一个9x9的网格，被划分为9个3x3的小宫格，目标是填充数字1到9，使得每一行、每一列以及每一个小...
用Java实现九宫重排问题
最新发布
03-28
蓝桥杯历届试题解法：蓝桥杯竞赛中的九宫重排题目提供了多种解法，包括使用BFS结合集合进行判重和使用单向BFS结合集合进行判重等。这些解法都是围绕如何高效地找到从初始状态到目标状态的路径而设计的。
搜索算法解决九宫重排问题
12-02
九宫格重排问题，又称为八皇后问题的变形，是一个经典的计算机科学问题。它要求在9x9的网格中放置9个数字，使得每行、每列以及两条对角线上的数字都不重复。在这个问题中，我们用不同的搜索算法来寻找所有可能的解决...
1九宫重排介绍.zip
03-28
九宫重排，也称为“数独变种”或“幻方旋转”，是基于数独逻辑的一种数学游戏和智力挑战。在传统的数独游戏中，玩家需要填入数字1到9，使得每一行、每一列以及每一个3x3的小宫格内的数字都不重复。而在九宫重排中，...
九宫重排java
小木屋
04-02 3792
问题描述 　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 　　我们把第一个图的局面记为：12345678. 　　把第二个图的局面记为：123.46758 　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 　　本题目的任务是已知九宫的初态和终态，求最少经过
三种不同方法的重排九宫java源码
05-25
广度优先搜索按照“先扩展出的节点先被考察”的原则进行搜索。 深度优先搜索按照“后扩展出的节点先被考察”的原则进行搜索。 有界深度优先搜索的原则与深度优先搜索相同，但是它规定了深度限界，使搜索不得无限制地向纵深方向发展。
三种方法实现的九宫重排程序
05-29
用java实现的带图形界面的九宫重排程序，支持广度优先搜索、深度优先搜索和有界深度优先搜索三种算法
双向广搜总结
11-15
双向广搜在竞赛中是很有战斗力的，比单向的广搜快很多
重排九宫格代码C++
03-28
分别使用广度优先搜索、深度优先搜索和 A*算法实现重排九宫格问题； 使用的搜索方式可在程序内修改； 可以自行输入初始状态和目标状态 可以选择是否展示具体搜索步骤； 程序输出在该搜索方法下的最佳路径以及使用该搜索方法的搜索步骤数；
盲目搜索（广度搜索）解重排九宫问题（C++）
11-16
盲目搜索（广度搜索）解重排九宫问题，即把数码问题的盲目搜索求解！C++实现的。
Java实现 蓝桥杯 历届试题 九宫重排
热门推荐
南 墙
07-26 1万+
问题描述 　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 我们把第一个图的局面记为：12345678. 　　把第二个图的局面记为：123.46758 　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 　　本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。...
蓝桥杯【历届试题】九宫重排
i逆天耗子
03-21 8782
问题描述 　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 　　我们把第一个图的局面记为：12345678. 　　把第二个图的局面记为：123.46758 　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 　　本题目的任务是已知九宫的初态和终态，求最少经过多少
蓝桥杯：九宫重排（Java实现）
qq_36919391的博客
12-01 1442
一道bfs类型的算法问题。 先给出题目源地址：九宫重排   题目描述 如下面第一个图的九宫格中，放着  1~8  的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。   我们把第一个图的局面记为：12345678. 把第二个图的局面记为：123.46758 显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 ...
蓝桥杯java第四届决赛第四题--九宫重排
好好学java
05-23 1194
标题：九宫重排 如图1的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成图2所示的局面。 我们把图1的局面记为：12345678. 把图2的局面记为：123.46758 显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 本题目的任务是已知九宫的初态
用Java编写：用A*算法实现八数码难题(九宫重排)的搜索。
05-26
好的，以下是使用Java编写的A*算法实现八数码难题的搜索的示例代码： ``` import java.util.*; public class EightPuzzleSolver { // 表示八数码难题的矩阵 private int[][] board; // 初始状态 private int[][] initialBoard = { {2, 8, 3}, {1, 6, 4}, {7, 0, 5} }; // 目标状态 private int[][] targetBoard = { {1, 2, 3}, {8, 0, 4}, {7, 6, 5} }; // 启发函数类型 private static final int MANHATTAN_DISTANCE = 1; private static final int MISPLACED_TILES = 2; // 启发函数类型，默认为曼哈顿距离 private int heuristicType = MANHATTAN_DISTANCE; // 构造函数 public EightPuzzleSolver() { this.board = initialBoard; } // 构造函数 public EightPuzzleSolver(int[][] board) { this.board = board; } // 设置启发函数类型 public void setHeuristicType(int type) { this.heuristicType = type; } // 获取启发函数类型 public int getHeuristicType() { return heuristicType; } // 获取当前状态的深度 private int getDepth(int[][] board) { int depth = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (board[i][j] != 0) { depth++; } } } return depth; } // 计算曼哈顿距离 private int calculateManhattanDistance(int[][] board) { int distance = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (board[i][j] != 0) { int row = (board[i][j] - 1) / 3; int col = (board[i][j] - 1) % 3; distance += Math.abs(row - i) + Math.abs(col - j); } } } return distance; } // 计算错位数 private int calculateMisplacedTiles(int[][] board) { int count = 0; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (board[i][j] != 0 && board[i][j] != targetBoard[i][j]) { count++; } } } return count; } // 计算启发函数值 private int calculateHeuristicValue(int[][] board) { switch (heuristicType) { case MANHATTAN_DISTANCE: return calculateManhattanDistance(board); case MISPLACED_TILES: return calculateMisplacedTiles(board); default: return 0; } } // 判断当前状态是否为目标状态 private boolean isGoalState(int[][] board) { for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (board[i][j] != targetBoard[i][j]) { return false; } } } return true; } // 交换两个位置的值 private void swap(int[][] board, int row1, int col1, int row2, int col2) { int temp = board[row1][col1]; board[row1][col1] = board[row2][col2]; board[row2][col2] = temp; } // 生成后继状态 private List<int[][]> generateSuccessors(int[][] board) { List<int[][]> successors = new ArrayList<>(); int row = -1, col = -1; // 找到空格的位置 for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { if (board[i][j] == 0) { row = i; col = j; break; } } } // 向上移动空格 if (row > 0) { int[][] successor = new int[3][3]; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { successor[i][j] = board[i][j]; } } swap(successor, row, col, row - 1, col); successors.add(successor); } // 向下移动空格 if (row < 2) { int[][] successor = new int[3][3]; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { successor[i][j] = board[i][j]; } } swap(successor, row, col, row + 1, col); successors.add(successor); } // 向左移动空格 if (col > 0) { int[][] successor = new int[3][3]; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { successor[i][j] = board[i][j]; } } swap(successor, row, col, row, col - 1); successors.add(successor); } // 向右移动空格 if (col < 2) { int[][] successor = new int[3][3]; for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { successor[i][j] = board[i][j]; } } swap(successor, row, col, row, col + 1); successors.add(successor); } return successors; } // A*算法求解八数码难题 public List<int[][]> solve() { // 初始化priority queue PriorityQueue<Node> pq = new PriorityQueue<>(); // 将初始状态加入priority queue pq.add(new Node(board, null, 0, calculateHeuristicValue(board))); // 初始化visited set Set<String> visited = new HashSet<>(); visited.add(Arrays.deepToString(board)); // 进行搜索 while (!pq.isEmpty()) { // 取出f(n)最小的状态 Node node = pq.poll(); // 判断是否为目标状态 if (isGoalState(node.board)) { // 构造路径 List<int[][]> path = new ArrayList<>(); while (node.parent != null) { path.add(node.board); node = node.parent; } path.add(node.board); Collections.reverse(path); return path; } // 生成后继状态 List<int[][]> successors = generateSuccessors(node.board); for (int[][] successor : successors) { // 判断后继状态是否已经访问过 if (!visited.contains(Arrays.deepToString(successor))) { // 计算g(n)和h(n) int g = node.g + 1; int h = calculateHeuristicValue(successor); // 加入priority queue pq.add(new Node(successor, node, g, h)); // 标记为已访问 visited.add(Arrays.deepToString(successor)); } } } // 无解 return null; } // 内部类，表示搜索树中的一个节点 private class Node implements Comparable<Node> { int[][] board; // 状态矩阵 Node parent; // 父节点 int g; // 从初始状态到达当前状态的代价 int h; // 从当前状态到达目标状态的估算代价 public Node(int[][] board, Node parent, int g, int h) { this.board = board; this.parent = parent; this.g = g; this.h = h; } // 比较两个节点的f(n)值 public int compareTo(Node other) { return (g + h) - (other.g + other.h); } } // 测试 public static void main(String[] args) { EightPuzzleSolver solver = new EightPuzzleSolver(); solver.setHeuristicType(MANHATTAN_DISTANCE); List<int[][]> path = solver.solve(); if (path != null) { for (int[][] board : path) { for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { System.out.print(board[i][j] + " "); } System.out.println(); } System.out.println(); } } else { System.out.println("No solution found!"); } } } ``` 在上面的代码中，我们定义了一个`EightPuzzleSolver`类，表示八数码难题的求解器。在构造函数中，我们可以指定初始状态，如果不指定，则默认为： ``` 2 8 3 1 6 4 7 0 5 ``` 我们还可以使用`setHeuristicType`方法来设置启发函数类型（曼哈顿距离或错位数），默认为曼哈顿距离。 在`solve`方法中，我们实现了A*算法的框架，包括初始化priority queue和visited set，取出f(n)最小的状态，判断是否为目标状态，生成后继状态，计算g(n)和h(n)，加入priority queue和visited set等操作。 在`generateSuccessors`方法中，我们实现了生成后继状态的函数，具体实现方式为向上、下、左、右四个方向移动空格，生成四个后继状态。 在`Node`类中，我们定义了搜索树中的一个节点，表示一个状态，其中包括状态矩阵、父节点、从初始状态到达当前状态的代价和从当前状态到达目标状态的估算代价。我们还实现了`compareTo`方法，用于比较两个节点的f(n)值，以便在priority queue中进行排序。 最后，在`main`方法中，我们创建了一个`EightPuzzleSolver`对象，设置了启发函数类型为曼哈顿距离，并调用`solve`方法求解八数码难题。如果求解成功，则输出求解路径，否则输出"No solution found!"。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值