POJ 2286 The Rotation Game IDA*算法

问题描述

如下图所示，有一个“#”形的棋盘，上面有1,2,3三种数字各8个。

给定8种操作，分别为图中的A~H。

这些操作会按照图中字母和箭头所指明的方向，把一条长为8的序列循环移动1个单位。

例如下图最左边的“#”形棋盘执行操作A后，会变为下图中间的“#”形棋盘，再执行操作C后会变成下图最右边的“#”形棋盘。

给定一个初始状态，请使用最少的操作次数，使“#”形棋盘最中间的8个格子里的数字相同。

输入格式
输入包含多组测试用例。

每个测试用例占一行，包含24个数字，表示将初始棋盘中的每一个位置的数字，按整体从上到下，同行从左到右的顺序依次列出。

输入样例中的第一个测试用例，对应上图最左边棋盘的初始状态。

当输入只包含一个“0”的行时，表示输入终止。

输出格式
每个测试用例输出占两行。

第一行包含所有移动步骤，每步移动用大写字母“A~G”中的一个表示，字母之间没有空格，如果不需要移动则输出“No moves needed”。

第二行包含一个整数，表示移动完成后，中间8个格子里的数字。

如果有多种方案，则输出字典序最小的解决方案。

样例

输入样例：
1 1 1 1 3 2 3 2 3 1 3 2 2 3 1 2 2 2 3 1 2 1 3 3
1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 3 3 3 3 3 3 3 3
0
输出样例：
AC
2
DDHH
2

思路
        设计估计函数： 如果中间的数中最多有m个数字相同， 那么我们最少只需要移动 8 - m次就可以得到结果， 所以估计函数设置为 f(n) = 8 - max。
        将图中所有位置标号得到

             A        B
             0        1
             2        3
 H  4   5    6    7   8   9   10     C
             11       12
 G  13  14   15   16  17  18  19     D
             20      21
             22      23
             F        E

这样我们就可以得到相关操作的数组

代表A B C D E F G H 操作的数组为

int oppo[8][7] = {
	{0, 2, 6, 11, 15, 20, 22}, //A
	{1, 3, 8, 12, 17, 21, 23},  //B
    {10, 9, 8, 7, 6, 5, 4},   //C
    {19, 18, 17, 16, 15, 14, 13},  //D
    {23, 21, 17, 12, 8, 3, 1}, //E
    {22, 20, 15, 11, 6, 2, 0},  //F
    {13, 14, 15, 16, 17, 18, 19},  //G 
    {4, 5, 6, 7, 8, 9, 10}  //H
};

目标位置， 即中间的数组为

int center[8] = {6, 7, 8, 11, 12, 15, 16, 17};

存相反操作的数组为

int opposite[8] = {5, 4, 7, 6, 1, 0, 3, 2}; 

代码

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N = 30;
int oppo[8][7] = {
	{0, 2, 6, 11, 15, 20, 22},
	{1, 3, 8, 12, 17, 21, 23},
    {10, 9, 8, 7, 6, 5, 4},
    {19, 18, 17, 16, 15, 14, 13},
    {23, 21, 17, 12, 8, 3, 1},
    {22, 20, 15, 11, 6, 2, 0},
    {13, 14, 15, 16, 17, 18, 19},
    {4, 5, 6, 7, 8, 9, 10}
};
int q[N], path[100], sum[4];
int center[8] = {6, 7, 8, 11, 12, 15, 16, 17};
int opposite[8] = {5, 4, 7, 6, 1, 0, 3, 2}; 

int f(){
	memset(sum, 0, sizeof sum);
	for(int i = 0; i < 8; i++) 
		sum[q[center[i]]]++;		
	int maxx = 0;
	for(int i = 1; i < 4; i++)
		maxx = max(maxx, sum[i]);	
	return 8 - maxx;	
}
bool check(){
	for(int i = 1; i < 8; i++){
		if(q[center[i]] != q[center[0]]) return false;
	}
	return true;
}
void oper(int x){
	int t = q[oppo[x][0]];
	for(int i = 0; i < 6; i++)
		q[oppo[x][i]] = q[oppo[x][i + 1]];
	q[oppo[x][6]] = t;
}
bool dfs(int depth, int maxx, int last){
	if(depth + f() > maxx) return false;
	if(check()) return true;
	for(int i = 0; i < 8; i++){
		if(opposite[i] == last) continue;
		oper(i);
		path[depth] = i;
		if(dfs(depth + 1, maxx, i)) return true;
		oper(opposite[i]);
	}
	return false;
}
int main(){
	while(~scanf("%d", &q[0]), q[0]){
		int depth = 0;
		for(int i = 1; i < 24; i++) scanf("%d", &q[i]);
		while(!dfs(0, depth, -1)) depth++;
		if(!depth) printf("No moves needed");
		for(int i = 0; i < depth; i++) printf("%c", 'A' + path[i]);
		cout << endl;
		cout << q[6] << endl;
	}
	return 0;
}