八数码 POJ1077 （康托展开与奇偶排列详解）

本文探讨了康托展开在状态压缩中的应用，特别是在解决八数码问题时。通过详细的代码示例和理论解释，展示了如何利用康托展开进行状态编码，以及如何判断八数码问题的可解性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目链接

八数码问题有多种解决方法，在这里只具体讲述一下康托展开在状态压缩中的应用。

题意：

输入一段数字序列，表示3×3棋盘0到8的一种排列状态，要求计算从初始状态到达目标状态（1 2 3 4 5 6 7 8 0）所需的最少步数，并输出操作过程。

思路：

本题的关键是标记每一种可能扩展到的状态，由于所有的状态个数对应的是9的全排列，如果仅仅是简单地扩展标记数组的维度必然会超内存，所以此时应该进行状态压缩，这里使用的是康托展开，同时为了减少不必要的操作缩短耗时，在执行BFS前首先要判断输入数据是否有解，这就涉及到八数码有解性的判定问题，将输入数据进行以上预处理后再执行BFS就不会超时了。（如果状态数不够多的情况下可以将每种状态存入set或map容器中，每次扩展时再进行查找，由于这两种容器插入和查找的时间复杂度近似为 $O (l o g n)$ ，所以应用在此题中其实是会超时的。）

补充：

八数码问题有解性的判定

因为排列有奇排列和偶排列两类，经过一次对换，奇排列变成偶排列，偶排列变成奇排列，但由于在本题中移动的是0，而移动0的位置并不改变排列的奇偶性，所以可以通过检查初始状态和目标状态排列的奇偶性是否相同来判断输入数据是否有解。

代码实现：

//判断是否有解(奇偶序列)
bool Solable(int* list){
	int sum=0;
	for(int i=0;i<9;i++){
		if(list[i]==0)
			continue;
		for(int j=0;j<i;j++){
			if(list[j]<list[i]&&list[j]!=0)
				sum++;
		}
	}
	if(sum%2==0)
		return true;
	else
		return false;
}

康托展开

定义

康托展开是一个全排列到一个自然数的双射，常用于构建哈希表时的空间压缩。康托展开的实质是计算当前排列在所有由小到大全排列中的顺序，因此是可逆的。

公式
$X=a_n(n-1)!+a_{n-1}(n-2)!+···+a_1·0！$

其中 $a_i$ 指的是位于位置 $i$ 后面的小于 $a_i$ 的数的个数， $X$ 指的是在当前排列前面所有排列的个数，所以 $X + 1$ 才是在全排列中的次序。

举例

例如， $357412968$ 展开为 $98884$ 。因为 $X = 2 \times 8! + 3 \times 7! + 4 \times 6! + 2 \times 5! + 0 \times 4! + 0 \times 3! + 2 \times 2! + 0 \times 1! + 0 \times 0! = 98884 .$

解释

排列的第一位是 $3$ ，比 $3$ 小的数有两个，以这样的数开始的排列有 $8!$ 个，因此第一项为 $2 \times 8!$
排列的第二位是 $5$ ，比5小的数有 $1 、 2 、 3 、 4$ ，由于 $3$ 已经出现，因此共有 $3$ 个比 $5$ 小的数，这样的排列有 $7!$ 个，因此第二项为 $3 \times 7$ ，以此类推，直至 $0 \times 0!$

用途

显然， $n$ 位 $（ 0 到 n - 1 ）$ 全排列后，其康托展开唯一且最大约为 $n!$ ，因此可以由更小的空间来储存这些排列。由公式可将 $X$ 逆推出唯一的一个排列。

逆康托展开

既然康托展开是一个双射，那么一定可以通过康托展开值求出原排列，即可以求出 $n$ 的全排列中第 $x$ 大排列。

代码实现

康托展开

//返回数组a中当下顺序的康拖映射，n为位数
int cantor(int *a,int n)
{
	int ans=0;
	for(int i=0;i<n;i++)
	{
		int x=0;int c=1,m=1;//c记录后面的阶乘
		for(int j=i+1;j<n;j++)
		{
			if(a[j]<a[i])x++;
			m*=c;c++;
		}
		ans+=x*m;
	}
	return ans;
}

逆康托展开

static const int FAC[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};   // 阶乘
  
//康托展开逆运算
void decantor(int x, int n)
{
    vector<int> v;  // 存放当前可选数
    vector<int> a;  // 所求排列组合
    for(int i=1;i<=n;i++)
        v.push_back(i);
    for(int i=m;i>=1;i--)
    {
        int r = x % FAC[i-1];
        int t = x / FAC[i-1];
        x = r;
        sort(v.begin(),v.end());// 从小到大排序
        a.push_back(v[t]);      // 剩余数里第t+1个数为当前位
        v.erase(v.begin()+t);   // 移除选做当前位的数
    }
}

参考

Wikipedia
康托展开详解

全部代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
using namespace std;
 
struct node{
	int state;
	int father; 
	char move;
	node(){
	}
	node(int s,int f,char m):state(s),father(f),move(m){}
};

const int maxn=400000;	
const int goal=123456780;
char res[maxn];
node Queue[maxn];
int head=0;
int tail=0;
char d[]={'u','d','l','r'};
int fac[] = {1,1,2,6,24,120,720,5040,40320,362880};
//康托展开 
int cantor(int state){	
	int count=100000000;
	int s[9];
	for(int i=0;i<9;i++){
		s[i]=state/count;
		state=state-s[i]*count;
		count/=10;
	}
	int sum=0;
	for(int i=0;i<9;i++){
		int num=0;
		for(int j=i+1;j<9;j++)
			if(s[j]<s[i])
				num++;
		sum+=num*fac[9-i-1];
	}
	return sum+1;
}
//判断是否有解(奇偶序列)
bool Solable(int* list){
	int sum=0;
	for(int i=0;i<9;i++){
		if(list[i]==0)
			continue;
		for(int j=0;j<i;j++){
			if(list[j]<list[i]&&list[j]!=0)
				sum++;
		}
	}
	if(sum%2==0)
		return true;
	else
		return false;
}

int Move(int s,char d){
	int r,c;
	int m[3][3];
	//int to matrix 
	for(int i=2;i>=0;i--){
		for(int j=2;j>=0;j--){
			m[i][j]=s%10;
			s/=10;
			if(m[i][j]==0){
				r=i;
				c=j;
			}
		}
	}
	//move
	if(d=='u'){
		if(r==0)
			return -1;
		swap(m[r][c],m[r-1][c]);
	}
	else if(d=='d'){
		if(r==2)
			return -1;
		swap(m[r][c],m[r+1][c]);
	}
	else if(d=='l'){
		if(c==0)
			return -1;
		swap(m[r][c],m[r][c-1]);
	}
	else{
		if(c==2)
			return -1;
		swap(m[r][c],m[r][c+1]);
	}
	//matrix to int
	int newstate=0;
	int mul=1;
	for(int i=2;i>=0;i--){
		for(int j=2;j>=0;j--){
			newstate+=m[i][j]*mul;
			mul*=10;
		}
	}
	return newstate;	
}

bool bfs(int l){
	bool reach[maxn];
	memset(reach,0,sizeof(reach));
	Queue[tail++]=node(l,-1,'0');
	reach[cantor(Queue[head].state)]=true;
	while(head!=tail){
		node t=Queue[head];
		if(t.state==goal){
			return true;
		}
		for(int i=0;i<4;i++){
			int newstate=Move(t.state,d[i]);
			if(newstate==-1)
				continue;
			if(reach[cantor(newstate)])
				continue;
			reach[cantor(newstate)]=true;
			Queue[tail++]=node(newstate,head,d[i]);
		}
		head++;
	}
	return false;
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	cout.tie(0);
	int l;
	char l1[50];
	char l2[10];
	int list[10];
	while(cin.getline(l1,50)){
		int i,j;
		for(i=0,j=0;l1[i];i++){
			if(l1[i]!=' '){
				if(l1[i]=='x'){
					l2[j]='0';
					list[j]=0;
					j++;
				}		
				else{
					l2[j]=l1[i];
					list[j]=l1[i]-48;
					j++;
				}					
			}
		}
		l=atoi(l2);
		if(!Solable(list)){
			cout<<"unsolable"<<endl;
			continue;
		}
		if(bfs(l)){
			node s0=Queue[head];
			int size=0;
			while(s0.father!=-1){
				res[size++]=s0.move;
				s0=Queue[s0.father];
			}
			for(int i=size-1;i>=0;i--)
				cout<<res[i];
			cout<<endl;
		}
		else
			cout<<"unsolable"<<endl;
	}
	return 0;	
}