康托展开与康托逆展开

定义

康托展开为全排列与自然数之间的映射关系，即康托展开可以是一个排列转化为一个自然数来代替，且一个自然数唯一指定一个排列。对应的康托的逆展开即为把一个自然数还原为一个排列。

X = a_n(n - 1)! + a_{n - 1}(n - 2)! +......+a_1(0)!

$a_i( 1\leq i \leq n)$代表了第i个数中比这个数小的有几个。
此数代表这个排列在总的全排列的位置（即第X大）。

例子

康托展开

比如求3412的是全排列的第几。
sum = 0
1. 第一位为3，比3小的有1,2,总共2个，故sum += 2 * (n - 1)! = 2 * 3! = 12
2. 第二位为4，比4小的有1,2,3，但3已经出现，故也是2个，故sum += 2 * (n - 2)! += 2 * 2! = 16
3. 第三位为1，比1小0个，故sum += 0 * (n - 3)! += 2 * 1! = 16
4. 第四位为2，比2小的有1个，但是1已经出现，故也是0个，sum += 0 = 16

综上，比3412小的排列的有16个，故3412为第17大。

    static int[] fac = new int[13];

    static void init(){
        fac[0] = 1;
        for(int i = 1; i < 13; i++){
            fac[i] = fac[i - 1] * i;
        }
    }

    static int kangTuo(int[] perm, int num){
        init();
        int sum = 0;
        for(int i = 0; i < num; i++){
            int count = 0;
            for(int j = i + 1; j < num; j++){
                if(perm[j] < perm[i]){
                    count++;
                }
            }
            sum += count * (fac[num - i - 1]);
        }
        return sum + 1;
    }

康托逆展开

既然康托展开是一个双射，那么一定可以通过康托展开值求出原排列，即可以求出n的全排列中第x大排列。
还是上面的例子，我们求17对应的康托逆展开。
1. 首先根据排列的位置算出有多少位。fac[num] >= fac[n],找到第一个大于等于某个阶乘即可，那么说明排列数位于此区间。得出n, 因为4！> 17, 17 > 3!, 故说明n = 4
2. 17 - 1 = 16，说明17前面有16个排列
3. 16 / fac[n - 1] = 16 / fac[3] = 2 余 4，说明比第一位小的数有2个。那么就是3
4. 4 / fac[n - 2] = 4 / fac[2] = 2 余 0，说明比第二位小的数有2个，是3，但3已经出现，故是4
5. 0 / fac[n - 3] = 0 / fac[1] = 0, 说明比第三位小的数有0个，故是1
6. 0 / 0! = 0, 说明比第四位小的数为0，故为1，但1已出现，故为2

综上，排列第17的排列为3412.

    static int[] reverseKangTuo(int num){
        init();
        int n = 0;
        for(int i = 0; i < 13; i++){
            if(fac[i] >= num){
                n = i;
                break;
            }
        }
        int[] perm = new int[n];
        boolean[] vis = new boolean[n + 1];
        int index;
        num--;
        for(int i = 0; i < n; i++){
            int count = num / fac[n - i - 1];
            for(index = 1; index <= n; index++){
                if(!vis[index]){
                    if(count == 0){
                        break;
                    }
                    count--;
                }
            }
            vis[index] = true;
            perm[i] = index;
            num %= fac[n - i - 1];
        }
        return perm;
    }

应用

主要用于排列值作为hash，可以转化为数字节省空间。其他应用待我遇见再补充。