1026 - A*算法 - 八数码

八数码

描述

现将1~8这八个自然数填入方格中，给定一个初始状态，例如为：281463750，其中空方格用数字0表示。现允许移动空格，但每次只能移动1格。试编一程序完成对于任意给定的一个目标状态，如：123804765，能够以最少步数实现从初始状态到目标状态的转换。方向优先：（左，上，下，右）

输入

两行，每行9个数，保证里面有0 第一行表示起始状态 第二行表示目标状态

输出

若干个组 3行为一组，每行3个数，表示每一步八数码移动的状态 每个数字占3个场宽
如果无解，则输出：NO solution!

样例输入

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

样例输出

分析

真是非常经典的一道题了
有很多种做法：可以双向dfs，可以A^*乱搞
当然这里我选用的就是A^*
搜索移动步数最少，观察发现，每次移动只能把一个数字与空格交换，这样最多把一个数字向它对应的 目标位置靠近1步。即使加入每一步移动都是有效的，每个状态到目标状态的移动步数也不可能小于所有数字当前位置与目标位置的曼哈顿距离之和。于是我们可以得到一个这样的估价函数：
$$F(s)=sum(|xi-xm|+|yi-ym|)$$
xi,yi表示每个数字现在的位置，xm,ym表示每个数字目标位置。
类似的，很多迷宫类问题的估计函数也是曼哈顿距离
记住这个姿势，很有用的

有了估价函数后，我们还想要再进一步优化
发现对于这种0~8的全排列，其唯一对应着康托展开的一个值，我们就用这个来判重

Little Tip
memcmp比较的时候，一定要保证你不希望比较的部分是相同的
要不然就卡着数组的大小的开空间
还是自己手写比较函数，，

Code

#include
#define ll long long
#define in read()
using namespace std;
inline int read(){
     
	char ch;int f=1,res=0;
	while((ch=getchar())<'0'||ch>'9') if(ch=='-') f=-1;
	while(ch>='0'&&ch<='9'){
     
		res=(res<<3)+(res<<1)+ch-'0';
		ch=getchar();
	}
	return f==1?res:-res;
}
bool vis[562890];
ll fac[10];
struct node{
     
	int s[10];
	int eval,stp,fa;
	int pos;//where is 0 
	bool operator <(const node &t)const{
     
		return eval>t.eval;///
	}
}ans[188888];
int goal[10],last;
priority_queue<node> q;
int dx[4]={
     0,-1,0,1};
int dy[4]={
     -1,0,1,0};
int contor(int x[]){
     
	int code=0,t;
	for(int i=0;i<9;++i){
     
		t=0;
		for(int j=i+1;j<9;++j) if(x[j]<x[i]) t++;
		code+=1ll*t*fac[8-i];
	}
	//printf("code=%d\n",code);
	if(vis[code]) return 1;//have something
	vis[code]=1;
	return 0;
}
int calc(int now[]){
     //calculate 估价值 
	int S[10],T[10];
	for(int i=0;i<9;++i)
		S[now[i]]=i,T[goal[i]]=i;
	int res=0;
	for(int i=1;i<9;++i)
		res+=abs(S[i]/3-T[i]/3)+abs(S[i]%3-T[i]%3);
	return res;
}
void expand(node &st){
     
	int x=st.pos/3;
	int y=st.pos%3;
	for(int i=0;i<4;++i){
     
		int newx=x+dx[i];
		int newy=y+dy[i];
		int newp=newx*3+newy;//将坐标转化为值 
		if(newx<3&&newx>=0&&newy<3&&newy>=0){
     
			node now=st;
			now.s[newp]=st.s[st.pos];
			now.s[st.pos]=st.s[newp];
			
			if(contor(now.s)) continue;
			
			now.fa=last;now.pos=newp;
			now.stp++;
			now.eval=now.stp+calc(now.s);
			q.push(now);
		}
	}
}
bool compare(int *a,int *b){
     
	for(int i=0;i<9;++i)
		if(a[i]!=b[i]) return 0;
	return 1;
}
int bfs(){
     
	while(!q.empty()){
     
		node tmp=q.top();q.pop();
		ans[++last]=tmp;
		if(compare(goal,tmp.s)) return 1;
		expand(tmp);
		if(last>10000) break;
	}
	return 0;	
}
void print(int x[]){
     
	for(int i=0;i<9;++i){
     
		printf("%3d",x[i]);
		if((i+1)%3==0) printf("\n");
	}
	printf("\n");
}
void write(int k){
     
	if(!k) return;
	write(ans[k].fa);
	print(ans[k].s);
}
int main(){
     
	fac[0]=1;
	for(int i=1;i<9;++i) fac[i]=fac[i-1]*1ll*i;
	node st;
	for(int i=0;i<9;++i) {
     
		st.s[i]=in;
		if(!st.s[i]) st.pos=i;
	}
	for(int i=0;i<9;++i) goal[i]=in;
	st.fa=0;st.eval=calc(st.s);st.stp=0;
	contor(st.s);
	q.push(st);
	if(bfs()) write(last);
	else printf("NO solution!");
	return 0;
}