康托展开与康托逆展开

康托展开

康托展开，用人话说出来..就是把一个数组的多种排序情况对应用数字表示出来

公式：X = a[i] * (n-1)! + a[i-1] * (n-2)! + … + a[1] * 0!
其中a[i]表示后面比该元素小的元素的个数

举个例子，有5个数1 2 3 4 5
共有5个元素，所以一共有5！种排序方法
如果用康托展开序列35142
第一个元素是3，在后面的序列中，有2个比3小的，所以ans += 2 * 4！
第二个元素是5，在后面的序列中，有3个比5小的，所以ans += 3 * 3！
第三个元素是1，在后面的序列中，有0个比1小的，所以ans += 0 * 2！
第四个元素是4，在后面的序列中，有1个比4小的，所以ans += 1 * 1！
第五个元素是2，在后面的序列中，有0个比2小的，所以ans += 0 * 0！
所以序列35142用康托展开后，为ans = 2 * 4! + 3 * 3! + 0 * 2! + 1 * 1! + 0 * 0! = 67
康托展开的代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
int factor[11];
int encode(int permutation[], int, int a[]);
int main()
{
    int n, i, permutation[20], a[20];
    factor[0] = 1;
    for(i=1; i<=10; i++)
        factor[i] = factor[i-1] * i;
    scanf("%d", &n);
    for(i=0; i<=n-1; i++)
        scanf("%d", &permutation[i]);
    printf("康托展开值:%d\n", encode(permutation, n, a));
    return 0;
}
int encode(int permutation[], int n, int a[])
{
    int i, j, cnt;
    for(i=0; i<=n-1; i++)
    {
        cnt = 0;
        for(j=i+1; j<=n-1; j++)
            if(permutation[i] > permutation[j])
                cnt ++;
        a[i] = cnt;
    }
    int sum = 0;
    for(i=0; i<=n-1; i++)
        sum += a[i] * factor[n-i-1];
    return sum;
}

康托逆展开

理解了康托展开，逆展开的思路就比较容易理解了。
已知5个元素 1， 2， 3， 4， 5
展开值ans = 67
怎么求它的序列呢？
1. 67 / 4! = 2 余 19
2. 19 / 3! = 3 余 1
3. 1 / 2! = 0 余 1
4. 1 / 1! = 1 余0
5. 0 / 0! = 0 余0

通过辗转相除，我们可以求得a[5] = 2, a[4] = 3, a[3] = 0, a[2] = 1, a[1] = 0
那么，序列的第一个值便可求得，在五个元素内，有2个元素比它小，所以是3
第二个元素：除去3后，还有元素1，2，4，5，后面共有3个元素比它小，所以是5
第三个元素：除去3和5后，还有元素1，2，4，后面共有0个元素比它小，所以是1
第四个元素：除去1，3，5，还有元素2，4，后面有1个元素比它小，所以是4
第五个元素：除去1，3，4，5，还有元素2，后面有0个元素比它小，所以是2

这样，我们就将康托展开值逆展开了，序列为3，5，1，4，2