【算法】康托展开

1. 概述

康托展开是将n个数的全排列映射到自然数空间{0, 1, ... , n!-1}的双射。在介绍康托展开之前，先介绍几个概念：变进制数、逆序对。

1.1 变进制

我们经常使用进制有：二进制、十进制、十六进制。这些进制称为“常数进制”，有一个共同点，即逢p进1；比如，十六进制是每位逢16进1，十进制数每位逢10进1。p进制数K可表示为

K = a1*p^1 + a2*p^2 + ... + an*p^n  ，其中1<= ai <= p-1
该表示法可表示任何一个自然数。

 

有这样一种变进制数：第1位逢2进1，第2位逢3进1，……，第n位逢n+1进1。变进制数可K表示为   

K = a1*1! + a2*2! + a3*3! + ... + an*n!  ，其中0 <= ai <= i
假设变进制数K第i位ai为i+1，则说明需要进位，且ai*i!=(i+1)*i!=1*(i+1)!，即向高位进1；说明该变进制数能够正确进位，从而这是一种合法的计数方式。

这种变进制数K有如下性质（证明参看[1]）：

(1)当所有位ai均为i时，K有最大值(n+1)!-1

(2)当所有位ai均为0时，K有最小值0

1.2 逆序对

对有 n 个互异元素的有序集A，如果存在正整数 i, j 使得 1 ≤ i < j ≤ n 而且 A[i] > A[j]，则 <A[i], A[j]> 这个有序对称为 A 的一个逆序对，也称作逆序数。

例如：数组 <2,3,8,6,1> 的逆序对为：<2,1> <3,1> <8,6> <8,1> <6,1> 共5个。

1.3 康托展开

假设我们有b0,b1,b2,b3,...,bn共n+1个不同的元素，并假设各元素之间有一种次序关系 b0<b1<b2<...<bn。对它们进行全排列，共产生(n+1)!种不同的排列。对于产生的任一排列，第i个元素(1 <= i <= n)与它前面的i个元素构成的逆序对的对数为di(0 <= di <= i)，那么我们得到一个逆序对对数序列d1,d2,...,dn（0 <= di <= i）。这不就是前面的n位变进制数的每一位么？于是，我们用n位变进制数M来表示该排列：

   M = d1*1! + d2*2! + ... + dn*n!
因此，每个排列都可以按这种方式表示成一个n位变进制数，并且该n位变进制数能与n+1个元素的全排列建立起一一对应的关系（证明参看[1]）。上述这种将全排列映射到自然数空间的算法称为康托展开。

2. Referrence

[1] tyc611,
一种变进制数及其应用（全排列之Hash实现）.
[2] 维基百科, 逆序对.
[3] 维基百科, 康托展开.

3. 问题

3.1 POJ 1077

n数码问题：输入一个排列，求能得到目标排列的最少步数变换。

先将排列映射到自然数空间，然后用BFS遍历求解最少步数的策略（参看前一篇）。

用C++结果TLE，换成G++结果报错'memset' was not declared in this scope，最后加上#include <cstring>  #include <cstdio>通过。

源代码：

1077

Accepted

6056K

219MS

G++

2001B

2013-12-06 10:28:46

#include<iostream>
#include <queue>
#include <cstring>
#include <cstdio>
using namespace std;

#define MAX 362880

const int factorial[9] = {1,1,2,6,24,120,720,5040,40320};  //阶乘
int end,visit[MAX],solvable;

struct _parent    //记录父节点及移动方向
{
int key;
char op;
}parent[MAX];

struct state     //xtile记录9（即x）所在位置
{
int per[9],key,xtile;
};

state start;
queue<state>que;

int hash(int per[])                   //康托展开，即全排列的hash
{
int i,j,count,result=0;
for(i=1;i<9;i++)
{
count=0;
for(j=0;j<i;j++)
if(per[j]>per[i])
count++;
result+=count*factorial[i];
}
return result;
}

void swap(int *a,int *b)
{
int temp;
temp=*a;
*a=*b;
*b=temp;
}

void exchange(state *ptr,char op,int varia)        //交换元素9
{
int i;
state next;
for(i=0;i<9;i++)
next.per[i]=ptr->per[i];
swap(next.per[ptr->xtile],next.per[ptr->xtile+varia]);
next.key=hash(next.per);
next.xtile=ptr->xtile+varia;

if(!visit[next.key])
{
visit[next.key]=1;
parent[next.key].key=ptr->key;
parent[next.key].op=op;
que.push(next);
}
}

void bfs()
{
int que_size;
state head;
memset(visit,0,sizeof(visit));
solvable=0;

visit[start.key]=1;
que.push(start);
while(!que.empty()&&!solvable)
{
que_size=que.size();
while(que_size--)
{
head=que.front();
que.pop();
if(head.key==end)
{
solvable=1;
return;
}

if(head.xtile/3!=0) exchange(&head,'u',-3);
if(head.xtile/3!=2) exchange(&head,'d',+3);
if(head.xtile%3!=2) exchange(&head,'r',+1);
if(head.xtile%3!=0) exchange(&head,'l',-1);
}
}
}

void init()
{
int i;
char ch;
for(i=0;i<9;i++)
{
cin>>ch;
if(ch=='x')
{
start.per[i]=9;
start.xtile=i;
}
else start.per[i]=ch-'0';
}
start.key=hash(start.per);
end=0;
}

void output(int k)
{
if(k!=start.key)
{
output(parent[k].key);
printf("%c",parent[k].op);
}
}

int main()
{
init();
bfs();
if(solvable)
{
output(end);
printf("\n");
}
else printf("unsolvable\n");
return 0;
}