-
题面描述
现有一个长度为n的集合S,集合S里的元素为 [1,2,3……n]。按照高中数学的知识,我们显然可以知道,集合里的元素的排列共有 n! 种。现在给你集合长度n以及一个正整数 Q,请你找出集合元素组成的第Q个的排列。 -
输入
输入数据由多组测试样例组成,每组测试样例第一行分别输入两个正整数n ( 1 <= n <= 9 ),Q( 1 <= Q <= n! ) -
输出
输出第Q个的排列,元素之间没有空格 -
样例输入
2 2
5 10
- 样例输出
21
13452
第一发超时代码是暴力dfs找第Q个排列, 毫无疑问的超时了,这时我想起 next_permutation() 函数,于是有了以下代码:
#include <bits/stdc++.h>
using namespace std;
int k[15];
int main()
{
int n, m;
while(~scanf("%d%d", &n, &m))
{
for(int i = 0; i < n; i++)
{
k[i] = i + 1;
}
int t = 1;
do
{
if(t == m)
{
for(int i = 0; i < n; i++)
printf("%d", k[i]);
printf("\n");
break;
}
t++;
}while(next_permutation(k, k + n));
}
return 0;
}
没想到出题人早就料到了这种情况,又超时了,无奈下上网查到了康拓展开/逆康拓展开。
简述
康托展开是一个全排列到一个自然数的双射,常用于构建hash表时的空间压缩。设有n个数(1,2,3,4,…,n),可以有组成不同(n!种)的排列组合,康托展开表示的就是是当前排列组合在n个不同元素的全排列中的名次。
原理
X=a[n] * (n-1)!+a[n-1] * (n-2)!+…+a[i] * (i-1)!+…+a[1]*0!
排列组合 | 名次 | 康托展开 |
---|---|---|
123 | 1 | 0 * 2! + 0 * 1! + 0 * 0! |
132 | 2 | 0 * 2! + 1 * 1! + 0 * 0! |
213 | 3 | 1 * 2! + 0 * 1! + 0 * 0! |
231 | 4 | 1 * 2! + 1 * 1! + 0 * 0! |
312 | 5 | 2 * 2! + 0 * 1! + 0 * 0! |
321 | 6 | 2 * 2! + 1 * 1! + 0 * 0! |
举个例子
在(1,2,3,4,5)5个数的排列组合中,计算 34152的康托展开值。
- 首位是3,则小于3的数有两个,为1和2,a[5]=2,则首位小于3的所有排列组合为 a[5]*(5-1)!
- 第二位是4,则小于4的数有两个,为1和2,注意这里3并不能算,因为3已经在第一位,所以其实计算的是在第二位之后小于4的个数。因此a[4]=2
- 第三位是1,则在其之后小于1的数有0个,所以a[3]=0
- 第四位是5,则在其之后小于5的数有1个,为2,所以a[2]=1
- 最后一位不用计算,因为在它之后已经没有数了,所以a[1]固定为0
- 根据公式:
X = 2 * 4! + 2 * 3! + 0 * 2! + 1 * 1! + 0 * 0! = 2 * 24 + 2 * 6 + 1 = 61
所以比 34152 小的组合有61个,即34152是排第62。
具体代码实现如下:(假设排列数小于10个)
int k[10] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880}; //阶乘
int cantor(int *a, int q)
{
int x = 0;
for(int i = 0; i < n; i++)
{
int smaller = 0; // 在当前位之后小于其的个数
for(int j = i + 1; j < n; j++)
{
if(a[j] < a[i])
smaller++;
}
x += k[n - i - 1] * smaller; // 康托展开累加
}
return x; // 康托展开值
}
逆康托展开
康托展开是一个全排列到一个自然数的双射,因此是可逆的。即对于上述例子,在(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。
具体代码实现如下:(假设排列数小于10个)
int k[15] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880}; // 阶乘
//康托展开逆运算
void decantor(int x, int n)
{
vector <int> ve; // 存放当前可选数
vector <int> a; // 所求排列组合
for(int i = 1; i <= n; i++)
ve.push_back(i);
for(int i = n; i >= 1; i--)
{
int r = x % k[i - 1];
int t = x / k[i - 1];
x = r;
sort(ve.begin(), ve.end()); // 从小到大排序
a.push_back(ve[t]); // 剩余数里第t+1个数为当前位
ve.erase(ve.begin() + t); // 移除选做当前位的数
}
}
那么看懂了康拓/逆康拓展开,也就能轻(shi)轻(fen)松(fei)松(li)的解出这道题,以下为ac代码:
#include <bits/stdc++.h>
using namespace std;
int k[15] = {1, 1, 2, 6, 24, 120, 720, 5040, 40320, 362880};
void decantor(int x, int n)
{
vector <int> ve;
vector <int> a;
for(int i = 1; i <= n; i++)
ve.push_back(i);
for(int i = n; i >= 1; i--)
{
int r = x % k[i - 1];
int t = x / k[i - 1];
x = r;
sort(ve.begin(), ve.end());
a.push_back(ve[t]);
ve.erase(ve.begin() + t);
}
for(int i = 0; i < n; i++)
printf("%d", a[i]);
printf("\n");
}
int main()
{
int n, m;
while(~scanf("%d%d", &n, &m))
{
decantor(m - 1, n); // 注意这里m-1才是康拓值
}
return 0;
}
应用
- 给定一个自然数集合组合一个全排列,所其中的一个排列组合在全排列中从小到大排第几位。
在上述例子中,在(1,2,3,4,5)的全排列中,34152的排列组合排在第62位。 - 反过来,就是逆康托展开,求在一个全排列中,从小到大的第n个全排列是多少。
比如求在(1,2,3,4,5)的全排列中,第62个排列组合是34152。[注意具体计算中,要先 -1 才是其康托展开的值。 - 另外康托展开也是一个数组到一个数的映射,因此也是可用于hash,用于空间压缩。比如在保存一个序列,我们可能需要开一个数组,如果能够把它映射成一个自然数, 则只需要保存一个整数,大大压缩空间。比如八数码问题。