如何生成全排列

[问题描述]：给定一个数组

，如何（按照字典序）生成它的全排列？比如(1,2,3)，它的全排列就是(1,2,3),(1,3,2),(2,1,3),(2,3,1),(3,1,2),(3,2,1).

在数学上，两个排列的大小定义为第一个不相等元素的大小关系，也就是说




当且仅当

。

1. 递归

观察我们手动生成全排列的过程，首先固定第一个元素：先写1开头的1xx，然后写2开头的2xx，然后是3开头的3xx；然后固定第二个元素：写1xx的时候，，剩下还有2,3两个元素，于是先写12x，然后再写13x。直到剩下一个元素，他的全排列只有一个（就是他自己）。
根据上面的分析过程，

的全排列就是：以a1开头和剩下n-1个数的排列a1xxxx；以a2开头和剩下n-1个数的排列a2xxxx，...，以an开头和剩下n-1个数的排列anxxxx。这样问题的规模缩减为n-1，当n=1时变为平凡情形，可以直接求解（递归出口）。由此得出递归算法：

#include <iostream>
#include <algorithm>
using namespace std;

int cnt = 0;

template <typename T>
void printArray(T *first, T *last){
T *p = NULL;
for(p = first; p != last; p++){
cout<<*p<<" ";
}
cout<<endl;
}

// 递归方法
template <typename T>
void simple_recur_perm(T *arr, int left, int right)
{
int i;
if(left == right){
printf("[%3d] ", cnt++);
printArray(arr, arr+right+1);
}
else{
for(i = left; i <= right; i++){
std::swap(arr[i], arr[left]);  //将ai交换到起始位置
simple_recur_perm(arr, left+1, right);
std::swap(arr[left], arr[i]);  //重新恢复数组
}
}
}

调用simple_recur_perm(arr, 0, n-1)即可。

这个函数有两个问题：(1)输出的排列不是按照字典序排列的；(2)无法处理有重复元素的情况。比如(1,1,2,3)，它的全排列共有4!/2!=12个而不是24个。

对于问题1，这个递归函数和我们手工分析的略微有些差别：我们在生成ai（比如说a4)开头的排列时，并不是简单的让他和a1交换，然后生成a2a3a1a5...an的排列，而是生成a1a2a3a5...an的排列。也就是说，当ai固定在首位时，剩下的n-1个元素依然是有序的。问题2的修正方法很简单：当两个元素相等的时候，事实上没有必要交换它们，因为交换前后序列是一样的，因此会出现重复输出。

// 递归方法
template <typename T>
void recur_perm(T *arr, int left, int right)
{
int i;
if(left == right){
printf("[%3d] ", cnt++);
printArray(arr, arr+right+1);
}
else{
for(i = left; i <= right; i++){
if(i != left && arr[left] == arr[i])   // 相等元素不需要交换
continue;
std::rotate(arr+left, arr+i, arr+i+1); // 把ai放在首位
recur_perm(arr, left+1, right);
std::rotate(arr+left, arr+left+1, arr+i+1);
}
}
}

2. 字典序生成

STL有next_permutation()函数，能够直接计算出某个排列的下一个排列，对于序列



计算下一个排列的算法过程是：

从右端开始，找出第一个a[j]<a[j+1]的位置j，即

。如果找不到，就说明是反序（最后一个排列），没有下一个排列。

在j右边，找出最后一个比a[j]大的位置k，即

。显然k存在，因为j+1就满足条件。

交换a[j]和a[k]
将

反转，就得到A的下一个排列A'。
例如839647521是数字1～9的一个排列。从它生成下一个排列的步骤如下：

自右至左找出排列中第一个比右边数字小的数字4；
在该数字后的数字中找出比4大的数中最小的一个5；
将5与4交换得到839657421；
将7421倒转得到839651247；
所以839647521的下一个排列是839651247。

过程说完了，为什么这样得到的就是A的下一个排列？

首先，由于a[j]<a[k]，而A[1...j-1]=A'[1...j-1]，因此A'>A，A'一定排在A的后面。
其次，我们在计算(4123)的下一个排列时，一定是交换2和3生成(4132)，而不是交换1和2，或者1和3。这是因为两个排列的大小关系由第一个不相等元素的大小关系决定，也就是说，前面的元素比后面的元素的权重更大。为了让A'尽可能的接近A（目标是A+1），应破坏那些权重最小的正序，就是说j是满足a[j]<a[j+1]的最右边的位置。
第三，j是最右边满足a[j]<a[j+1]的位置，因此j之后的序列一定是逆序。而a[k]>a[j]，因此交换a[j],a[k]之后，a[j+1...n]依然是逆序。将它反转，从而变为正序（也就是最小的排列），使得A'>A且变换后的排列A'最小。
我实现的山寨版代码如下

// 直接生成(stl::next_permutation)
template <typename T>
bool stl_permutation(T *arr, int len)
{
if(len <= 1)
return false;
int j, k;

for(j = len-1; j >= 1; j--) {
if(arr[j-1] < arr[j])     //第一个a[j-1]<a[j]的位置
break;
}

if(--j < 0){        //没找到，说明是反序
std::reverse(arr, arr+len);
return false;
}

for(k = len-1; k >j; k--){
if(arr[k] > arr[j])
break;
}
std::swap(arr[j], arr[k]);
std::reverse(arr+j+1, arr+len);
return true;
}

它能够处理重复元素。

3. 康托展开

上面的方法每次增加的顺序为1。能否根据A在全排列中的顺序，直接生成呢？

计算当前排列在全排列中的顺序叫做康托展开，计算公式为
X=p
*(n-1)!+p[n-1]*(n-2)!+...+p[i]*(i-1)!+...+p[1]*0!

其中p[i]表示a[0]a[1]...a[i-1]中比a[i]小的元素的个数。例如，3 5 7 4 1 2 9 6 8 展开为 98884，X=2*8!+3*7!+4*6!+2*5!+0*4!+0*3!+2*2!+0*1!+0*0!=98884。
那么这个公式怎么得来的呢？计算全排列中的顺序，就是计算有多少个全排列比它还小。以上面这个例子说明，比它小的全排列有：

首先看首位，比3小的有1和2，1xxxxxxxx, 2xxxxxxxx，一共2*8!个；
再看第二位，比5小的有1,2,3,4，但是3已经在前面用了，31xxxxxxx, 32xxxxxx, 34xxxxxxx, 一共3*7!个
然后看第三位，比7小的有1,2,3,4,5,6，但3和5已经在前面用过了，3571xxxxx, 3572xxxxx, 3574xxxxx, 3576xxxxx,
……

计算的函数为：

const int PermSize = 12;
long long factorial[PermSize] = {1, 1, 2, 6, 24, 120,720, 5040, 40320, 362880, 3628800,39916800 };
template <typename T>
long long Cantor(T *arr, int len){
int i, j;
long long n = 0;
long long C = 0;
for(i = 0; i < len; i++){
n = 0;
for(j = i+1; j < len; j++){
if(arr[j] < arr[i])
n++;
}
C += n * factorial[len-i-1];
}
return C;
}

康托展开是一个全排列到一个自然数的双射，因此根据全排列的顺序，也能将排列计算出来。如n=5,x=95时：

用95去除4! 得到3余23，说明有3个数比第1位小，所以第一位是4
用23去除3! 得到3余5，说明有3个数比第2位小，所以是4，但是4已出现过，因此是5
用5去除2!得到2余1，类似地，这一位是3
用1去除1!得到1余0，这一位是2
最后一位只能是1
所以这个数是45321。

根据全排列顺序直接生成排列的函数：

template <typename T>
void inverseCantor(T *arr, int len, long long C){
int i, j;
for(i = 0; i < len; i++){
j = C / factorial[len-1-i];
C -= j*factorial[len-1-i];
std::nth_element(arr+i, arr+i+j, arr+len);
std::swap(arr[i], arr[i+j]);
}
}

但康托展开不能处理有重复元素的情形。另外由于涉及阶乘，容易造成溢出。

用于测试的主函数：

int main()
{
const int N = 4;
int a
= {1, 2, 3, 4};
std::sort(a, a+N);

// 递归
cnt = 0;
simple_recur_perm(a, 0, N-1);
recur_perm(a, 0, N-1);
cout<<endl;

// 直接计算下一个排列
cnt = 0;
do{
printf("[%3d] ", cnt++);
printArray(a, a+N);
}while(stl_permutation(a, N));
cout<<endl;

//康托展开
cnt = 0;
for(cnt = 0; cnt < factorial
; cnt++){
printf("[%3d] ", cnt);
inverseCantor(a, N, cnt);
printArray(a, a+N);
}

return 0;
}

另外，生成全排列的方法还有递增、递减进位制数法，邻位对换法等等，这里就不列举了（其实是因为我还没研究）。

参考资料： http://blog.csdn.net/goal00001111/article/details/3326619 http://zh.wikipedia.org/wiki/%E5%BA%B7%E6%89%98%E5%B1%95%E5%BC%80
本博客代码没有经过测试，因此BUG无数，欢迎无责任使用，出现问题与本人一概无关~