康託展開與康託逆展開

康託展開

康託展開，用人話說出來..就是把一個數組的多種排序情況對應用數字表示出來

公式：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

原文出處：
---------------------
作者：life_bre
原文：https://blog.csdn.net/sdutstudent/article/details/53791521