蓝桥杯历届试题九宫重排（双向搜索优化）

本文链接：https://blog.youkuaiyun.com/piaocoder/article/details/50835398

历届试题九宫重排

问题描述

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

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

输入格式

　　输入第一行包含九宫的初态，第二行包含九宫的终态。

输出格式

　　输出最少的步数，如果不存在方案，则输出-1。

样例输入

  12345678. 
 
 123.46758 

样例输出

3

样例输入

  13524678. 
 
 46758123. 

样例输出

22

解题思路：

比较经典的搜索题，可以直接搜索或者使用双向搜索优化。

AC代码：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;

public class Main {
	static Map<String,Integer> hm1 = new HashMap<String,Integer>();
	static Map<String,Integer> hm2 = new HashMap<String,Integer>();
	static int[] dx = {-1,0,1,0},dy = {0,-1,0,1};
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String start = br.readLine();
		String end = br.readLine();
		char[][] a = new char[3][3];
		char[][] b = new char[3][3];
		int pos = 0,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(pos);
				b[i][j] = end.charAt(pos);
				pos++;
				if(a[i][j] == '.'){
					x1 = i;
					y1 = j;
				}
				if(b[i][j] == '.'){
					x2 = i;
					y2 = j;
				}
			}
		}
		Node node1 = new Node(0,x1,y1,a);
		Node node2 = new Node(0,x2,y2,b);
		
		Queue<Node> qnode1 = new LinkedList<Node>();
		Queue<Node> qnode2 = new LinkedList<Node>();
		qnode1.add(node1);
		qnode2.add(node2);
		hm1.put(node1.getMap(), 0);
		hm2.put(node2.getMap(), 0);
		
		System.out.println(bfs(qnode1,qnode2));
	}
	
	private static int bfs(Queue<Node> q1, Queue<Node> q2) {
		while(!q1.isEmpty() || !q2.isEmpty()){
			if(!q1.isEmpty()){
				Node node = q1.poll();
				int x = node.getX();
				int y = node.getY();
				if(hm2.containsKey(node.getMap())){
					return node.getSum() + hm2.get(node.getMap());
				}
				for(int i = 0; i < 4; i++){
					int xx = x+dx[i],yy = y+dy[i];
					if(xx < 0 || xx >= 3 || yy < 0 || yy >= 3)
						continue;
					char[][] a = node.getCopy();
					a[x][y] = a[xx][yy];
					a[xx][yy] = '.';
					Node node2 = new Node(node.sum+1,xx,yy,a);
					String s = node2.getMap();
					if(hm2.containsKey(s)){
						return node2.getSum()+hm2.get(s);
					}
					if(!hm1.containsKey(s)){
						hm1.put(s, node2.getSum());
						q1.add(node2);
					}
				}
			}
			if(!q2.isEmpty()){
				Node node = q2.poll();
				int x = node.getX();
				int y = node.getY();
				if(hm1.containsKey(node.getMap())){
					return node.getSum() + hm1.get(node.getMap());
				}
				for(int i = 0; i < 4; i++){
					int xx = x+dx[i],yy = y+dy[i];
					if(xx < 0 || xx >= 3 || yy < 0 || yy >= 3)
						continue;
					char[][] a = node.getCopy();
					a[x][y] = a[xx][yy];
					a[xx][yy] = '.';
					Node node2 = new Node(node.sum+1,xx,yy,a);
					String s = node2.getMap();
					if(hm1.containsKey(s)){
						return node2.getSum()+hm1.get(s);
					}
					if(!hm2.containsKey(s)){
						hm2.put(s, node2.getSum());
						q2.add(node2);
					}
				}
			} 
		}
        return -1;
    }
}
	
class Node{
	int sum,x,y;
	char[][] a = null;
	public char[][] getCopy(){
		char[][] copy = new char[3][3];
		
		for(int i = 0; i < 3; i++){
			for(int j = 0; j < 3; j++){
				copy[i][j] = a[i][j];
			}
		}
		return copy;
	}
	
	public String getMap(){
		StringBuffer sb = new StringBuffer();
		for(int i = 0; i < 3; i++){
			for(int j = 0; j < 3; j++){
				sb.append(a[i][j]);
			}
		}
		return sb.toString();
	}
	
	public Node(int sum, int x, int y, char[][] a) {
		super();
		this.sum = sum;
		this.x = x;
		this.y = y;
		this.a = a;
	}

	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;
	}
}

测试数据：

Input:

12345678.
152743.86

12345678.
12356.784

2315.6784
8235164.7

12345678.
87654321.
.87654321
12345678.

Output: