八数码问题,类似华容道,要求给出复位的操作序列。
康托展开用于解决排列相关问题,实现了一个排列到整数双射。因此我们可以用一个整数表示当前排列,便于进行搜索。以下是康托展开和逆展开的模板。
int cantor(int* st){
int x=0;
for(int i=0;i<9;i++){
int smaller=0;
for(int j=i+1;j<9;j++){
if(st[j]<st[i])
smaller++;
}
x+=fac[8-i]*smaller;
}
return x;
}
void decantor(int x){
vector<int> v;
for(int i=1;i<=9;i++)
v.push_back(i);
for(int i=8;i>=0;i--){
int r=x%fac[i];
int t=x/fac[i];
x=r;
sort(v.begin(),v.end());
tmp[8-i]=v[t];
v.erase(v.begin()+t);
}
}
题目打算采用bfs,从0状态出发寻找初始状态,途中每个状态都存储当前cmd序列和9的位置。但是这份代码最终mle了。。。
之后得知,路径最长不会超过三十多,则将路径储存在一个全局数组中path[9!][50],空间缩小将近一半,但出现超时的问题,考虑剪枝:在移动x的过程中逆序数的变化为偶数,而由于目标序列逆序数为0,所以初始逆序数如果是奇数,则可直接排除。
依然超时,推测是因为数据组数多,bfs要打表了。之前一直都是当作直跑一次写的代码。打算干脆放下去学A*。
A*搜索的原理很符合逻辑,大概地判断当前情况的优劣,并以此为排序权重影响搜索的顺序。同时将x节点所代表的值由9改为0,方便计算逆序数。
AC代码:
#include<bits/stdc++.h>
using namespace std;
static const int fac[10]={1,1,2,6,24,120,720,5040,40320,362880};
int sp[9];
int target[9]={1,2,3,4,5,6,7,8,0};
bool vis[362880];
int step[4][2]={{1,0},{0,1},{-1,0},{0,-1}};
char cmd[5]="drul";
int spos;
char path[362880];
int bck[362880];
void disp(int n){
if(bck[n]){
disp(bck[n]);
printf("%c",path[n]);
}
}
struct state{
int dat;
int pos;
int h,g,f;
state(){}
state(int _dat,int _pos,int _h,int _g):dat(_dat),pos(_pos),h(_h),g(_g){
f=g+h;
}
bool operator<(const state& st)const{
if(f!=st.f)
return f>st.f;
else
return g>st.g;
}
};
int geth(int s[]){
int res=0;
for(int i=0;i<9;i++){
if(s[i]==0)
continue;
int x=i/3; //当前位置
int y=i%3;
int tx=(s[i]-1)/3; //这个位置上的值,减一即为目标位置
int ty=(s[i]-1)%3;
res+=abs(x-tx)+abs(y-ty);
}
return res;
}
int cantor(int* st){
int x=0;
for(int i=0;i<9;i++){
int smaller=0;
for(int j=i+1;j<9;j++){
if(st[j]<st[i])
smaller++;
}
x+=fac[8-i]*smaller;
}
return x;
}
void decantor(int x,int* a){
vector<int> v;
for(int i=0;i<9;i++)
v.push_back(i);
for(int i=8;i>=0;i--){
int r=x%fac[i];
int t=x/fac[i];
x=r;
sort(v.begin(),v.end());
a[8-i]=v[t];
v.erase(v.begin()+t);
}
}
int cal(int* s){
//计算逆序数 reverse order number
int res=0;
for(int i=1;i<9;i++){
if(!s[i])
continue;
int tmp=0;
for(int j=0;j<i;j++)
if(s[j]>s[i])
tmp+=1;
res+=tmp;
}
return res;
}
int s[9]={0};
void bfs(){
memset(vis,0,sizeof(vis));
memset(path,0,sizeof(path));
memset(bck,0,sizeof(bck));
int dest=cantor(target);
memcpy(s,sp,9*sizeof(int));
int ron=cal(sp)-cal(target);
if(ron&1){
puts("unsolvable");
return;
}
priority_queue<state> q;
state st;
st.dat=cantor(s);
st.pos=spos;
st.g=0;
st.f=0;
st.h=0;
q.push(st);
vis[st.dat]=1;
while(!q.empty()){
state now=q.top();
if(now.dat==dest){
if(now.g==0)
puts("lr");
else{
disp(dest);
puts("");
}
return;
}
q.pop();
int x=now.pos/3;
int y=now.pos%3;
for(int i=0;i<4;++i){
int nx=x+step[i][0];
int ny=y+step[i][1];
if(nx<0||nx>2||ny<0||ny>2)
continue;
decantor(now.dat,s);
swap(s[x*3+y],s[nx*3+ny]);
int ndat=cantor(s);
if(!vis[ndat]){
int h=geth(s);
vis[ndat]=1;
bck[ndat]=now.dat;
path[ndat]=cmd[i];
q.push(state(ndat,nx*3+ny,h,now.g+1));
}
swap(s[x*3+y],s[nx*3+ny]);
}
}
cout<<"unsolvable"<<endl;
}
int main(){
char c;
while(cin>>c){
if(c=='x'){
spos=0;
sp[0]=0;
}
else
sp[0]=c-'0';
for(int i=1;i<9;i++){
cin>>c;
if(c=='x')
spos=i,sp[i]=0;
else
sp[i]=c-'0';
}
bfs();
}
return 0;
}
/*
1 2 3 4 5 6 7 8 x
2 1 3 4 5 6 7 8 x
1 3 x 4 2 6 7 5 8
1 2 3 4 5 6 7 x 8
*/
接下来是HDU3567,这一题比前面那道区别在于,给出T个测试,每次任意给起点终点,要求输出最短字典序最小的操作序列。
考虑双向bfs,前半段的字典序可以通过控制每层遍历时的移动方向决定,后半段则只能通过枚举所有最短的序列。由于bfs的特点,每次循环的层数代表了序列的长度,这样一层一层找下去肯定首先找到最短的,再在其中寻找字典序最小。
建立两个队列,每次先对q1进行遍历,寻找有没有状态已从后半段抵达;再对q2遍历,每次遇到后半段已到达的则说明,这是这次遍历的成果,尝试进行字典序更新。
代码如下,蜜汁WA调不出来了,大概思路是这样的:
#include<stdio.h>
#include<memory.h>
#include<queue>
#include<algorithm>
#include<iostream>
#include<string>
#include<cstring>
#include<map>
#include<vector>
using namespace std;
//升级八数码
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
int cantor(int* st){
int x=0;
for(int i=0;i<9;i++){
int smaller=0;
for(int j=i+1;j<9;j++){
if(st[j]<st[i])
smaller++;
}
x+=fac[8-i]*smaller;
}
return x;
}
struct node{
int hsh;
int pos;
int s[9];
};
int vis[362885];
string path[362885];
char cmd[]="dlru";
int dx[4]={1,0,0,-1};
int dy[4]={0,-1,1,0};
int dx2[4]={-1,0,0,1};
int dy2[4]={0,1,-1,0};
string bfs(node startP,node endP){
if(startP.hsh==endP.hsh)
return "";
queue<node>q1;
queue<node>q2;
memset(vis,0,sizeof vis);
q1.push(startP);
vis[startP.hsh]=1;
path[startP.hsh]="";
q2.push(endP);
vis[endP.hsh]=2;
path[endP.hsh]="";
while(!q1.empty()&&!q2.empty()){
int sz1=q1.size();
for(int i=0;i<sz1;i++){
node now=q1.front();
q1.pop();
int x=now.pos/3;
int y=now.pos%3;
//cout<<path[46232]<<endl;
//cout<<p<<endl;
for(int j=0;j<4;j++){
int nx=x+dx[j];
int ny=y+dy[j];
if(nx>=0&&nx<3&&ny>=0&&ny<3){
node n=now;
n.pos=nx*3+ny;
swap(n.s[now.pos],n.s[n.pos]);
n.hsh=cantor(n.s);
string p=path[now.hsh]+cmd[j];
if(vis[n.hsh]==2){
//cout<<p<<endl;
return p+path[n.hsh];
}else if(vis[n.hsh]==0){
vis[n.hsh]=1;
path[n.hsh]=p;
//cout<<path[n.hash]<<' '<<cmd[j]<<endl;
//cout<<path[46232]<<endl;
q1.push(n);
}
}
}
}
int sz2=q2.size();
for(int i=0;i<sz2;i++){
node now=q2.front();
q2.pop();
int x=now.pos/3;
int y=now.pos%3;
for(int j=0;j<4;j++){
int nx=x+dx2[j];
int ny=y+dy2[j];
if(nx>=0&&nx<3&&ny>=0&&ny<3){
node n=now;
n.pos=nx*3+ny;
swap(n.s[now.pos],n.s[n.pos]);
n.hsh=cantor(n.s);
string p=cmd[j]+path[now.hsh];
if(vis[n.hsh]==0){
path[n.hsh]=p;
vis[n.hsh]=2;
q2.push(n);
}else if(vis[n.hsh]==2){
if(p<path[n.hsh])
path[n.hsh]=p;
}
}
}
}
}
return "unsolvable";
}
int main(){
#ifdef LOCAL
freopen("data.in","r",stdin);
freopen("data.out","w",stdout);
#endif
int t;
cin>>t;
char s[10],e[10];
for(int i=1;i<=t;i++){
scanf("%s%s",s,e);
node S,E;
for(int i=0;i<9;i++){
if(s[i]=='X')
S.pos=i,S.s[i]=9;
else
S.s[i]=s[i]-'0';
if(e[i]=='X')
E.s[i]=9,E.pos=i;
else
E.s[i]=e[i]-'0';
}
S.hsh=cantor(S.s);
E.hsh=cantor(E.s);
string res=bfs(S,E);
printf("Case %d: %d\n",t,res.size());
cout<<res<<endl;
}
return 0;
}
/*
2
12X453786
12345678X
564178X23
7568X4123
1
1234X6758
12345678X
*/