hdu1430(康托展开+BFS)

魔板

Time Limit: 10000/5000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)

Total Submission(s): 2102 Accepted Submission(s): 448



Problem Description

在魔方风靡全球之后不久，Rubik先生发明了它的简化版——魔板。魔板由8个同样大小的方块组成，每个方块颜色均不相同，可用数字1-8分别表示。任一时刻魔板的状态可用方块的颜色序列表示：从魔板的左上角开始，按顺时针方向依次写下各方块的颜色代号，所得到的数字序列即可表示此时魔板的状态。例如，序列(1,2,3,4,5,6,7,8)表示魔板状态为：

1 2 3 4

8 7 6 5

对于魔板，可施加三种不同的操作，具体操作方法如下：

A: 上下两行互换,如上图可变换为状态87654321

B: 每行同时循环右移一格,如上图可变换为41236785

C: 中间4个方块顺时针旋转一格,如上图可变换为17245368

给你魔板的初始状态与目标状态，请给出由初态到目态变换数最少的变换步骤，若有多种变换方案则取字典序最小的那种。



Input

每组测试数据包括两行，分别代表魔板的初态与目态。



Output

对每组测试数据输出满足题意的变换步骤。



Sample Input

12345678
17245368
12345678
82754631

Sample Output

C
AC

题解：康托展开的问题解决序列的排序。参见：http://blog.csdn.net/zhongkeli/article/details/6966805

康托展开

　　康托展开的公式是 X=an*(n-1)!+an-1*(n-2)!+...+ai*(i-1)!+...+a2*1!+a1*0! 其中，ai为当前未出现的元素中是排在第几个（从0开始）。

　　这个公式可能看着让人头大，最好举个例子来说明一下。例如，有一个数组 s = ["A", "B", "C", "D"]，它的一个排列 s1 = ["D", "B", "A", "C"]，现在要把 s1 映射成 X。n 指的是数组的长度，也就是4，所以

X(s1) = a4*3! + a3*2! + a2*1! + a1*0!

关键问题是 a4、a3、a2 和 a1 等于啥？

a4 = "D" 这个元素在子数组 ["D", "B", "A", "C"] 中是第几大的元素。"A"是第0大的元素，"B"是第1大的元素，"C" 是第2大的元素，"D"是第3大的元素，所以 a4 = 3。

a3 = "B" 这个元素在子数组 ["B", "A", "C"] 中是第几大的元素。"A"是第0大的元素，"B"是第1大的元素，"C" 是第2大的元素，所以 a3 = 1。

a2 = "A" 这个元素在子数组 ["A", "C"] 中是第几大的元素。"A"是第0大的元素，"C"是第1大的元素，所以 a2 = 0。

a1 = "C" 这个元素在子数组 ["C"] 中是第几大的元素。"C" 是第0大的元素，所以 a1 = 0。（因为子数组只有1个元素，所以a1总是为0）

所以，X(s1) = 3*3! + 1*2! + 0*1! + 0*0! = 20

A B C | 0

A C B | 1

B A C | 2

B C A | 3

C A B | 4

C B A | 5

通过康托逆展开生成全排列

　　如果已知 s = ["A", "B", "C", "D"]，X(s1) = 20，能否推出 s1 = ["D", "B", "A", "C"] 呢？

　　因为已知 X(s1) = a4*3! + a3*2! + a2*1! + a1*0! = 20，所以问题变成由 20 能否唯一地映射出一组 a4、a3、a2、a1？如果不考虑 ai 的取值范围，有

3*3! + 1*2! + 0*1! + 0*0! = 20

2*3! + 4*2! + 0*1! + 0*0! = 20

1*3! + 7*2! + 0*1! + 0*0! = 20

0*3! + 10*2! + 0*1! + 0*0! = 20

0*3! + 0*2! + 20*1! + 0*0! = 20

等等。但是满足 0 <= ai <= n-1 的只有第一组。可以使用辗转相除的方法得到 ai，如下图所示：



知道了a4、a3、a2、a1的值，就可以知道s1[0] 是子数组["A", "B", "C", "D"]中第3大的元素 "D"，s1[1] 是子数组 ["A", "B", "C"] 中第1大的元素"B"，s1[2] 是子数组 ["A", "C"] 中第0大的元素"A"，s[3] 是子数组 ["C"] 中第0大的元素"C"，所以s1 = ["D", "B", "A", "C"]。

然后我们可以把所有状态从12345678开始存储下来，然后把输入的两个状态转化为初始状态变成最后要求的状态求解。

#include<limits>
#include<queue>
#include<vector>
#include<list>
#include<map>
#include<set>
#include<deque>
#include<stack>
#include<bitset>
#include<algorithm>
#include<functional>
#include<numeric>
#include<utility>
#include<sstream>
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<ctime>

#define LL long long
#define eps 1e-8
#define pi acos(-1)
#define INF 0x7fffffff
#define delta 0.98 //模拟退火递增变量
using namespace std;
struct node{
	int a[10];
	int n;
};
string ans[50000];
int vis[50000];
queue <node> q;
char c[3]={'A','B','C'};
int h[10]={0,1,2,6,24,120,720,5040};
void A(node &k){
	swap(k.a[0],k.a[7]);
	swap(k.a[1],k.a[6]);
	swap(k.a[2],k.a[5]);
	swap(k.a[3],k.a[4]);
}
void B(node &k){
	swap(k.a[3],k.a[2]);
	swap(k.a[2],k.a[1]);
	swap(k.a[1],k.a[0]);
	swap(k.a[4],k.a[5]);
	swap(k.a[5],k.a[6]);
	swap(k.a[6],k.a[7]);
}
void C(node &k){
	swap(k.a[1],k.a[2]);
	swap(k.a[1],k.a[6]);
	swap(k.a[6],k.a[5]);
}
int cantor(node k){
	int s=0,i,j;
	for (i=0;i<8;i++){
		int n=0;
		for (j=i+1;j<8;j++)
			if (k.a[i]>k.a[j]) n++;
		s+=n*h[7-i];
	}
	return s;
}
void Init(){
	memset(vis,0,sizeof(vis));
	//memset(ans,NULL,sizeof(ans));
	node k;
	int i;
	for (i=0;i<8;i++)
		k.a[i]=i;
	k.n=cantor(k);
	vis[k.n]=1;
	while (!q.empty()) q.pop();
	q.push(k);
	while (!q.empty()){
		k=q.front();
		q.pop();
		for (i=0;i<3;i++){
			node g=k;
			if (i==0) A(g);
			if (i==1) B(g);
			if (i==2) C(g); 
			g.n=cantor(g);
			if (!vis[g.n]){
				vis[g.n]=1;
				ans[g.n]=ans[k.n]+c[i];
				//cout<<ans[g.n]<<endl;
				q.push(g);
			}
		}
	}
}
string s1,s2;
int main(){
	Init();
	int hh[10],i;
	while (cin>>s1>>s2){
		for (i=0;i<8;i++)
			hh[s1[i]-'0']=i+1;
		node k;
		for (i=0;i<8;i++)
			k.a[i]=hh[s2[i]-'0'];
		cout<<ans[cantor(k)]<<endl;
	}
	return 0;
}

康托逆展开：

#include<limits>
#include<queue>
#include<vector>
#include<list>
#include<map>
#include<set>
#include<deque>
#include<stack>
#include<bitset>
#include<algorithm>
#include<functional>
#include<numeric>
#include<utility>
#include<sstream>
#include<iostream>
#include<iomanip>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<ctime>
#define LL long long
#define eps 1e-8
#define pi acos(-1)
#define INF 0x7fffffff
#define delta 0.98 //模拟退火递增变量
using namespace std;

int ans[10]={1,2,3,4,5,6,7,8,9,10};
int h[10]={1,1,2,6,24,120,720,5040,40320,362880};
int a[10],vis[10];
int main(){
	int n,i,j,t;
	printf("输入一个康托展开项数字,求得其序列是多少\n");
	while(~scanf("%d",&n)){
		memset(vis,0,sizeof(vis));
		for (i=0;i<10;i++){
			t=n/h[9-i];
			n=n%h[9-i];
			int k=0;
			for (j=0;j<10;j++)
				if (!vis[j]){
					if (k==t){
						vis[j]=1;
						a[i]=ans[j];
						break;
					}
				 	k++;
				}
		}
		for (i=0;i<10;i++)
			printf("%d ",a[i]);
		cout<<endl; 
	} 
	return 0;
}