如何生成全排列

最新推荐文章于 2025-06-27 13:13:06 发布

原创最新推荐文章于 2025-06-27 13:13:06 发布 · 684 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#全排列

数据结构与算法专栏收录该内容

5 篇文章

订阅专栏

[问题描述]：给定一个数组 $a_1 a_2 a_3 \cdots a_n$ ，如何（按照字典序）生成它的全排列？比如(1,2,3)，它的全排列就是(1,2,3),(1,3,2),(2,1,3),(2,3,1),(3,1,2),(3,2,1).

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

$a_1 a_2 \cdots a_{i-1} a_i a_{i+1} \cdots a_n < a_1 a_2 \cdots a_{i-1} b_i b_{i+1} \cdots b_n$

当且仅当 $a_i < b_i$ 。

1. 递归

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

根据上面的分析过程， $a_1 a_2 a_3 \cdots a_n$ 的全排列就是：以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=a_1 a_2 \cdots a_n = a_1 a_2 \cdots a_{j-1}a_{j}a_{j+1} \cdots a_{k-1}a_{k}a_{k+1} \cdots a_n$

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

从右端开始，找出第一个a[j]<a[j+1]的位置j，即 $j = \max \{i | a_i < a_{i+1} \}$ 。如果找不到，就说明是反序（最后一个排列），没有下一个排列。
在j右边，找出最后一个比a[j]大的位置k，即 $k = \max \{ i | a_j < a_i \}$ 。显然k存在，因为j+1就满足条件。
交换a[j]和a[k]
将 $a_{j+1}a_{j+2}\cdots a_{n}$ 反转，就得到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]*(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[N] = {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[N]; cnt++){
		printf("[%3d] ", cnt);
		inverseCantor(a, N, cnt);
		printArray(a, a+N);
	}

	return 0;
}

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

参考资料：

http://blog.youkuaiyun.com/goal00001111/article/details/3326619

http://zh.wikipedia.org/wiki/%E5%BA%B7%E6%89%98%E5%B1%95%E5%BC%80

本博客代码没有经过测试，因此BUG无数，欢迎无责任使用，出现问题与本人一概无关~