【数学】康托展开 && 康托逆展开

　　(7.15)康托展开，就是把全排列转化为唯一对应自然数的算法。它可以建立1 ～ n的全排列与[1, n!]之间的自然数的双向映射。

1、康托展开：

　　尽管我并不清楚康托展开的原理何在，这个算法的过程还是比较好记的。正确性之后有机会询问下学长。

　　如果从1开始给全排列的排名从大到小编号的话（从0开始也可，建立的是与[0, n!-1]的映射，本质相同），定义rk为排名，a是排列数组，排列有n位（最低位是第0位），那么有公式

　　rk - 1 = cnt[n-1] * (n-1)! + cnt[n-2] * (n-2)! + ... + cnt[0] * 0!　　

　　其中cnt数组的含义是未统计的数字中，小于a[i]的数字有多少个。

　　举例：计算排列3 4 2 1对于{1, 2, 3, 4}的排名

　　首先取出最高位（第三位），小于数字3的数有两个，所以cnt[3] = 2，rk += 2 * 3!，rk = 12。

　　然后取出4，小于4的数有三个，但是3已经被统计过了，所以cnt[2] = 2，rk += 2 * 2!，rk = 16.

　　取出2，小于2的只有1，cnt[1] = 1，rk += 1 * 1!，rk = 17。

　　最后由于除第0位本身外已经没有数了，cnt[0]恒等于0。所以3 4 2 1的排名为18。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
int f[10], n;
bool vis[10];
int KtSplay(int *a) {  //康托展开，返回的[1, n!]之间的数
    int rk = 0;
    cal();
    for (int i = 1; i <= n; ++i)
        vis[i] = 0;
    for (int i = n - 1; i >= 0; --i) {
        int u = a[i], cnt = 0;
        for (int i = 1; i < u; ++i)
            if (!vis[i]) ++cnt;
        rk += cnt * f[i];
        vis[u] = true;
    }
    return rk + 1;
}
int a[10];
int main() {
    cin >> n;
    for (int i = n - 1; i >= 0; --i)
        cin >> a[i];
    cout << KtSplay(a);
}

（先咕掉逆展开）

（先补一点）

　　康托展开的逆过程，就是依照排名来查询排列。

　　首先把排名-1（突然发现这样有点麻烦，可能从0开始编排名号更合理，大家看得懂就好）。然后我们考虑康托展开的过程，用带余除法的方式确定每一位数字的排名，进而得到这个数。

　　比如我们要计算{1, 2, 3, 4}排列中排第18的排列。

　　第三位（最高位）：17/3! = 2……5，说明比该位小的数有2个，该位是3。

　　第二位：5/2! = 2……1，说明这一位是当前没出现的第2个，该位是4。

　　第三位：1/1! = 1……0，说明这一位是2。

　　那么最后一位是1。

　　所以所求排列是3、4、2、1。

代码：

void KtResplay(int rk) {
    --rk;
    cal();
    for (int i = n - 1; i; --i) {
        int k = rk / f[i];
        int j = 0;
        while (k >= 0) {
            ++j;
            if (!vis[j])
                --k;
        }
        vis[j] = true;
        a[i] = j;
        rk = rk % f[i];
    }
    for (int i = 1; i <= n; ++i)
        if (!vis[i]) {
            a[0] = i;
            break;
        }
    return;
}

 （2019.7.16 坑填了）