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;
}