nyoj 139 & 143 康托展开与逆展开

139题用的是康托展开：

X=a
(n-1)!+a[n-1](n-2)!+…+a[i]*(i-1)!+…+a[1]*0! 其中a[i]为当前未出现的元素中是排在第几个（从0开始）。 //假设序列是a
,a[n-1],a[n-1]……a[1]

如 {1,2,3} 按从小到大排列一共6个。123 132 213 231 312 321 。

如求321是{1,2,3}中第几个大的数可以这样考虑 ：

第一位是3，当第一位的数小于3时，那排列数小于321 如 123、 213 ，小于3的数有1、2 。所以有2*2!个。再看小于第二位2的：小于2的数只有一个就是1 ，所以有1*1!=1 所以小于321的{1,2,3}排列数有2*2!+1*1!=5个。所以321是第6个大的数。 2*2!+1*1!+1*0!

再举个例子：

1324是{1,2,3,4}排列数中第几个大的数：第一位是1小于1的数没有，是0个 0*3! 第二位是3小于3的数有1和2，但1已经在第一位了，所以只有一个数2 1*2! 。第三位是2小于2的数是1，但1在第一位，所以有0个数 0*1! ，所以比1324小的排列有0*3!+1*2!+0*1!=2个，1324是第三个大数。

代码：

#include <iostream>
using namespace std;
int main() {
int i,j,a[13];
a[0]=1;
for(i=1; i<=12; i++) {  //a[i]=i!;
a[i]=a[i-1]*i;
}
int n,count,length;
long long sum;
string x;
cin>>n;
while(n--) {
sum=0;
cin>>x;
length=x.length();
for(i=0; i<length; i++) {
count=0;        //第几大，从0开始
for(j=i+1; j<length; j++) {
if(x[i]>x[j])
count++;
}
sum+=count*a[length-i-1];  //+=count*(length-i-1)!
}
cout<<sum+1<<endl;
}
return 0;
}

143题呢，是逆推的，由第几个，求得该序列

如果已知 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，即：

20/(3!)=3余2 //a4=3

2/(2!) =1余0 //a3=1

0/(1!) =0余0 //a2=0

0/(0!) =0余0 //a1=0

知道了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”]。

再例如：

{1,2,3,4,5}的全排列，并且已经从小到大排序完毕

找第96个数

首先用96-1得到95

用95去除4! 得到3余23

有3个数比它小的数是4

所以第一位是4

用23去除3! 得到3余5

有3个数比它小的数是4但4已经在之前出现过了所以第二位是5（4在之前出现过，所以实际比5小的数是3个）

用5去除2!得到2余1

有2个数比它小的数是3，第三位是3

用1去除1!得到1余0

有1个数比它小的数是2，第二位是2

最后一个数只能是1

所以这个数是45321

代码：

#include <stdio.h>
#include <iostream>
using namespace std;
int main() {
int n,i,j,t,count,len=12; //count第几个   len字符串长度，本题默认为12
int fac[13],num[13];    //factorial阶乘  fac[i]=i!;
fac[0]=1;
for(i=1; i<=12; i++)
fac[i]=fac[i-1]*i;
cin>>n;
while(n--) {
for(i=0; i<=12; i++)
num[i]=i;
cin>>count;
count--;
for(i=0; i<len; i++) {
t=count/fac[len-i-1];   //t即康托展开的a[i]  从a
到a[1]
printf("%c",num[t]+'a');
for(j=t; j<len-1; j++)  //用过之后就覆盖掉，保证序列中没有重复元素
num[j]=num[j+1];
count=count%fac[len-i-1];
}
cout<<endl;
}
return 0;
}