HDU 1043 Eight 【经典八数码输出路径/BFS/A*/康托展开】
本题有写法好几个写法，但主要思路是BFS：
No。1
采用双向宽搜，分别从起始态和结束态进行宽搜，暴力判重。如果只进行单向会超时。
No。2
采用hash进行判重，宽搜采用单向就可以AC。
No。3
运用康拓展开进行判重，即使采用单向宽搜时间效率也很高。
哈希是想到了，但是我们应该选择什么哈希函数呢，看了网上一些神牛利用的是"康托展开",也就是利用全排列都有一个对应的整数，利用哈希函数把状态压缩成整数，这样就可以做到每一个整数都是唯一对应一个状态，那么这个时候就把哈希做完了。
Eight
Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 29838 Accepted Submission(s): 7831
Special Judge
Problem Description
The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and all packed into a 4 by 4 frame with one tile missing. Let's call the missing tile 'x'; the object of the puzzle is to arrange the tiles so that they are ordered as:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 x
where the only legal operation is to exchange 'x' with one of the tiles with which it shares an edge. As an example, the following sequence of moves solves a slightly scrambled puzzle:
1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4
5 6 7 8 5 6 7 8 5 6 7 8 5 6 7 8
9 x 10 12 9 10 x 12 9 10 11 12 9 10 11 12
13 14 11 15 13 14 11 15 13 14 x 15 13 14 15 x
r-> d-> r->
The letters in the previous row indicate which neighbor of the 'x' tile is swapped with the 'x' tile at each step; legal values are 'r','l','u' and 'd', for right, left, up, and down, respectively.
Not all puzzles can be solved; in 1870, a man named Sam Loyd was famous for distributing an unsolvable version of the puzzle, and
frustrating many people. In fact, all you have to do to make a regular puzzle into an unsolvable one is to swap two tiles (not counting the missing 'x' tile, of course).
In this problem, you will write a program for solving the less well-known 8-puzzle, composed of tiles on a three by three
arrangement.
Input
You will receive, several descriptions of configuration of the 8 puzzle. One description is just a list of the tiles in their initial positions, with the rows listed from top to bottom, and the tiles listed from left to right within a row, where the tiles are represented by numbers 1 to 8, plus 'x'. For example, this puzzle
1 2 3
x 4 6
7 5 8
is described by this list:
1 2 3 x 4 6 7 5 8
Output
You will print to standard output either the word ``unsolvable'', if the puzzle has no solution, or a string consisting entirely of the letters 'r', 'l', 'u' and 'd' that describes a series of moves that produce a solution. The string should include no spaces and start at the beginning of the line. Do not print a blank line between cases.
Sample Input
2 3 4 1 5 x 7 6 8
Sample Output
ullddrurdllurdruldr
Source
South Central USA 1998 (Sepcial Judge Module By JGShining)
【代码】:
#include<cstdio>
#include<string>
#include<cstdlib>
#include<cmath>
#include<iostream>
#include<cstring>
#include<set>
#include<queue>
#include<algorithm>
#include<vector>
#include<map>
#include<cctype>
#include<stack>
#include<sstream>
#include<list>
#include<assert.h>
#include<bitset>
#include<numeric>
#define debug() puts("+++++++++++++++++++++++++++++")
#define gcd(a,b) __gcd(a,b)
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define fi first
#define se second
#define pb push_back
#define sqr(x) ((x)*(x))
#define ms(a,b) memset(a,b,sizeof(a))
#define sz size()
#define be begin()
#define pu push_up
#define pd push_down
#define cl clear()
#define lowbit(x) -x&x
#define all 1,n,1
#define rep(i,x,n) for(int i=(x); i<(n); i++)
#define in freopen("in.in","r",stdin)
#define out freopen("out.out","w",stdout)
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int,int> P;
const int INF = 0x3f3f3f3f;
const LL LNF = 1e18;
const int maxn = 1000000;
const int maxm = 1e6 + 10;
const double PI = acos(-1.0);
const double eps = 1e-8;
const int dx[] = {-1,1,0,0,1,1,-1,-1};
const int dy[] = {0,0,1,-1,1,-1,1,-1};
const int d[6][3]={ {0,0,1},{0,0,-1},{-1,0,0},{1,0,0},{0,1,0},{0,-1,0} };
int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};//u,d,l,r
const int mon[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int monn[] = {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
bool vis[maxn];
int cantor(int *s) //康拖展开求该序列的hash值
{
int sum = 0;
for(int i=0; i<9; i++)
{
int num = 0;
for(int j=i+1; j<9; j++)
if(s[j] < s[i]) num++;
sum += (num*fac[9-i-1]);
}
return sum + 1;
}
struct node
{
int s[9]; //数位- 2 3 4 1 5 x-0 7 6 8
int loc; //“0”的位置,把“x"当0
int status; //康拖展开的hash值
string path; //路径
}st,ed,now;
string path;
int aim = 46234; //123456780对应的康拖展开的hash值
char indexs[5]="udlr"; //正向搜索
bool check(int tx,int ty)
{
return (tx<0||tx>2||ty<0||ty>2);
}
bool bfs()
{
ms(vis,0);
queue<node> q;
q.push(now);
while(!q.empty())
{
st = q.front();
q.pop();
if(st.status==aim)
{
path = st.path;
return true;
}
int x = st.loc/3;
int y = st.loc%3;
for(int i=0; i<4; i++)
{
//0和四周交换
int tx = x + dir[i][0];
int ty = y + dir[i][1];
if(check(tx,ty)) continue;
ed = st;
ed.loc = tx * 3 + ty; //0和四周交换
ed.s[st.loc] = ed.s[ed.loc];
ed.s[ed.loc] = 0;
ed.status = cantor(ed.s);
if(!vis[ed.status])
{
vis[ed.status] = true;
ed.path+=indexs[i];
if(ed.status==aim)
{
path=ed.path;
return true;
}
q.push(ed);
}
}
}
return false;
}
/*
2 3 4 1 5 x 7 6 8
ullddrurdllurdruldr
*/
int main()
{
char ch;
while(cin>>ch)
{
if(ch=='x') {now.s[0]=0; now.loc=0;}
else now.s[0]=ch-'0';
for(int i=1;i<9;i++)
{
cin>>ch;
if(ch=='x')
{
now.s[i]=0;
now.loc=i;
}
else now.s[i]=ch-'0';
}
now.status=cantor(now.s);//234150768——>
if(bfs()) cout<<path<<endl;
else cout<<"unsolvable"<<endl;
}
}
//思路： 单向bfs()+哈希判重+路径输出(由于POJ数据只有一组，这个方法可以在POJ上面A，其它oj不能A )
#include <algorithm>
#include <iostream>
#include <cstring>
#include <string>
#include <vector>
#include <cstdio>
#include <cctype>
#include <stack>
#include <queue>
#include <cmath>
using namespace std;
#define MAXN 400000
struct State{
int state[9];
int pos;//空格位置
char ch[50];//记录原始状态到达当前状态的路径(数组不能开太大不然超内存)
}s[MAXN];//每一个状态对应一个结构体
int factor[9] = {1,1,2,6,24,120,720,5040,40320};//阶乘数组
int dir[4][2] = {{-1,0},{0,1},{1,0},{0,-1}};//方向数组
char dirtion[4] = {'u' , 'r' , 'd' , 'l'};
int vis[MAXN];//标记某个状态是否被走过
int start;//保存原始输入状态的哈希值
State star;//原始状态对应的结构体
queue<int>q;//这里不能直接放结构体，不然肯定超时
//哈希映射
int Hash(int s[]){
int i , j , temp , num;
num = 0 ;
for(i = 0 ; i < 9 ; i++){
temp = 0;
for(j = i+1 ; j < 9 ; j++){
if(s[j] < s[i]) temp++;
}
num += factor[8-i]*temp;
}
return num;
}
//广搜
bool Bfs(){
while(!q.empty()) q.pop();
memset(vis , 0 , sizeof(vis));
start = Hash(star.state);
vis[start] = 1;
s[start] = star;
q.push(start);
while(!q.empty()){
State cur = s[q.front()];
q.pop();
int x , y , r , c;
x = cur.pos/3 ; y = cur.pos%3;
for(int i = 0 ; i < 4 ; i++){
r = x+dir[i][0] ; c = y+dir[i][1];
if(r < 0 || c < 0 || r >= 3 || c >= 3) continue;
State tmp = cur;
tmp.state[tmp.pos] = tmp.state[3*r+c];//原先空格位置换成新的编号
tmp.pos = 3*r+c ; tmp.state[tmp.pos] = 9;//重新更新空格位置
int hash = Hash(tmp.state);//求出当前哈希值
if(vis[hash]) continue;
vis[hash] = 1;
int len = strlen(cur.ch);//求出前一个状态的路径长度
tmp.ch[len] = dirtion[i];//更新路径
s[hash] = tmp;//赋值
if(hash == 0){//如果搜索到目标节点直接输出退出
printf("%s\n" , s[hash].ch) ; return 1;
}
q.push(hash);//入对列
}
}
return 0;
}
int main(){
char c;
while(scanf("%c" , &c) != EOF){
if(c == 'x'){ star.state[0] = 9 ; star.pos = 0;}
else star.state[0] = c-'0';
for(int i = 1 ; i < 9 ; i++){
scanf(" %c" , &c);
if(c == 'x'){ star.pos = i ; star.state[i] = 9;}
else star.state[i] = c-'0';
}
getchar();
int flag = Bfs();
if(!flag) printf("unsolvable\n");//无解的情况
}
return 0;
}
