POJ 2286 UVA 1343 The Rotation Game IDA*

以前看刘汝佳的方法写过，现在再写一遍

以下是自己意淫的IDA*

g()是旋转的次数 ；

h()的求法：每次移动最多只会使得中央区域包含的数字种类减少1种。求出中央区域个数最多的那个数字的个数 n， 要达到中央区域数字都相同，至少需要 8-n次操作，此即估价函数值

// 1 2
// 3 4
// 5 6 7 8 9 10 11
// 12 13
// 14 15 16 17 18 19 20
// 21 22
// 23 24
#include<cstdio>
#include<cstring>
#include<queue>
#include<set>
#include<string>
#include<algorithm>
#include<iostream>
#define min3(x,y,z) min(x,min(y,z))
using namespace std;
const int center[]={7,8,9,12,13,16,17,18};
const int Move[8][7]={
{1,3,7,12,16,21,23},
{2,4,9,13,18,22,24},
{11,10,9,8,7,6,5},
{20,19,18,17,16,15,14},
{24,22,18,13,9,4,2},
{23,21,16,12,7,3,1},
{14,15,16,17,18,19,20},
{5,6,7,8,9,10,11}
};
const char d[]="ABCDEFGH";
int Board[25];
int diff(int *B,int n){
int cnt=0;
for(int i=0;i<8;i++)
if(B[center[i]]!=n) cnt++;
return cnt;
}
int H(int *B){
return min3(diff(B,1),diff(B,2),diff(B,3));
}
struct Node{
int Board[25];
string path;
int f,g,h;
Node(int *b,int g,string p):g(g),path(p){memcpy(Board,b,sizeof(Board));h=H(b);f=g+h;}
bool operator < (const Node& n) const{
if(f==n.f) return path>n.path; //保证字典序
return f>n.f;
}
};
set<long long> closed;
bool inClosed(int* B){
long long code=0;
for(int i=1;i<=24;i++){
code|=B[i];
code<<=2;
}
if(closed.count(code)) return true;
closed.insert(code);
return false;
}
bool A_Star(int maxd)
{
priority_queue<Node> open; closed.clear();
open.push(Node(Board,0,""));
int nBoard[25];
while(!open.empty())
{
Node u=open.top(); open.pop();
if(u.h==0){
cout<<(u.g?u.path:"No moves needed")
<<endl<<u.Board[7]<<endl;
return true;
}
if(u.g+u.h>maxd) continue;
for(int i=0;i<8;i++)
{
memcpy(nBoard,u.Board,sizeof(nBoard));
for(int j=0;j<6;j++)
nBoard[Move[i][j]]=u.Board[Move[i][j+1]];
nBoard[Move[i][6]]=u.Board[Move[i][0]];

if(inClosed(nBoard)) continue;
open.push(Node(nBoard,u.g+1,u.path+d[i]));
}
}
return false;
}
int main()
{
while(scanf("%d",&Board[1])&&Board[1])
{
for(int i=2;i<=24;i++) scanf("%d",&Board[i]);
for(int i=1;i<=24;i++) if(!Board[i]) break;
for(int maxd=1;;maxd++)
if(A_Star(maxd)) break;
}
return 0;
}

结果WR 因为答案求出来并非字典序最小，我的策略是优先比较f()，如果f()相同就比较字典序，而有可能f()大的反而字典序小，因为h()中并未体现字典序，所以单单比较f并非字典序最小，

输入 1 2 2 3 3 3 1 1 1 1 2 2 2 2 3 3 3 3 3 1 1 1 1 1 正确的是：GBBCGAAA ，而我的是GBBGCAAA

所以只能比较g，且在g相同的时候path最小，类似BFS

比较函数改成如下就AC了

struct Node{
int Board[25];
string path;
int f,g,h;
Node(int *b,int g,string p):g(g),path(p){memcpy(Board,b,sizeof(Board));h=H(b);f=g+h;}
bool operator < (const Node& n) const{
if(g==n.g) return path>n.path;
return g>n.g;
}
};

但超级慢，2000MS+

所以不如用DFS，首先是天然的字典序，其次无需浪费判重的时间，而且深搜索一开始不会像BFS重复

BFS如下：160MS

// 1 2
// 3 4
// 5 6 7 8 9 10 11
// 12 13
// 14 15 16 17 18 19 20
// 21 22
// 23 24
#include<cstdio>
#include<cstring>
#include<queue>
#include<set>
#include<string>
#include<algorithm>
#include<iostream>
#define min3(x,y,z) min(x,min(y,z))
using namespace std;
const int center[]={7,8,9,12,13,16,17,18};
const int rev[]={5,4,7,6,1,0,3,2};
const int Move[8][7]={
{1,3,7,12,16,21,23},
{2,4,9,13,18,22,24},
{11,10,9,8,7,6,5},
{20,19,18,17,16,15,14},
{24,22,18,13,9,4,2},
{23,21,16,12,7,3,1},
{14,15,16,17,18,19,20},
{5,6,7,8,9,10,11}
};
int Board[25];
int diff(int n){
int cnt=0;
for(int i=0;i<8;i++)
if(Board[center[i]]!=n) cnt++;
return cnt;
}
int H(){
return min3(diff(1),diff(2),diff(3));
}
int solved(){
for(int i=1;i<8;i++)
if(Board[center[0]]!=Board[center[i]]) return false;
return true;
}
void move(int i){
int tmp=Board[Move[i][0]];
for(int j=0;j<6;j++)
Board[Move[i][j]]=Board[Move[i][j+1]];
Board[Move[i][6]]=tmp;
}
char ans[1000];
bool DFS(int dep,int maxd)
{
if(solved()) {
ans[dep]='\0';
return true;
}
if(dep+H()>maxd) return false;
for(int i=0;i<8;i++){
ans[dep]='A'+i;
move(i);
if(DFS(dep+1,maxd)) return true;
move(rev[i]);
}
return false;
}
int main()
{
while(scanf("%d",&Board[1])&&Board[1])
{
for(int i=2;i<=24;i++) scanf("%d",&Board[i]);
if(solved()) cout<<"No moves needed"<<endl;
else{
for(int maxd=1;;maxd++)
if(DFS(0,maxd)) break;
cout<<ans<<endl;
}
cout<<Board[7]<<endl;
}
return 0;
}