POJ - 1077 简单做法 A*

一、内容

在一个3×3的网格中，1~8这8个数字和一个“X”恰好不重不漏地分布在这3×3的网格中。

例如：

1 2 3
X 4 6
7 5 8

在游戏过程中，可以把“X”与其上、下、左、右四个方向之一的数字交换（如果存在）。

我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：

1 2 3
4 5 6
7 8 X

例如，示例中图形就可以通过让“X”先后与右、下、右三个方向的数字交换成功得到正确排列。

交换过程如下：

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

把“X”与上下左右方向数字交换的行动记录为“u”、“d”、“l”、“r”。

现在，给你一个初始网格，请你通过最少的移动次数，得到正确排列。

二、思路

• 不想去写康拓展开，那就只能用unordered_map，但是POJ又不支持，那就只能用速度慢点的map来映射了。
• h函数估价：全部的点与自己原来位置的曼哈顿距离之和。
• 记录路径，记录上一次的状态和本次的状态，最后反向输出一下就行了。
• 然后就是如何判断有无解， 当我们将所有数字横向展开（x除外），求出逆序对的个数，如果逆序对为奇数那么就是无解。

三、代码

#include <cstdio>
#include <iostream>
#include <cstring> 
#include <algorithm>
#include <cmath>
#include <queue>
#include <map>  //换成unordered_map会快很多 但是POJ不支持 
using namespace std;
int  x, y; 
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1}; 
struct node{ 
	int f;
	string str;
	node(int f, string str): f(f), str(str){}
	friend bool operator < (node a, node b) {
		return a.f > b.f; //转化为小根堆 
	}
};
// 0上 1下 2左 3右 
char path[4] = {'u', 'd', 'l', 'r'};
int getH(string str) {
	int h = 0;
	for (int i = 0; i < 9; i++) {
		//求出曼哈顿距离
		if (str[i] != 'x') {
			//当做01234567x  这样坐标是(t / 3, t % 3) 
			int t = str[i] - '1';
			//当前字符的坐标（i / 3, i % 3） 正确的位置（t / 3, t % 3）
			h += abs(i / 3 - t / 3) + abs(i % 3 - t % 3); 
		}
	}
	return h;
} 

string bfs(string start){
	string last, next;
	string end = "12345678x";
	//代表移动过的步数 有点像djkstra的d数组的作用  但是这里初始是0所以第一判断应该判断是否为0 以后再判断大小  
	map<string, int> g;  
	map<string, bool> vis; //看是否访问过该状态
	map<string, pair< int, string> > pre; 
	priority_queue<node> q;
	g[start] = 0; 
	q.push(node(getH(start), start));
	int step; //记录移动的步数 
	while (q.size()) {
		node t = q.top();
		q.pop();
		last = t.str;
		if (vis[last]) continue; 
		vis[last]++;
		step = g[last]; 
		//到达目标状态退出循环 
		if (last == end) break;
		//查找x的坐标 
		for (int i = 0; i < last.size(); i++) {
			if (last[i] == 'x') {
				x = i / 3;
				y = i % 3; 
				break;
			}
		} 
		//枚举4个方向
		next = last;
		for (int i = 0; i < 4; i++) {
			int fx = dx[i] + x;
			int fy = dy[i] + y;	
			if (fx < 0 || fy < 0 || fx >= 3 || fy >= 3) continue;
			swap(next[x *3 + y], next[fx * 3 + fy]);
			//判断这个状态能否入队 没有访问过直接入队 或者 步数比较少入队 
			//if (!g.count(next) || g[next] > step + 1) {
			if (!vis[next]) {  //未访问过的状态肯定是直接入队访问过的步数必然会多1  
				g[next] = step + 1;
				q.push(node(step + 1 + getH(next), next));
				//记录路径 保存上一状态 
				pre[next] = make_pair(i, last);
			} 
			//将next换回去 
			swap(next[x *3 + y], next[fx * 3 + fy]); 
		}  
	} 
	next = "";
	while (end != start) {
		next += path[pre[end].first];
		end = pre[end].second;
	}
	reverse(next.begin(), next.end());
	return next;
}

int main() {
	string start, last, next;
	for (int i = 1; i <= 9; i++) {
		cin >> next;
		start += next;
		if (next != "x") last += next;
	}
	//求逆序对的数量 判断是否有解
	int cnt = 0;
	for (int i = 0; i < 7; i++) {
		for (int j = i + 1; j < 8; j++) {
			if (last[j] < last[i]) cnt++;
		}
	}
	if (cnt % 2 != 0) {
		cout << "unsolvable" << endl;
	} else {
		cout <<	bfs(start) << endl;
	}
	return 0; 
}