[模板]康拓展开和他的逆运算

康托展开

　　康托展开的公式是 X = an*(n-1)!+an-1*(n-2)!+...+ai*(i-1)!+...+a2*1!+a1*0! 其中，ai为当前未出现的元素中是排在第几个（从0开始），n指的是数组的长度。

举个例子，有一个数组 s = ["A", "B", "C", "D"]，它的一个排列 s1 = ["D", "B", "A", "C"]，则

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"] 中是第几大的元素。"B"是第1大的元素，所以 a3 = 1。
a2 = "A" 这个元素在子数组 ["A", "C"] 中是第几大的元素。"A"是第0大的元素，所以 a2 = 0。
a1 = "C" 这个元素在子数组 ["C"] 中是第几大的元素。"C" 是第0大的元素，所以 a1 = 0。（因为子数组只有1个元素，所以a1总是为0）
所以，X(s1) = 3*3! + 1*2! + 0*1! + 0*0! = 20

通过康托逆展开生成全排列

　　如果已知 s = ["A", "B", "C", "D"]，X(s1) = 20，能否推出 s1 = ["D", "B", "A", "C"] 呢？
　　要根据X逆推出s1排列，我们只需要求出ai，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"]。

以上内容参考自此博客

附代码（ABCD长度n=4时，正推全排列的X值，逆推X值代表的全排列）：

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
// X = an*(n-1)!+an-1*(n-2)!+...+ai*(i-1)!+...+a2*1!+a1*0!
using namespace std;
const int maxn = 500;
int fac[maxn];
bool vis[26];//康托逆展开生成全排列时，记录字母状态
int n;
string s;
int cantor_fac(int x){
    if(fac[x]) return fac[x];
    return x*cantor_fac(x-1);
}
//通过排列求X
int cantor_encode(){
    vector <int> vec(n);
    int num=0;
    int re=0;
    for(int i=0; i<n; i++){
        num = 0;
        for(int j=i+1; j<n; j++)
            if(s[i] > s[j]) num++;
        vec[n-i-1] = num;
    }
    for(int i=0; i<n; i++)
        re += cantor_fac(i)*vec[i];
    return re;
}
//通过康托逆展开生成全排列
void cantor_decode(int val){
    div_t div_re;
    string str;
    int num;
    memset(vis, false, sizeof(vis));
    for(int i=n-1; i>=0; i--){
        div_re = div(val, cantor_fac(i));
        str.push_back(div_re.quot+'0');
        val = div_re.rem;
    }
    for(int i=0; i<n; i++){
        num=-1;
        for(int j=0; j<n; j++){
            if(!vis[j])
                num++;
            if(num == str[i]-'0'){
                vis[j] = true;
                s.push_back(j+'A');
                break;
            }
        }
    }
    cout << "逆推序列：" << s << "(" << str << ")" << endl << endl;
}
int main(){
    fac[0] = 1;
    n = 4;
    int re;
    for(int i=0; i<n; i++)
    for(int j=0; j<n; j++)
    for(int k=0; k<n; k++)
    for(int c=0; c<n; c++){
        if(i==j || i==k || i==c || j==k || j==c || k==c) continue;
        s.clear();
        s.push_back(i+'A'); s.push_back(j+'A');
        s.push_back(k+'A'); s.push_back(c+'A');
        cout << "原序列：" << s << endl;
        re = cantor_encode();
        cout << "X = " << re << endl;
        s.clear();
        cantor_decode(re);
    }
    return 0;
}

附上运行结果：

原序列：ABCD
X = 0
逆推序列：ABCD(0000)

原序列：ABDC
X = 1
逆推序列：ABDC(0010)

原序列：ACBD
X = 2
逆推序列：ACBD(0100)

原序列：ACDB
X = 3
逆推序列：ACDB(0110)

原序列：ADBC
X = 4
逆推序列：ADBC(0200)

原序列：ADCB
X = 5
逆推序列：ADCB(0210)

原序列：BACD
X = 6
逆推序列：BACD(1000)

原序列：BADC
X = 7
逆推序列：BADC(1010)

原序列：BCAD
X = 8
逆推序列：BCAD(1100)

原序列：BCDA
X = 9
逆推序列：BCDA(1110)

原序列：BDAC
X = 10
逆推序列：BDAC(1200)

原序列：BDCA
X = 11
逆推序列：BDCA(1210)

原序列：CABD
X = 12
逆推序列：CABD(2000)

原序列：CADB
X = 13
逆推序列：CADB(2010)

原序列：CBAD
X = 14
逆推序列：CBAD(2100)

原序列：CBDA
X = 15
逆推序列：CBDA(2110)

原序列：CDAB
X = 16
逆推序列：CDAB(2200)

原序列：CDBA
X = 17
逆推序列：CDBA(2210)

原序列：DABC
X = 18
逆推序列：DABC(3000)

原序列：DACB
X = 19
逆推序列：DACB(3010)

原序列：DBAC
X = 20
逆推序列：DBAC(3100)

原序列：DBCA
X = 21
逆推序列：DBCA(3110)

原序列：DCAB
X = 22
逆推序列：DCAB(3200)

原序列：DCBA
X = 23
逆推序列：DCBA(3210)


Process returned 0 (0x0)   execution time : 3.452 s
Press any key to continue.

小结：

康拓展开，可为A*算法服务；