poj1077-不作此题人生不完整~经典搜索题

这题可不是简单的迷宫搜索之类的，我用STL的单向bfs搜索就超时了，于是我迫不得已手写队列，AC，接下来要尝试双向和A*
首先是单向BFS：



300ms还可以啊，我以为会是七八百毫秒的

这个是A星算法的：



估价函数我自己想的，所以没那些人那么快
/*******单向BFS********
****会用康托函数以及保存路径就行**/
#include<iostream>
#include<string>
#include<queue>
#define M 900000
using namespace std;
int fac[] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880 };
int vis[M],pre[M],flag;
char ans[M],way[M];
int dir[]={-1,1,3,-3}; //l,r,u,d
char dc[4]={'l','r','d','u'};
typedef struct
{
int x; //这个就是八数码的状态值
int t; //步数
int place; //x在九位数字中的位置
char str[10]; //那个状态时的字符串
}puzzle;

puzzle p[M]; //手动创建队列
int front;
int rear;

void EnQ(puzzle pp) //入队
{
p[rear]=pp;
rear=(rear+1)%M;
}

puzzle DeQ( ) //出队
{
puzzle pp;
pp=p[front];
front=(front+1)%M;
return pp;
}

int order(char *s, int n) //利用康托展开，求字符串的状态值
{
int i, j, temp, num;
num = 0;
for (i = 0; i < n-1; i++)
{
temp = 0;
for (j = i + 1; j < n; j++)
if (s[j] < s[i])
temp++;
num += fac[s[i]-1-'0'] * temp;
}
return num;
}

void bfs(char s[],int start)
{
int i,y;
char temp;
memset(vis,0,sizeof(vis));
front=rear=0;
puzzle pp,ppp;
pp.x=order(s,9);
pp.t=0;
pp.place=start;
strcpy(pp.str,s);
vis[pp.x]=1;
EnQ(pp);
while(front!=rear)
{
pp=DeQ();
if(pp.x==0)
{
flag=1;
int a=pp.x;
for(i=pp.t;i>=1;i--) //照着之前储存的信息一直回到起点
{
ans[i]=way[a];
a=pre[a];
}
for(i=1;i<=pp.t;i++)
printf("%c",ans[i]);
cout<<endl;
return ;
}

for(i=0;i<4;i++)
{
ppp=pp;
y=ppp.place+dir[i]; //要变换的位置
if((i==0&&y%3==2)||(i==1&&y%3==0)||y<0||y>8)
continue;

temp=ppp.str[pp.place];
ppp.str[ppp.place]=ppp.str[y];
ppp.str[y]=temp; //交换操作，改变字符串
y=order(ppp.str,9); // 再把y=那个hash值

if(vis[y]==0)
{
pre[y]=ppp.x; //这个点的前一位赋值
ppp.x=y;
vis[y]=1;
way[y]=dc[i];
ppp.t++;
ppp.place+=dir[i];
EnQ(ppp);
}

}

}

}

int main()
{
int i,j;
char s[10];
char str,start;
flag=0;
for(i=0;i<9;)
{
scanf("%c",&str);
if(str!=' ')
{
if(str=='x')
{
s[i]='9';
start=i;
}
else
s[i]=str;
i++;
}
}
s[9]='\0';
bfs(s,start);
if(flag==0)
cout<<"unsolvable"<<endl;

}

<pre name="code" class="cpp">/*******不知道真假的A星算法*********
****f=g（已走步数）+h（每一个格子回到原位所需的步数）+**/
#include<iostream>
#include<string>
#include<queue>
#include<cmath>
#define M 900000
using namespace std;
int fac[] = { 1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880 };
int vis[M],pre[M],flag;
char ans[M],way[M];
int dir[]={-1,1,3,-3}; //l,r,u,d
char dc[4]={'l','r','d','u'};
char *ss="123456789";
struct puzzle
{
int x; //这个就是八数码的状态值
int place; //x在九位数字中的位置
int f; //总代价
int g; //已用代价
int h; //估计代价
char str[10]; //那个状态时的字符串
bool operator < (const puzzle &a) const
{
if(f==a.f)
return h>a.h; //优先选择f值小的，如果f值相等有点选择h值小的
else return f>a.f;
}
};

int order(char *s, int n) //利用康托展开，求字符串的状态值
{
int i, j, temp, num;
num = 0;
for (i = 0; i < n-1; i++)
{
temp = 0;
for (j = i + 1; j < n; j++)
if (s[j] < s[i])
temp++;
num += fac[s[i]-1-'0'] * temp;
}
return num;
}

int FindH(char *s) //h=每一个格子回到原位所需的步数
{
int sum=0,m;
for(int i=0;i<9;i++)
if(s[i]!=ss[i])
{
m=abs(s[i]-'0'-1-i);
sum+=m/3+m%3;
}
return sum;
}

void bfs(char s[],int start)
{
int i,y;
char temp;
memset(vis,0,sizeof(vis));
priority_queue<puzzle>q;
struct puzzle pp,ppp;
pp.x=order(s,9);
pp.g=0;
pp.place=start;
strcpy(pp.str,s);
vis[pp.x]=1;
pp.h=FindH(pp.str);
pp.f=pp.h+pp.g;
q.push(pp);
while(!q.empty())
{
pp=q.top(); //先出队的都是f值小的
q.pop();
if(pp.x==0)
{
flag=1;
int a=pp.x;
for(i=pp.g;i>=1;i--) //照着之前储存的信息一直回到起点
{
ans[i]=way[a];
a=pre[a];
}
for(i=1;i<=pp.g;i++)
printf("%c",ans[i]);
cout<<endl;
return ;
}

for(i=0;i<4;i++)
{
ppp=pp;
y=ppp.place+dir[i]; //要变换的位置
if((i==0&&y%3==2)||(i==1&&y%3==0)||y<0||y>8)
continue;

temp=ppp.str[pp.place];
ppp.str[ppp.place]=ppp.str[y];
ppp.str[y]=temp; //交换操作，改变字符串
y=order(ppp.str,9); // 再把y=那个hash值

if(vis[y]==0)
{
pre[y]=ppp.x; //这个点的前一位赋值
ppp.x=y;
vis[y]=1;
way[y]=dc[i];
ppp.place+=dir[i];
ppp.g++;
ppp.h=FindH(ppp.str);
ppp.f=ppp.h+ppp.g;
q.push(ppp);
}

}

}

}

int main()
{
int i,j;
char s[10];
char str,start;
flag=0;
for(i=0;i<9;)
{
scanf("%c",&str);
if(str!=' ')
{
if(str=='x')
{
s[i]='9';
start=i;
}
else
s[i]=str;
i++;
}
}
s[9]='\0';
bfs(s,start);
if(flag==0)
cout<<"unsolvable"<<endl;

}