（1）康托展开：设X为一个排列在所有排列中排第几个：
X=a[n]*(n-1)!+a[n-1]*(n-2)!+...+a[i]*(i-1)!+...+a[1]*0!
其中a[i]为当前未出现的元素中是排在第几个（从0开始），这就是传说中的康托展开
例如 蓝桥杯
题目描述：
X星系的某次考古活动发现了史前智能痕迹。
这是一些用来计数的符号，经过分析它的计数规律如下：
（为了表示方便，我们把这些奇怪的符号用a~q代替）
abcdefghijklmnopq 表示0
abcdefghijklmnoqp 表示1
abcdefghijklmnpoq 表示2
abcdefghijklmnpqo 表示3
abcdefghijklmnqop 表示4
abcdefghijklmnqpo 表示5
abcdefghijklmonpq 表示6
abcdefghijklmonqp 表示7
.....
在一处石头上刻的符号是：
bckfqlajhemgiodnp
请你计算出它表示的数字是多少？
#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
int main()
{
map<char,int>my;
for(int i=0;i<=26;i++){
my['a'+i]=i+1;
}
char str1[18]={"bckfqlajhemgiodnp"};
ll a[18],b[18];
for(int i=0;i<17;i++){
a[i]=my[str1[i]];
}
ll p[18]={1};
for(ll i=1;i<=18;i++){
p[i]=p[i-1]*i;
}
int vis[18]={0};
ll ans=0;
for(int i=0;i<17;i++){
vis[a[i]]=1;
int cnt=0;
for(int j=a[i];j>0;j--){
if(vis[j]==0){
cnt++;
}
}
ans=ans+(p[17-(i+1)]*cnt);
}
printf("%lld\n",ans);
return 0;
}
题目描述
定义一个数字为幸运数字当且仅当它的所有数位都是4或者7。
比如说，47、744、4都是幸运数字而5、17、467都不是。
现在想知道在1...n的第k小的排列（permutation，https://en.wikipedia.org/wiki/Permutation）中，有多少个幸运数字所在的位置的序号也是幸运数字。
输入描述:
第一行两个整数n，k。
1 <= n，k <= 1000,000,000
输出描述:
一个数字表示答案。
如果n没有k个排列，输出-1。
示例1
输入
7 4
输出
1
题解：k<=1000000000,但是13！>k,因此除了最后13位，前边的所有位都是固定的，可以直接数出多少个幸运数字，剩下的最后13位，因为考虑到第k小，我们就可以用到逆康托展开了，复杂度最大也就13*13了。
逆康托展开：顾名思义，就是反过来的康托展开，假如让你求第k小的排列情况，令k/(n-1)!,求出a[n],然后k%(n-1)!，一次类推求出n个位置上的值，这一过程我们可以通过正向展开理解，仔细观察式子，会发现a[n]*(n-1)!一定比后边所有项之和要大，所以你每次除上a[i]相应的系数，所得就是这一位上后边有几个比这个数小的数，因此就可以暴力找出这一项应该填数字几，到这里应该就讲的差不多了。。。
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define ll long long
#define inf 5e9
ll n,k,ans,vis[20],a[20];
ll num[20],q[1000005],pre[20]={1};
void dfs(ll x,ll y)
{
if(x>y) return;
if(x) ans++;
dfs(x*10+4,y);
dfs(x*10+7,y);
}
int jud(ll x)
{
while(x)
{
int tmp=x%10;
if(tmp!=4 && tmp!=7)
return 0;
x/=10;
}
return 1;
}
int main(void)
{
for(int i=1;i<=13;i++)
pre[i]=(ll)i*pre[i-1];
scanf("%lld%lld",&n,&k);
if(n<13 && k>pre[n])
{
printf("-1\n");
return 0;
}
k--;ll m=min(n,13ll);
for(int i=m;i>0;i--)
{
ll t=k/pre[i-1];k%=pre[i-1];
for(int j=1;j<=m;j++)
{
if(!vis[j])
{
if(!t)
{
vis[j]=1;
a[i]=n-m+j;
break;
}
t--;
}
}
}
dfs(0ll,n-m);
for(int i=1;i<=m;i++)
if(jud(n-i+1) && jud(a[i]))
ans++;
printf("%lld\n",ans);
return 0;
}
逆康托展开
在（1，2，3，4，5）给出61可以算出起排列组合为 34152。由上述的计算过程可以容易的逆推回来，具体过程如下：
- 用 61 / 4! = 2余13，说明a[5]=2,说明比首位小的数有2个，所以首位为3。
- 用 13 / 3! = 2余1，说明a[4]=2，说明在第二位之后小于第二位的数有2个，所以第二位为4。
- 用 1 / 2! = 0余1，说明a[3]=0，说明在第三位之后没有小于第三位的数，所以第三位为1。
- 用 1 / 1! = 1余0，说明a[2]=1，说明在第二位之后小于第四位的数有1个，所以第四位为5。
- 最后一位自然就是剩下的数2啦。
- 通过以上分析，所求排列组合为 34152。
#include<iostream>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
long int factory[]={1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
void decontor(int x, int n) {
vector<int> v;
vector<int> a;
for(int i = 1; i <= n; i++) v.push_back(i);
sort(v.begin(), v.end());
for(int i = n-1; i >= 0; i--) {
int r = x % factory[i];
int t = x / factory[i];
x = r;
a.push_back(v[t]);
v.erase(v.begin()+t);
}
for(int i = 0; i < a.size(); i++) cout << a[i];
}
int main()
{
int x, n;
cin >> x >> n;
decontor(x, n);
return 0;
}