算法基础：康托展开与逆康托展开

康托展开与逆康托展开

序言:
本文记录康托展开与逆康拓展开的原理以及其应用。

1.概述
举例而言，对于 1 ~ 4 的一个全排列 [1, 2, 3, 4] 和 [4, 3, 2, 1]，我们知道，从字典序而言，前者是该全排列集的第一个，后者是该集的最后一个。那么，所谓康托展开，即给定一个 $n$ 位数的全排列，我们可以根据康托展开公式确定其应当是字典序中的第“几”个全排列。
由于康托展开计算的是某个全排列方式在该全排列集合中的字典序(或者说是排名)，其映射关系唯一且单调，故该映射关系是可逆的。即，我们给定一个全排列的所有字符，以及某个字典序号，我们可以利用逆康托展开得到相应的那个全排列。

2.康托展开
给定一个全排列，计算其字典序。直观起见，我们举例[2, 3, 4, 1]来说明康托展开的运作步骤：
命所求字典序为 $rank=0$

1. 第 1 位是 2， 那么以 1 打头的所有全排列一定排在这个全排列之前，那么以 1 打头的全排列有 (3!) = 6种，$rank=rank+1\ast 3!=6$。
2. 第 2 位是 3，那么以 1 与 2 作为第二位的所有全排列一定在这个圈排列之前。不过我们已经让 2 打头了，因此不需要再考虑 2 占第二位的情况，只需要计算 1 占第二位的情况。$rank=rank+1\ast 2!=8$。
3. 第三位是 4，同时，我们计算以 1 占第三位的所有情况。$rank=rank+1\ast 1!=9$。
4. 最后一位，是不需要判定的，因为前 $n-1$ 位给定后，第 $n$ 位自定。当然，为了也适应前面推导，可以记 $rank=rank+0\ast 0!=9$。

由是，排在 [2, 3, 4, 1] 之前的全排列共有 9 个，那么 [2, 3, 4, 1] 应当是第 10 个全排列。总结康托展开公式为：
$$rank=a_n(n-1)!+a_{n-1}(n-2)!+\cdots +a_{1}0!$$
其中，$a_i$表示原排列中，排在下标 $i$ 后面的，比下标 $i$ 的字符还小的字符个数。当然，如果排名是从 1 开始的话，最终结果应当再 + 1。

• C++ 实现

//对前 10 个自然数(0 ~ 9)的阶乘存入表
//以免去对其额外的计算
const int fact[10] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
/**
 * @brief 康拓展开
 *
 * @param[in] permutation 输入的一个全排列
 * @param[out] num 输入的康拓映射，即是第几个全排列
 */
int contor(const vector& permutation) {
    int num = 0;
    int len = permutation.size();
    for (int i = 0; i < len; ++i) {
        int cnt = 0; // 在 i 之后，比 i 还小的有几个
        for (int j = i + 1; j < len; ++j)
            if (permutation[i] > permutation[j]) ++cnt;
        num += cnt * fact[len - i - 1];
    }
    return num + 1;
}

2.逆康托展开
同样以[2, 3, 4, 1]为例，以说明逆康拓展开的执行方法。这里输入和输出互反，同时，我们还需要输入全排列的字符个数(否则有无穷多个解)。
给定，字符个数 4，字典序序号 10，首先字典序 - 1 得到排在该字典序前的全排列个数，然后：

1. 9 / 3! 结果，商 1 余 3，说明首位要余出一个给 当前没用过的，最小的一个字符，因为它们占据了前 6 个排序。这里 “1” 没有用过，又是最小的字符，因此，我们应当使用 “2” 作为首位，并标记其已经使用。取余数进行下一步操作。
2. 3 / 2! 结果，商 1 余 1，说明第二位要余出一个给 当前没用过的，最小的字符。这里 “1” 没有用过，“2” 已经用了。因此，我们应当使用 “3” 作第二位。
3. 1 / 1! 结果，商 1 余 0，说明第三位要余出一个给 当前没用过的，最小的字符。这里 “1” 没有用过，“2” 已经用了，“3”也用了。因此，我们应当使用 “4” 作第三位。
4. 同康托展开，最后一位无需判断，所有字符中至今未使用的填入即可。

• C++ 实现

//对前 10 个自然数(0 ~ 9)的阶乘存入表
//以免去对其额外的计算
const int fact[10] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
/**
 * @brief 逆康拓展开
 *
 * @param[in] bits 给定全排列的使用数字个数
 * @param[in] num 给定全排列的次位
 * @param[out] permutation 输出对应的全排列
 */
vector revContor(int bits, int num) {
    num = num - 1; //有 num - 1 个排列比目标序列要小
    vector vis(bits + 1, false);
    vector permutation(bits, -1);

    int n, residue = num;
    for (int i = 0; i < bits; ++i) {
        n = residue / (fact[bits - i - 1]);
        residue = residue % (fact[bits - i - 1]);

        for (int j = 1; j <= bits; ++j) {
            if (!vis[j] && !(n--)) {
                vis[j] = true;
                permutation[i] = j;
                break;
            }
        }
    }
    return permutation;
}

4. 应用
康托展开与逆康托展开与全排列的联系十分密切，在解决全排列的字典序问题时能够发挥极大的作用。
此外，康托展开也是一个数组到一个数的映射，可以应用于hash中进行空间压缩。例如，在八数码问题中，我们可以把一种排列状态压缩成一个整数存放在数组中。