康托(Cantor)展开与逆展开理解与运用

对于第一个元素2，我们可以知道别的第一个元素<2 的排列字典序一定是小于排列P的；所以1~5中，1 < 2，既当前位置有1这一种可能使该排列的字典序小于P，后面还有4个元素，这4种元素的排列总数为 $4!$ ，因为前面有1种可能，所以这里可以得到 $1*4!$ 个排列字典序小于P
继续向下一位看。在1~5中排除掉刚刚已经在第一个位置的2（前面出现过了后面不可能再出现），就是在（1, 3, 4, 5）中，有（1, 3, 4) < 5，这里有3种可能，后面3个元素共有 $3!$ 个排列，所以这里又可以得到 $3*3!$ 个排列字典序小于P
同理，下一位有 (1, 3) < 4（上面使用过2，故不算）, 后面剩余2位，可以得到 $2 * 2!$ 个排列
下一位：有1 < 3 ，后面剩1位，得到 $1*1!$
最后一位：（无元素） < 1 ，后面剩0位，得到 $0*0!$

总结一下：刚刚得到字典序小于P(2, 5, 4, 3, 1)的排列个数

$X=1*4!+3*3!+2*2!+1*1!+0*0!=47$

但这里需要注意：现在我们求的是按字典序排序下在排列P之前有几个排列，我们原先要计算的是排名，所以要加上1，得 $X=48$ 。

公式

上面举例过一遍了，下面的公式应该很好理解吧，就不细说了

$X=a_{1}(n-1)!+a_{2}(n-2)!+...+a_{i}(n-i)!+...+a_{n-1}\cdot1!+a_{n}\cdot0! + 1$

其中：

${a_i}$ 表示比第 $i$ 位上的元素字典序小且没使用过的元素个数

$n$ 既排列元素的个数

$X$ 是排列的排名

完整定义

………………引自Zhihu user---我不玩了给我退学

（这里说排名从0开始，建议计算后手动加1.比较符合“排名”，更形象，加不加也无所谓啦）（看不看无所谓，知道基本意思就行了）

C++代码

代码实现

//计算阶乘
int factorial(int n) {
    if (n == 0 || n == 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

//康托展开函数
int cantorExpansion(const vector<int>& p){
    int n = p.size();
    int x = 0;
    //计算康托展开的每一位
    for(int i = 0; i < n - 1;i++){
    	//smc:smaller_count
        int smc = 0;
        for(int j = i + 1; j < n;j++){
            if (p[j] < p[i]){
                smc++;
            }
        }
        x += smc * factorial(n - i - 1);
    }

    return x;
}

上面这样写比较直观；当然可以省去factorial函数，像下面这样（也就只改了个x的计算）

int cantorExpansion(const vector<int>& p){
	int n = p.size();
    int x = 0;
    for(int i = 0; i < n - 1;i++){
        int smc = 0;
        for(int j = i + 1; j < n;j++){
            if(p[j] < p[i]){
                smc++;
            }
        }
        x = (x + smc) * (n - i - 1);
    }
    return x;
}

（可能有些看官不理解第二段代码计算x的部分，这里解释一下：

x+smc 会累加上 smc 并乘上下一位对应的位数（也就是这一位阶乘的最高位），下一次一并计算，上次只乘了阶乘的最后一位的 smc 会再乘阶乘的下一位，直到都乘过了。光说可能有点抽象，下面模拟以下全排列1~5在此函数下X的计算过程（ ${a_i}$ 表示比第 $i$ 位上的元素字典序小且没使用过的元素个数）：

$X=((((a_1*4)+a_2)*3+a_3)*2+a_4)*1$

展开可以得到

$X=1*2*3*4\cdot a_1+1*2*3\cdot a_2+1*2\cdot a_3+1 \cdot a_4$

自己推一下就能理解啦qwq）

代码分析

两个不同的cantor函数写法都用了两层循环所以时间复杂度都是 $\theta (n^2)$

另外factorial函数分析得其时间复杂度是 $\theta (n)$

所以总体时间复杂度都是 $\theta (n^2)$

代码优化

（这是8月5日未更新树状数组优化前的原话：这里其实可以用线段树将时间复杂度降到 $\theta (n \log n)$ ，至于为什么不放代码，别问，问就是不会：）。这里先插个锚点🚩，等以后会了再来：）。）本来说是要用线段树的，但发现用线段树有点“杀鸡用牛刀”、“大炮打蚊子”的意思，而且树状数组常数比线段树小，在数据不是很大的情况下甚至比线段树还快，树状数组还比线段树简单、整洁（其实还是我没学、不会~~，不然多少要装一下~~，这里锚点再留着🚩，等有机会了继续补：）），下面是用树状数组优化的完整代码，各位看官可以参考参考。

#include <bits/stdc++.h>

using namespace std;

vector<int> bit;

int lowbit(int k){
	return k & -k;
}

void add(int x, int z){
	int size = bit.size();
	for(int i = z;i <= size;i += lowbit(i)) bit[i] += x;
}

int summing(int l, int r){
	int sum = 0;
	for(int i = l - 1;i != 0;i -= lowbit(i)) sum -= bit[i];
	for(int i = r;i != 0;i -= lowbit(i)) sum += bit[i];
	return sum;
}

//在这上面的3个函数是BIT的基本三件套，没学过树状数组的建议学了再看

int cantorExpansion(const vector<int>& p){
	int n = p.size();
    int x = 0;
    for(int i = 0; i < n - 1;i++){
        int used = summing(1, p[i]);//这里used可以得到在p[i]之前有多少个元素使用过
        x = (x + p[i] - used - 1) * (n - i - 1);
        add(1, p[i]);
        //这里的p[i] - used - 1实际上是上面未优化代码的smc,p[i] - 1得到的是该位a[i]最大的可能
        //所以p[i] - used - 1其实写成p[i] - 1 - used的话
        //比较好理解，我懒得改了（因为我原代码里有调试的代码片段，改就要一起改）
        //其他的都一样跟上面的大差不差，实际上就是把计算原来smc的for优化掉了。
    }
    return x;
}

int main() {
    vector<int> p = {2, 5, 4, 3, 1};//这里写上原排列以计算，你们想的话可以自己写个输入
    bit.assign(p.size() + 1, 0);
    int result = cantorExpansion(p);
    cout << "NO. Cantorexpansion of \n{2, 5, 4, 3, 1} is: \n" << result + 1 << endl;
    
    return 0;
}

我觉得这里还是附上一点说明才好。代码里的注释已经讲的很~~很很很很很很~~清楚了，这里再解释一下优化思路。原来的时间复杂度是 $\theta (n^2)$ ，cantorExpansion函数最外层的循环是一定要遍历的（应该吧），没什么优化思路。那么我们试图优化里面的for循环。尝试树状数组解决（因为树状数组时间复杂度较小，这题刚好可以转化为求区间和（前缀和），所以想到用树状数组（当然，我是知道后还原的思考过程，不是我自己推的，我也是看的别的文章知道的[手动滑稽]）），优化掉里层循环，我们用树状数组表示各位的使用状态，然后使用树状数组的 $\theta (\log_N)$ 级的超快查找、修改单点，就可以把原来计算smc的 $\theta (N)$ 降下来。加上外层循环，总体时间复杂度就是 $\theta (N\log_N)$ ，这样就完成了我们的任务！！！

另外，在下面给的练习中，洛谷P5367这题有20个测试点，普通的康托展开只能拿前10个测试点的分。既一半、50分。所以，题解区就也有很多优化值得一看，也有线段树优化的。但树状数组的大多优化思路也都差不多，就是把树状数组当作一个桶，用0和1来表示各位的状态，也是算前缀和，直接求出smc，与此处的优化稍有不同但不大，计算x的过程也不是完全一样，感兴趣的可以去看看。

关于其他的：我在更新这篇优化之前也有再写了一篇关于树状数组的文章，归于本人“日常分享”的专栏，质量相比别人的可能不是很优秀，各位看官感兴趣可以参考参考，下面是链接：

树状数组(BIT)简单分析、应用-CSDN博客

（本人坚持原创、探寻极限、追求卓越。你的一个赞与关注，是对我莫大的支持！！！）

逆康托展开

前面有说，排名与排列是一一对应的，所以我们可以通过排名逆推原排列

原理

看到社区视乎没有多少篇讲为什么逆康托展开可以像他们所讲的那样那么算，所以这里我讲讲我对于这的理解。下面是简单推论、证明

问题整理、转换

这里先不急，我们先来分析一下怎么逆推。（因为之前在X计算的最后加上了1，所以这边要减去1才好算，后面的X默认都是减去1的）因为排名X与 $a_i$ 有关，所以我们尝试求每一位的 $a_i$ 。根据公式，我们需要将X 除以与 $a_i$ 匹配的剩余位阶乘（既 $(n-i)!$ ），为了直接得到我们想要的 $a_i$ ，我们假设完美情况（完美情况就是指 X除以(n - i)!的商一定是ai）

$X/((n-i)!)=a_i......R(a_i>0)$ ,

这里的余数为第i位的下一位往后的所有排列的总数既

$R = a_{i+1}(n-(i+1))!+a_{i+2}(n-(i+2))!+...+a_{n-1}\cdot 1!+a_{n}\cdot 0!$ ,

分析一下，要得到这个完美情况，就要使

$(n - i)! > R$ ,

( $a_i>0$ 是因为如果 $a_i=0$ ，那么后面的总排列数既 $R$ 一定小于等于 $(n-i)!-1$ ，所以不用考虑)

所以，我们现在要来证明完美情况总是成立以便后面的由排名逆推原排列。首先先来分析最坏情况，因为 $(n-i)!$ 无法改变，所以我们试图改变 $R$ 使 $R$ 尽可能的大，又因 $a_i>0$ ，所以 $min(a_i)=1$ ，为了方便证明，我们忽略 $a_i$ 前面部分的所有，使得 $a_i=a_1=1$ ，因为考虑最坏情况，又 $min(a_i)=1$ ，所以使得第 $i$ 位上的元素为2，下一位上的元素为最大的 $n$ ，那么这个排列就是

$2, n, n-1, ..., 3, 1$ ,

这里因为忽略了第 $i$ 位前面的所有，这里以 $n_0$ 为元素个数重新计算 $(n_0-i)!$ 既为 $(n_0-1)!$ ，由下一位既元素为 $n>2$ 的这一位可以算得有 $(n_0-2) !*(n_0-2)$ ，再下一位就是 $(n_0-3) !*(n_0-3)$ ，这样逐位推下去，到倒二位既 $(3!*3)$ 的下一位少了个 $(2!*2)$ ，直接到了 $(1!*1)$ ，观察可知，上面这一过程很有规律。所以，我们的问题又可以转换成另一个问题，另外，该规律序列少了一个 $(2!*2)$ ，相信你们也知道怎么转换、转换后是什么了，所以我们不妨大胆把这个 $(2!*2)$ 加上（不影响推论、证明、结果），所以：

将 $n_0-1$ 视做 $x$ ，加上 $(2!*2)$ ，则问题可以转换成：
对于一任意正整数 $x(x > 1)$ ，求证：

$x!>(x-1)(x-1)!+(x-2)(x-2)!+...+1*1!$ ,

总是成立。

其实这变成了一个数学问题，我们用数学归纳法可以很简单的证明出来。

证明

第一步：确定基础情况

$x!=2*1>(x-1)!=1!=1*1=1(x=2)$

第二步：归纳、做出假设

假设对于一个正整数 $k(k>1)$ ，有

$k!>(k-1)(k-1)!+(k-2)(k-2)!+...+1*1!$

第三步：确定并证明联系

我们可以看到，不等式右边单项式的元素是递减，每次减1的（直接看，不分解阶乘），所以，我们根据这个联系试证明

$(k+1)!>k\cdot k!+(k-1)(k-1)!+...+1*1!$

只要证明出这个不等式，再加上基础情况，对于原证明所有的满足条件的 $k$ 都会成立

我们知道一个阶乘数等于该数乘上一个数的阶乘，在这里既

$(k+1)!=(k+1)*k!$

由乘法分配律得

$(k+1)k!=k\cdot k!+k!$

最后我们得到

$(k+1)!=k\cdot k!+k!$

带入到

$(k+1)!>k\cdot k!+(k-1)(k-1)!+...+1*1!$

得

$k\cdot k! + k!>k\cdot k!+(k-1)(k-1)!+...+1*1!$

因为我们知道（上面假设的）

$k!>(k-1)(k-1)!+(k-2)(k-2)!+...+1*1!$

在此不等式两边同时加上 $k\cdot k!$ 得到

$k\cdot k! + k!>k\cdot k!+(k-1)(k-1)!+...+1*1!$

既

$(k+1)!>k\cdot k!+(k-1)(k-1)!+...+1*1!$

到此，证明完成

所以，对于一任意正整数 $x(x > 1)$ ，

$x!>(x-1)(x-1)!+(x-2)(x-2)!+...+1*1!$ ,

总是成立。

（其实，一个证明与这个十分相似，既对于任意正整数 $x(x > 1)$ ，

$x!=(x-1)(x-1)!+(x-2)(x-2)!+...+1*1!+1$ ,

总是成立。可能可以在某些与阶乘相关的地方用到吧，感兴趣的看官可以用数学归纳法推一下，这里就不推了）

回归原问题

所以，上面一式成立，我们之前没解决的证明一个个都成立了，既原证明

$(n - i)! > R$

总是成立。我们就一直有“完美情况”

$X/((n-i)!)=a_i......R(a_i>0)$

对于每一位，我们都可以用此公式来计算当前位置的 $a_i$ ，我们只要用排列的排名 $X$ 来除以与 $a_i$ 匹配的剩余位阶乘（既 $(n-i)!$ ）就可以得到 $a_i$ ,然后取出余数 $R$ 当作下一位的 $X$ ，继续套用上面的公式，直到余数为0时就能求出各位的 $a_i$ 了，再通过各位的 $a_i$ 就能推出原排列了。

说明

证明仅供参考。

本证明仅是作者个人的理解，可能有些错误，或不严谨、表达不标准，如有错误，也请大家指出，如果是不严谨，只要问题不是很大，大家将就着看吧，或者看看下面的”其他证明“。感谢理解。

其他证明

这里再提供另一种证明思路、过程，可能比我的证明更严谨更准确，仅供参考。

………………引自Githab user---FrogIf

举例

哈哈h，刚刚原理部分可能讲的有点上头了，不过问题不大，~~看不懂也没关系（也不难，应该看得懂吧，相信你们水平比我强多了~~），只要记住怎么算的就行了，再说一遍公式：

$X/((n-i)!)=a_i......R(a_i>0)$

下面来个简单的举例：

之前我们算出(2, 5, 4, 3, 1)的 $X$ 为48，因为为了更形象“排名”加上了个1，这并不是原公式里的也会影响我们计算，所以在这里将其减去1得到47.

根据公式，我们需要将 $X$ 除以 $(n-i)!$ 得到 $a_i$ 余 $R$ ,将 $R$ 带入下一位的 $X$ 继续算直到余数为0即可得到各位的 $a_i$ （注意不是原排列）。

将 $X=47$ 除以 $(n-i)!=4!$ 得到 $a_1=1$ 余 $R=23$ ,将下一位 $X$ 设为 $R$ 得到 $X=23$
$23/3!=3......5$ , $a_2=3$
$5/2!=2......1$ , $a_3=2$
$1/1!=1......0$ , $a_4=1$
最后一位一定是0

现在，我们由各位的 $a_i$ 推出原排列

由 $a_1=1$ 得在第一个元素后面有1个比它小的，所以我们取出(1, 2, 3, 4, 5)中第二小的2，加入得到排列(2, )（也可以看作取下标为1的元素（下标从0开始））
由 $a_2=3$ 得在第二个元素后面有3个比它小的，所以我们取(1, 3, 4, 5)中第4小的5，加入得到排列(2, 5, )（也可以看作取下标为3的元素（下标从0开始），后面就不再说了）
取(1, 3, 4)中第3小的4，加入得到排列(2, 5, 4, )
取(1, 3)中第2小的3，加入得到排列(2, 5, 4, 3, )
取(1)中第0小的（可以理解为又是最大又是最小，所以是0；或者理解成或者取下标0）1，加入得到原排列(2, 5, 4, 3, 1)

公式上面提过了，这里就不再提了。

C++代码

代码实现

int factorial(int n){
    if (n == 0 || n == 1)
        return 1;
    return n * factorial(n - 1);
}

//逆康托展开
void inverseCantorExpansion(int n, int k, vector<int>& p){
    //n是排列的长度，k是康托展开得到的数值，p是还原后的排列
    vector<int> ele;
    for (int i = 1; i <= n;i++){
        ele.push_back(i);
    }//ele临时1~n最小字典序排列

    for (int i = 0; i < n;i++){
        int fact = factorial(n - 1 - i);
        int index = k / fact;
        p[i] = ele[index];//对应文章中举例的部分 把除的a_i看做下标
        ele.erase(ele.begin() + index);//去除取出的元素
        k %= fact;
    }
}

还有一种写法，大致框架一样，各部分用了些稍不同的代码，是来自Githab user---FrogIf的,需要的自行参见，文章后记有链接。