HDU 1043 ，POJ 1077 Eight
八数码问题
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
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
一、数据如何存储和表示？
1、可以用整形来表示八数码的状态，x可以当作“9”，“0”不好处理，例如终态12345678x，可以表示成整数123456789，
2、用数组来存储，这里x可以用0或9来表示。
二、数据如何拓展？
1、对于int型整数，数据的拓展就是对这个数的处理，例如对于整数
1 2 3 1 2 3
4 5 6 4 5 9
7 8 9 x上移一位变成的状态是 7 8 6 即整数123459786
2、对于数组，数据拓展就是将该数组看成是二维数组，对此二维数组行和列的处理
三、如何记录路径？
1、构造一张邻接表，链式或者是连续存储都可以，记录每个节点的父节点和所有子节点，最后从目的节点递归输出最短路径，不用耗费大量内存记录走过的路径，所以极力推荐此种实现方法，具体应用可以参见
LeetCode OJ:Word Ladder II 解题思路过程详谈
2、因为此题只是记录udlr，所以可以用string来记录，不过因为对每个路径都需要存储走过的路径，太耗内存，所以不推荐
四、如何判重？
1、对于int型数组，可以构造一个大数组，记录是否访问，如vis[123456789]表示123456789状态是否访问，优点：快速。缺点：大量数据浪费，int类型大小的局限性
2、对于数组，可以将数组变成int型，再进行操作
3、用map来存，避免大量浪费
4、用康托拓展判重
五、状态转移如何建立？
1、最简单的无非是广搜，
（1）正向广搜
（2）反向广搜，将所有可能点都记录下来，用string[]大数组存储所有路径，当输入数据次数较多时比较适用，因为广搜只进行1次，内存消耗太大
2、双向广搜
3、A*算法
4、IDA*算法
这里提供一个使用双向广搜+map+int型存储数据版，答案不对，仅供参考
#include
#include 再提供一个反向广搜版+康托版
/*
HDU 1043 Eight
思路：反向搜索，从目标状态找回状态对应的路径
用康托展开判重
*/
#include
#include
#include
#include
#include
using namespace std;
const int MAXN=1000000;//最多是9!/2
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};//康拖展开判重
// 0!1!2!3! 4! 5! 6! 7! 8! 9!
bool vis[MAXN];//标记
string path[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]q;
q.push(cur);
path[aim]="";
while(!q.empty())
{
cur=q.front();
q.pop();
int x=cur.loc/3;
int y=cur.loc%3;
for(int i=0;i<4;i++)
{
int tx=x+dir[i][0];
int ty=y+dir[i][1];
if(tx<0||tx>2||ty<0||ty>2)continue;
next=cur;
next.loc=tx*3+ty;
next.s[cur.loc]=next.s[next.loc];
next.s[next.loc]=0;
next.status=cantor(next.s);
if(!vis[next.status])
{
vis[next.status]=true;
next.path=indexs[i]+next.path;
q.push(next);
path[next.status]=next.path;
}
}
}
}
int main()
{
freopen("C:\\in.txt","r",stdin);
char ch;
Node cur;
bfs();
while(cin>>ch)
{
if(ch=='x') {cur.s[0]=0;cur.loc=0;}
else cur.s[0]=ch-'0';
for(int i=1;i<9;i++)
{
cin>>ch;
if(ch=='x')
{
cur.s[i]=0;
cur.loc=i;
}
else cur.s[i]=ch-'0';
}
cur.status=cantor(cur.s);
if(vis[cur.status])
{
cout< 再提供一个A*+康托版
#include
#include
#include
#include
#include
using namespace std;
const int MAXN=1000000;
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};//康拖展开判重
// 0!1!2!3! 4! 5! 6! 7! 8! 9!
bool vis[MAXN];//标记
string path;//记录最终的路径
int dir[4][2]={{-1,0},{1,0},{0,-1},{0,1}};//方向向量
char indexs[5]="udlr";//正向搜索
struct Node
{
int data[9];
int f,g,h;
int loc;//“0”的位置,把“x"当0
int status;//康拖展开的hash值
string path;//路径
bool operator==(const Node &t){
return status==t.status;
}
bool operator<(const Node &t)const{
return f>t.f;
}
}start,goal;//起始和终止点
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] q;
q.push(start);
while(!q.empty())
{
cur=q.top();
q.pop();
if(cur==goal)
{
path=cur.path;
return true;
}
int x=cur.loc/3;
int y=cur.loc%3;
for(int i=0;i<4;i++)
{
int tx=x+dir[i][0];
int ty=y+dir[i][1];
if(tx<0||tx>2||ty<0||ty>2)continue;
next=cur;
next.loc=tx*3+ty;
next.data[cur.loc]=next.data[next.loc];
next.data[next.loc]=0;
next.status=Cantor(next.data);
if(!vis[next.status])
{
vis[next.status]=true;
next.path=next.path+indexs[i];
if(next==goal)
{
path=next.path;
return true;
}
next.g++;//g值
next.f=Fvalue(next,goal,1);//f值
q.push(next);
}
}
}
return false;
}
int main()
{
freopen("C:\\in.txt","r",stdin);
char ch;
//目的节点初始化start
for(int i=0;i<8;i++)goal.data[i]=i+1;
goal.data[8]=0;
goal.status=46234;//123456780对应的康拖展开的hash值
//end
while(cin>>ch)
{
//起始节点初始化start
if(ch=='x') {start.data[0]=0;start.loc=0;}
else start.data[0]=ch-'0';
for(int i=1;i<9;i++)
{
cin>>ch;
if(ch=='x')
{
start.data[i]=0;
start.loc=i;
}
else start.data[i]=ch-'0';
}
start.status=Cantor(start.data);//康拖hash值
start.g=0;
start.f=Fvalue(start,goal,1);//计算f值
//end
if(Astar())
{
cout< 最后再提供一个IDA*版，比A*更简洁更快
/*
POJ 1077 Eight
C++
Memory 168K
Time 32MS
*/
#include
#include
using namespace std;
const unsigned int M = 1001;
int dir[4][2] = {
1, 0, // Down
-1, 0, // Up
0,-1, // Left
0, 1 // Right
};
typedef struct STATUS{
int data[3][3];
int r,c;//0所在的位置
}STATUS;
char dirCode[] = {"dulr"};
char rDirCode[] = {"udrl"};
char path[M]; // 最优解
STATUS start, goal = { 1,2,3,4,5,6,7,8,0,2,2 }; // 起始和终止状态
int maxDepth = 0; // 深度边界
//计算h值，作为IDAstar算法的评估函数
int dist(STATUS suc, STATUS goal, int k) {//计算方格的错位距离
int si,sj,gi,gj; //si,sj表示suc中k所处位置，gi,gj表示goal中k所处的位置
for(int i=0;i<3;i++)
for(int j=0;j<3;j++){
if(suc.data[i][j]==k){
si=i;sj=j;
}
if(goal.data[i][j]==k){
gi=i;
gj=j;
}
}
return abs(si-gi) + abs(sj-gj);
}
int H(STATUS suc, STATUS goal) {//计算 h 值
int h = 0;
for(int i = 1; i <= 8; i++)
h = h + dist(suc, goal, i);
return h;
}
//计算h值结束
//IDAstar算法开始
bool dfs(STATUS cur,int depth,int h,char preDir){
//IDA*估值函数剪枝
//当前局面的估价函数值+当前的搜索深度 > 预定义的最大搜索深度时剪枝
if(depth+h>maxDepth)return false;
if(memcmp(&cur, &goal, sizeof(STATUS)) == 0 )
{
path[depth] = '\0';
return true;
}
STATUS next;
for(int i=0;i<4;++i){
if(dirCode[i]==preDir)continue;//不能回到上一状态
next=cur;
next.r = cur.r + dir[i][0];
next.c = cur.c + dir[i][1];
if( !( next.r >= 0 && next.r < 3 && next.c >= 0 && next.c < 3 ) )
continue;
swap(next.data[cur.r][cur.c], next.data[next.r][next.c]); //置换变成新的状态
int nexth=H(next,goal);//重新计算h值
path[depth] = dirCode[i];
if(dfs(next, depth + 1, nexth, rDirCode[i]))
return true;
}
return false;
}
int IDAstar(){
int h = H(start,goal);
maxDepth = h;
while (!dfs(start,0, h, '\0'))
maxDepth++;
return maxDepth;
}
//IDAstar算法结束
//是否可解
bool IsSolvable(const STATUS &cur)
{
int i, j, k=0, s = 0;
int a[9];
for(i=0; i < 3; i++){
for(j=0; j < 3; j++){
if(cur.data[i][j]==0) continue;
a[k++] = cur.data[i][j];
}
}
for(i=0; i < 8; i++){
for(j=i+1; j < 8; j++){
if(a[j] < a[i])
s++;
}
}
return (s%2 == 0);
}
//初始状态赋值
void input(){
char c;
for(int i=0;i<3;i++){
for(int j=0;j<3;j++){
cin>>c;
if(c=='x'){start.data[i][j]=0;start.r=i;start.c=j;}
else start.data[i][j]=c-'0';
}
}
}
int main(){
freopen("C:\\in.txt","r",stdin);
input();
if(IsSolvable(start)){
IDAstar();
cout<