康托展开入门

问题描述：
1：给出n,代表1~n这n个数。现在给一个这n个数的全排列，问它是第几大的排列。（康托展开）
2：给出n,m。问1~n的全排列中，第m大的是哪一个？（逆康托展开）
康托展开

康托展开的公式是 X=an * (n-1)!+an-1 * (n-2)!+…+ai * (i-1)!+…+a2 * 1!+a1 * 0!
　　其中，ai表示：第i个数在第i ~ 第n个数中，大小排在第几个（从0开始）。
　　这个公式可能看着让人头大，最好举个例子来说明一下。
　　例如，有一个数组 s = [“A”, “B”, “C”, “D”]，它的一个排列 s1 = [“D”, “B”, “A”, “C”]，现在要把 s1 映射成 X。n 指的是数组的长度，也就是4，所以X(s1) = a4 * 3! + a3 * 2! + a2 * 1! + a1 * 0!
　　
关键问题是 a4、a3、a2 和 a1 等于啥？
a4 = “D” 这个元素在子数组 [“D”, “B”, “A”, “C”] 中是第几大的元素。
"A"是第0大的元素，"B"是第1大的元素，“C” 是第2大的元素，"D"是第3大的元素，所以 a4 = 3。

a3 = “B” 这个元素在子数组 [“B”, “A”, “C”] 中是第几大的元素。
"A"是第0大的元素，"B"是第1大的元素，“C” 是第2大的元素，所以 a3 = 1。

a2 = “A” 这个元素在子数组 [“A”, “C”] 中是第几大的元素。
"A"是第0大的元素，"C"是第1大的元素，所以 a2 = 0。

a1 = “C” 这个元素在子数组 [“C”] 中是第几大的元素。
“C” 是第0大的元素，所以 a1 = 0。（因为子数组只有1个元素，所以a1总是为0）

所以，X(s1) = 3 * 3! + 1 * 2! + 0 * 1! + 0 * 0! = 20

A B C | 0
A C B | 1
B A C | 2
B C A | 3
C A B | 4
C B A | 5

通过康托逆展开生成全排列
如果已知 s = [“A”, “B”, “C”, “D”]，X(s1) = 20，能否推出 s1 = [“D”, “B”, “A”, “C”] 呢？
因为已知 X(s1) = a4 * 3! + a3 * 2! + a2 * 1! + a1 * 0! = 20，所以问题变成由 20 能否唯一地映射出一组 a4、a3、a2、a1？如果不考虑 ai 的取值范围，有
3 * 3! + 1 * 2! + 0 * 1! + 0 * 0! = 20
2 * 3! + 4 * 2! + 0 * 1! + 0 * 0! = 20
1 * 3! + 7 * 2! + 0 * 1! + 0 * 0! = 20
0 * 3! + 10 * 2! + 0 * 1! + 0 * 0! = 20
0 * 3! + 0 * 2! + 20 * 1! + 0 * 0! = 20
等等。但是满足 0 <= ai <= n-1 的只有第一组。可以使用辗转相除的方法得到 ai，如下图所示：

知道了a4、a3、a2、a1的值，就可以知道s1[0] 是子数组[“A”, “B”, “C”, “D”]中第3大的元素 “D”，s1[1] 是子数组 [“A”, “B”, “C”] 中第1大的元素"B"，s1[2] 是子数组 [“A”, “C”] 中第0大的元素"A"，s[3] 是子数组 [“C”] 中第0大的元素"C"，所以s1 = [“D”, “B”, “A”, “C”]。

这样我们就能写出一个函数 Permutation3()，它可以返回 s 的第 m 个排列。

*康托展开代码：*

#include <iostream>

using namespace std;

const int maxn=20;
int f[maxn];
int a[maxn+5];

void init()
{
    f[0]=f[1]=1;
    for(int i=2;i<=maxn;i++)
    {
        f[i]=f[i-1]*i;
    }
}
int main()
{
    int n;
    init();
    while(cin>>n)
    {
        int num=0;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
        }
        for(int j=1;j<n;j++)
        {
            int m=0;
            for(int k=j+1;k<=n;k++)
            {
                if(a[j]>a[k])
                    m++;
            }
            num+=(m*f[n-j]);
        }
        cout<<num+1<<endl;
    }
    return 0;
}

*逆康托展开代码：*

#include <iostream>

using namespace std;

const int maxn=20;
long fac[maxn+5];
int x[maxn+5];
int ans[maxn];
void init()
{
    fac[0]=1;
    fac[1]=1;
    for(int i=2;i<=maxn;i++)
    {
        fac[i]=i*fac[i-1];
    }
}
int main()
{
    init();
    int n,m;
    while(cin>>n>>m)
    {
       for(int s=1;s<=n;s++)
        x[s]=s;
       m--;
       int a,b,c,d,id=n,i=n,j=n-1;
       a=m;
       b=fac[j--];
       while(i--)
       {
           c=a/b;
           int k=0;
           for(int t=1;t<=n;t++)
           {
               if(x[t]>0)
                k++;
               if(k>c)
               {
                   ans[id--]=x[t];
                   x[t]=-1;
                   break;
               }
           }
           d=a%b;
           a=d;
           b=fac[j--];
       }
        for(int i=n;i>=1;i--)
        {
            cout<<ans[i];
        }
       cout<<endl;
    }
    return 0;
}