LOJ167 康托展开 题解

题面

康托展开：

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

X = A[0] * (n-1)! + A[1] * (n-2)! + … + A[n-1] * 0!

A[i] 指的是位于位置i后面的数小于A[i]值的个数,后面乘的就是后面还有多少个数的阶乘

这个算出来的数康拖展开值，是在所有排列次序 - 1的值，因此X+1即为在全排列中的次序

long long cantor()
{
    long long ans=0;
    inc(1,n,1){
        long long cnt=0;
        long long num=1,sum=1;
        for(int j=i+1;j<=n;j++){
            if(a[j]<a[i]) ++cnt;
            sum=sum*num%p;
            ++num;
        }
        ans=(ans+cnt*sum%p)%p;
    }
    return ans%p;
}

问：虽然知道了康托展开的方法，但怎样知道排名求排列呢？

答:那就使用逆康托展开！；

逆康托展开：

前面已经说到康拖展开是从序列到自然数的映射且是可逆的，那么逆康拖展开便是从自然数到序列的映射。

举例子：

在（1，2，3，4，5) 给出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。

static const int FAC[] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};   // 阶乘预处理
void decantor(int x, int n)
{
    vector<int> v;  // 存放当前可选数
    vector<int> a;  // 所求排列组合
    for(int i=1;i<=n;i++)
        v.push_back(i);
    for(int i=m;i>=1;i--)
    {
        int r = x % FAC[i-1];
        int t = x / FAC[i-1];
        x = r;
        sort(v.begin(),v.end());// 从小到大排序
        a.push_back(v[t]);      // 剩余数里第t+1个数为当前位
        v.erase(v.begin()+t);   // 移除选做当前位的数
    }
}

但是......

你会发现，这样的时间复杂度是n^2的，我们无法接受这么暴力的算法；即使比枚举快乐很多；

那么，我们总不能整个ex康托展开，所以开始考虑优化；

从阶乘上入手？还是不够快。那么剩余优化的仅仅剩一个地方：统计小于a[i]个数.

这时我们会想到我们可爱的朋友：树状数组。

nlogn的复杂度，开心愉悦的AC掉了它；

#include <bits/stdc++.h>
#define p 998244353
#define inc(a,b,c) for(register int i=a;i<=b;i+=c)
using namespace std;
int n; 
int a[1000010],c[1000010];
long long pre[1000010];
int lowbit(int x)
{
    return x&(-x);
}
int query(int x)
{
    int res=0;
    while(x>0){
        res+=c[x];
        x-=lowbit(x);
    }
    return res;
}
void add(int x)
{
    while(x<=n){
        c[x]+=1;
        x+=lowbit(x);
    }
}
long long cantor()
{
    long long ans=0;
    for(register int i=n;i>=1;i--){
        long long ask=query(a[i]);
        add(a[i]);
        long long tmp=pre[n-i];
        ans=(ans+tmp*ask%p)%p;
    }
    return ans%p;
}
int main()
{
    cin>>n;
    pre[0]=1;
    inc(1,n,1){
        pre[i]=pre[i-1]*i%p;
    }
    inc(1,n,1){
        scanf("%d",&a[i]);
    }
    cout<<cantor()+1;
    
}

附：公式的证明

某一全排列序列的编号即等于排在它前面的全排列的个数，而由编号定义可知，其前面的全排列组成数都小于该全排列组成的数。

还是用例子来说明吧，更易于理解，考察3214，我们要求出比它小的全排列的个数，可以这样计算：

1. 千位取1或2，后三位由剩下的3个元素全排列，共2*3!种；

2. 千位取3，百位取小于2的元素，只能为1，后两位由剩下的2个元素全排列，共1*2！种；

3. 千位取3，百位取2，十位取小于1的元素，不存在；

4. 最后一项一定为0；