康拓展开

定义：

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

把一个整数X展开成如下形式：
X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[2]*1!+a[1]*0!

其中，a为整数，并且0<=a[i]<i(1<=i<=n)。

 

康托展开的最基本应用应该就是，求一个排列（按字典数）的序号（就是第几个）。
而其逆运算就是求序号对应的排列。

 

康托展开和逆康托展开

康托展开举例

再举个例子说明。
　　在

  

5个数的排列组合中，计算 34152的康托展开值。

首位是3，则小于3的数有两个，为1和2，

  

，则首位小于3的所有排列组合为

 

第二位是4，由于第一位小于4，1、2、3中一定会有1个充当第一位，所以排在4之下的只剩2个，所以其实计算的是在第二位之后小于4的个数。因此

  

。

第三位是1，则在其之后小于1的数有0个，所以

  

。

第四位是5，则在其之后小于5的数有1个，为2，所以

  

。

最后一位就不用计算啦，因为在它之后已经没有数了，所以

  

固定为0

根据公式：

 

　　所以比34152小的组合有61个，即34152是排第62。

 

 

逆康托展开举例

一开始已经提过了，康托展开是一个全排列到一个自然数的双射，因此是可逆的。即对于上述例子，在

  

给出61可以算出起排列组合为34152。由上述的计算过程可以容易的逆推回来，具体过程如下：

用 61 / 4! = 2余13，说明

  

,说明比首位小的数有2个，所以首位为3。

用 13 / 3! = 2余1，说明

  

，说明在第二位之后小于第二位的数有2个，所以第二位为4。

用 1 / 2! = 0余1，说明

  

，说明在第三位之后没有小于第三位的数，所以第三位为1。

用 1 / 1! = 1余0，说明

  

，说明在第二位之后小于第四位的数有1个，所以第四位为5。

最后一位自然就是剩下的数2。

通过以上分析，所求排列组合为 34152。

 

例题

P2272【康托展开】数字排列

问题描述

{1,2,3} 三个数的全排列可看做6个数字，按从小到大排序得到序列a：123,132,213,231,312,321
下面有两种提问：
1.数字231在序列a中排名第几？回答4
2.数列a中排名第5的数字是多少？回答312

给出n个数字(1,2,3,...,n)，回答关于序列a的1和2两种提问。

输入格式

第一行，两个整数n和m，n表示数字1到n(n<=9)构成的全排列，m(m<=100,000)表示询问数
接下来m行，表示询问，每行两个整数x和y，x=1表示第一种询问，回答y的排名；x=2表示第2种询问，答出排名为y的数字

输出格式

m行，每行一个整数，表示对应的答案。

样例输入

3 2
1 231
2 5

样例输出

4
312

提示

结果巨大，建议用long long 类型

 

时间限制 : 20000 MS   空间限制 : 65536 KB

代码

#include <stdio.h>
#include <bits/stdc++.h>
using namespace std;
char ch;
bool flag[15];
long long n, m, x, num;
long long a[15], b[15];
int q[10]= {1,1,2,6,24,120,720,5040,40320,362880};
inline int read()  
{
    int s=0;
    char c=getchar();
    while (c<'0' || c>'9') c=getchar();
    while (c>='0' && c<='9') s=s*10+c-'0',c=getchar();
    return s;
}
int kangtuo()
{
    long long i, j, num = 0;
    num = (a[1] - 1) * q[n - 1];
    for(i = 2; i <= n; i ++)
    {
        long long temp = 0;
        for(j = 1; j < i; j ++)
            if(a[j] < a[i])temp ++;
        num += (a[i] - temp -1) * q[n - i];
    }
    return num + 1;
}
void nikangtuo(int num)
{
    long long i, j, t;
    num --;
    for(i = 1; i <= n; i ++)
    {
        t = num / q[n - i];
        for(j = 1; j <= n; j ++)
            if(!flag[j])
            {
                if(!t)break;
                t --;
            }
        flag[j] = true;
        num %= q[n - i];
        b[i] = j;
    }
}
int main()
{
    n=read(),m=read();
    while(m --)
    {
        x=read();
        if(x == 1)
        {
            memset(flag, 0, sizeof(flag));
            for(int  i = 1; i <= n; i ++)
            {
                cin>>ch;
                a[i] = ch - '0';
            }
            cout<<kangtuo()<<endl;
        }
        else
        {
            memset(b, 0, sizeof(b));
            memset(flag, 0, sizeof(flag));
            num=read();
            nikangtuo(num);
            for(int i = 1; i <= n; i ++)cout<<b[i];
            cout<<endl;
        }
    }
}