HDU 3567 Eight II 预处理+bfs+hash

最新推荐文章于 2020-05-29 21:01:53 发布

WA是一笔财富

最新推荐文章于 2020-05-29 21:01:53 发布

阅读量1.1k

点赞数 3

分类专栏： bfs hash hdu

本文链接：https://blog.youkuaiyun.com/lxy767087094/article/details/54695170

版权

hdu 同时被 3 个专栏收录

122 篇文章

订阅专栏

bfs

20 篇文章

订阅专栏

hash

7 篇文章

订阅专栏

传送门：HDU3567

题意：经典八数码问题，将八数码从状态A转化到状态B，问最短且字典序最小的解法。

思路：先说说我自己吧，我是刚做完了POJ1077就来做这个题，当时感觉这不是一样的么，改个bfs结束条件不就完事了，然后就一发wa。。看题解才发现A*算法不能保证输出结果是字典序最小的，仔细想想，好像确实是，因为A*中F=G+H的等式是为了更快的求得解，我们每次从优先队列中取出来的状态是F值最小，G值最大的，而G值最大决定了这种状态是同F值中最晚入队的，这样一来怎么可能保证是字典序最小，并且实测好像也不能保证解最短（当然也有可能是蒟蒻的代码问题）。

下面说正解：我是用的网上比较通用的hash+bfs预处理，预处理就是先枚举X在各个位置上的情况，然后dfs并记录能到达的所有情况。一开始我并不明白为什么要枚举X在各个位置上的情况，看了题解对输入数据的处理以后稍微有些懂了，应该是类似于一种一一映射的关系，我们枚举的是初态，bfs记录的是终态，数据输入以后，我们将输入的状态A（初态）映射成我们和枚举的状态中X位置相同的那个，然后用同样的映射方法把状态B映射出来（假设映射为状态D），再查找已经记录好的对应于状态D的路径，直接输出就好了。

举个例子更好的说明这种映射：

样例1中： A状态: 1 2 X B状态: 1 2 3

4 5 3 4 5 6

7 8 6 7 8 X

我们将要将A状态映射成:C状态 : 1 2 X

3 4 5

6 7 8

相应于A->C映射的映射关系，B映射为D状态: 1 2 5

3 4 8

6 7 X

这样映射下来，由于我们提前处理好了C->D的过程，而A->B的过程就等于C->D的过程，所以就可以直接输出了。

代码：

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<stack>
#include<set>
#include<vector>
#include<map>
#define ll long long
#define pi acos(-1)
#define inf 0x3f3f3f3f
using namespace std;
typedef pair<int,int>P;
int factorial[9]={1,1,2,6,24,120,720,5040,40320};
int go[4][2]={1,0,0,-1,0,1,-1,0};
bool book[500000];
int pre[10][500000];
char res[10][500000];
char dir[5]="dlru";
struct node{
	int mp[3][3];
	int r,c;//'x'的坐标 
}st,en;
int Hash(node t)
{
	int s[10];
	int cnt=0,sum=0;
	for(int i=0;i<3;i++)
	{
		for(int j=0;j<3;j++)
		{
			s[i*3+j]=t.mp[i][j];
			cnt=0;
			for(int k=0;k<i*3+j;k++)
			{
				if(s[k]>s[i*3+j])
				cnt++;
			}
			sum+=factorial[i*3+j]*cnt;
		}
	}
	return sum;
}
void bfs(int k)
{
	memset(book,0,sizeof(book));
	memset(pre[k],-1,sizeof(pre[k]));
	queue<node>q;
	while(!q.empty())
	q.pop();
	q.push(st);
	book[Hash(st)]=1;
	while(!q.empty())
	{
		node t=q.front(),a;
		q.pop();
		int head=Hash(t);
		for(int i=0;i<4;i++)
		{
			a=t;
			a.r+=go[i][0];
			a.c+=go[i][1];
			if(a.c<0||a.r<0||a.r>2||a.c>2)continue;
			a.mp[t.r][t.c]=t.mp[a.r][a.c];
			a.mp[a.r][a.c]=9;
			int x=Hash(a);
			if(book[x])continue;
			book[x]=1;
			q.push(a);
			pre[k][x]=head;
			res[k][x]=dir[i];
		}
	}
}
node make_node(char s[])
{
		node k;
		int len=strlen(s),r=0,c=0;
		for(int i=0;i<len;i++)
		{
			if('0'<=s[i]&&s[i]<='9')
			k.mp[r][c]=s[i]-'0';
			else if(s[i]=='X')
			{
				k.mp[r][c]=9;
				k.r=r;
				k.c=c;
			}
			else
			continue;
			c++;
			r+=c/3;
			c%=3;
		}
	return k;
}
void init()
{
	st=make_node("X12345678");
	bfs(0);
	st=make_node("1X2345678");
	bfs(1);
	st=make_node("12X345678");
	bfs(2);
	st=make_node("123X45678");
	bfs(3);
	st=make_node("1234X5678");
	bfs(4);
	st=make_node("12345X678");
	bfs(5);
	st=make_node("123456X78");
	bfs(6);
	st=make_node("1234567X8");
	bfs(7);
	st=make_node("12345678X");
	bfs(8);
}
int main()
{
	init();
	char s[10]={0};
	int cnt=0,t,num[10],k;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%s",s);
		int len=strlen(s),j=0;
		for(int i=0;i<len;i++)
		if(s[i]=='X')k=i;
		else
		num[s[i]-'0']=j++;//记录映射关系，即每个数字的位置
		scanf("%s",s);
		len=strlen(s);
		for(int i=0;i<len;i++)
		if(s[i]=='X')continue;
		else
		s[i]=num[s[i]-'0']+'1';//将终态按照相同映射关系映射
		//puts(s);
		printf("Case %d: ",++cnt);
		st=make_node(s);
		int rear=Hash(st),ans=0;
		stack<char>ss;
		while(!ss.empty())ss.pop();
		while(rear!=-1)
		{
			ans++;
			ss.push(res[k][rear]);
			rear=pre[k][rear];
		}
		ss.pop();
		printf("%d\n",ans-1);
		while(!ss.empty())
		printf("%c",ss.top()),ss.pop();
		puts("");
	}
    return 0;
}