HDU 1043 Eight 八数码问题 A*算法（经典问题）

HDU 1043 Eight 八数码问题（经典问题）

题意

经典问题，就不再进行解释了。

这里主要是给你一个状态，然后要你求其到达\(1,2,3,4,5,6,7,8,x\)的转移路径。

解题思路

这里有很多的解法，我这里是参考的学长给的题解，真的写的巨好啊！可惜不知道是哪位学长写的＞︿＜。

下面就是学长写的题解了，自己改动和增添了一点。

---

经典问题，解法有很多，我们先来计算一下八数码问题一共有多少种状态。八数码问题包含九个字符，这九个字符可以任意排列，也就是\(9! = 362880\)。所以八数码问题的状态只有\(36W\)，并不是很多。

插播一个知识点 下面三种方法均需要使用（用来记录该状态是否达到过）。

知识点一：康托展开（具体见百度，此处不再进行赘述）

百度百科

我们可以用康托展开来把一个排列转换为一个自然数，这样，我们就可以方便的知道某一个状态是否达到过。

---

方法一 打表

我们可以从最终状态

\[\left[\begin{matrix}1 & 2 & 3\\4 & 5 & 6\\7 & 8 & X\\\end{matrix}\right]
\]

向其它所有状态进行搜索，并记录路径。然后对于每个询问，直接输出答案即可（也就相当于先打表）。

---

插播第二个知识点 下面两种方法均需要使用（用来判断该局面是否有解）。

知识点二：\(n\)数码问题的有解性

奇数码游戏两个局面可达，当且仅当两个局面下网格中的数依次写成1行\(n ＊ n - 1\)个元素的序列后（不考虑空格），逆序对个数的奇偶性相同。例如某一个局面写成\(［5,2,8,1,3,4,6,7］\)。该结论的必要性很容易证明：空格左右移动时，写成的序列显然不变；空格向上（下）移动时，相当于某个数与它后（前）边的n-1个数交换了位置，因为n-1是偶数，所以逆序对数的变化也只能是偶数。该结论的充分性证明较为复杂，我们将不在此大篇幅讨论这样一个数学问题。

上面的结论还可以扩展到\(n\)为偶数的情况，此时两个局面可达，当且仅当两个局面对应网格写成序列后，“逆序对数之差”和''两个局面下空格所在的行数之差”奇偶性相同。事实上，在\(n＊m\)网格上（\(n，m\geq2\)也服从上述两个结论之一（根据列数奇偶性分情况讨论）

总而言之，\(n＊m\)数码问题的有解性判定，可以转化为求逆序对来解决。

补充：其实就是如下所述

n*m数码：

m是奇数，俩种状态逆序对奇偶性相同。

m是偶数，俩种状态“逆序对+下空格之间的行数之差”的奇偶性一致。

---

下面的两种方法一定要先对局面进行有解性的判定，只对有解的情况进行搜索。否则，如果某一个局面无解，则无论什么搜索方案，都会完全的搜索完整个状态空间，也就是会超时。

---

方法二 双向BFS（这里题解中没有代码，准备后续补坑）

如果不进行打表的话，我们可以使用双向BFS来降低复杂度（因为搜索树节点数量是随着层数指数级增长的）。

从题目所给状态和最终状态交替进行双向BFS，当某一次取出队首节点，发现另一个分支已经访问过这个状态时，说明两个BFS相遇，递归进行输出答案。

---

方法三 A*启发式搜索

局面的估价函数：用每一个值的当前位置与最终位置的曼哈顿距离作为每一个值的代价，对所有的值的代价求和，就是当前局面的代码。

按照估价函数进行启发式搜索即可。

---

代码实现（方法三：A*算法）

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
struct node{
	int s[9];
	int cur, n;
	int f, g, h;
    //注意，因为优先队列原本是从大到小的排列，所以我们需要重写小于号，这里的小于的功能实际是大于号的功能
    //这样优先队列里面排序才是从小到大进行的排序。
    //我的实现方式是用友元函数重载小于运算符
	friend bool operator <(const node a, const node b)
	{
		return a.f==b.f ? a.g > b.g : a.f > b.f;
	}
    //下面是学长写的小于号运算符重载形式，使用的是成员函数运算符重载
     //bool operator<(const node &a) const {
     //   return a.f == f ? a.g < g : a.f < f;
    //}
};
const char dir[]="dulr";
const int nexts[][2]={{1, 0}, {-1, 0}, {0, -1}, {0, 1}};
const int maxn=363000;
int fac[]={1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880}; //0-9的阶乘
bool vis[maxn];
int pre[maxn];
char path[maxn];
int cantor(const int s[])
{
	int sum=0;
	for(int i=0; i<9; i++)
	{
		int cnt=0;
		for(int j=i+1; j<9; j++)
			if(s[j] < s[i])
				cnt++;
		sum+=cnt*fac[9-i-1];
	}
	return sum;
}
int getval(const int *s) //曼哈顿距离
{
	int val=0;
	int x, y, tx, ty;
	for(int i=0; i<9; i++)
	{
		x=i/3; y=i%3;
		tx=(s[i]-1)/3; ty=(s[i]-1)%3;
		val+=abs(x-tx)+abs(y-ty);
	}
	return val;
}

void printans(int n)
{
	if(pre[n])
	{
		printans(pre[n]);
		printf("%c", path[n]);
	}
}
void AStar(node s)
{
	memset(vis, false, sizeof(vis));
	priority_queue<node> q;
	q.push(s);
	vis[s.n]=true;
	pre[s.n]=0;
	int ans=0;
	while(!q.empty())
	{
		node now=q.top();
		q.pop();
		if(now.n==ans)
		{
			printans(ans);
			printf("\n");
			return ;
		}
		int x=now.cur/3, y=now.cur%3;
		for(int p=0; p<4; p++)
		{
			int tx=nexts[p][0]+x, ty=nexts[p][1]+y;
			if(tx<0 || ty<0 || tx>2 || ty>2) continue;
			node tmp=now;
			tmp.cur=tx*3+ty;
			swap(tmp.s[now.cur], tmp.s[tmp.cur]);
			tmp.n=cantor(tmp.s);
			if(vis[tmp.n])	continue;
			vis[tmp.n]=true;
			pre[tmp.n]=now.n;
			path[tmp.n]=dir[p];
			tmp.g++;
			tmp.h=getval(tmp.s);
			tmp.f=tmp.g+tmp.h;
			q.push(tmp);
		}
	}
 }
int main()
{
	char ch;
	node s;
	while(scanf(" %c", &ch) !=EOF)
	{
		if(ch=='x')
			ch='9', s.cur=0;
		s.s[0]=ch-'0';
		for(int i=1; i<9; i++)
		{
			scanf(" %c", &ch);
			if(ch=='x')
				ch='9', s.cur=i;
			s.s[i]=ch-'0';
		}
		s.n=cantor(s.s);
		s.g=0;
		s.h=getval(s.s);
		s.f=s.g+s.h;
		int cnt=0;
		for(int i=0; i<8; i++)
		{
			if(s.s[i]!=9)
				for(int j=i+1; j<9; j++)
					if(s.s[j] < s.s[i])
						cnt++;
		}
		if(cnt&1)
			printf("unsolvable\n");
		else AStar(s);

	}
	return 0;
 }