当前位置：文档库 › 排列组合算法

排列组合算法

最近一直在考虑从m个数里面取n个数的算法。最容易理解的就是递归，但是其效率，实在不能使用。一直找寻中，今日得果

2。算法来源与互联网

组合算法

本程序的思路是开一个数组，其下标表示1到m个数，数组元素的值为1表示其下标

代表的数被选中，为0则没选中。

首先初始化，将数组前n个元素置1，表示第一个组合为前n个数。

然后从左到右扫描数组元素值的“10”组合，找到第一个“10”组合后将其变为

“01”组合，同时将其左边的所有“1”全部移动到数组的最左端。

当第一个“1”移动到数组的m-n的位置，即n个“1”全部移动到最右端时，就得

到了最后一个组合。

例如求5中选3的组合：

1 1 1 0 0 //1,2,3

1 1 0 1 0 //1,2,4

1 0 1 1 0 //1,3,4

0 1 1 1 0 //2,3,4

1 1 0 0 1 //1,2,5

1 0 1 0 1 //1,3,5

0 1 1 0 1 //2,3,5

1 0 0 1 1 //1,4,5

0 1 0 1 1 //2,4,5

0 0 1 1 1 //3,4,5

全排列算法

从1到N，输出全排列，共N！条。

分析：用N进制的方法吧。设一个N个单元的数组，对第一个单元做加一操作，满N进一。每加一次一就判断一下各位数组单元有无重复，有则再转回去做加一操作，没

有则说明得到了一个排列方案。

//////////////////////////////////////////////////////

递归算法

全排列是将一组数按一定顺序进行排列，如果这组数有n个，那么全排列数为n!个。现以{1, 2, 3, 4, 5}为

例说明如何编写全排列的递归算法。

1、首先看最后两个数4, 5。它们的全排列为4 5和5 4, 即以4开头的5的全排列和以5开头的4的全排列。

由于一个数的全排列就是其本身，从而得到以上结果。

2、再看后三个数3, 4, 5。它们的全排列为3 4 5、3 5 4、4 3 5、4 5

3、5 3

4、5 4 3 六组数。

即以3开头的和4,5的全排列的组合、以4开头的和3,5的全排列的组合和以5开头的和3,4的全排列的组合.

从而可以推断，设一组数p = {r1, r2, r3, ... ,rn}, 全排列为perm(p)，pn = p - {rn}。

因此perm(p) = r1perm(p1), r2perm(p2), r3perm(p3), ... , rnperm(pn)。当n = 1时perm(p} = r1。

为了更容易理解，将整组数中的所有的数分别与第一个数交换，这样就总是在处理后n-1个数的全排列。

算法如下：

#include

int n = 0;

void swap(int *a, int *b)

{

int m;

m = *a;

*a = *b;

*b = m;

}

void perm(int list[], int k, int m)

{

inti;

if(k > m)

{

for(i = 0; i<= m; i++)

printf("%d ", list[i]);

printf("/n");

n++;

}

else

{

for(i = k; i<= m; i++)

{

swap(&list[k], &list[i]);

perm(list, k + 1, m);

swap(&list[k], &list[i]);

}

int main()

{

int list[] = {1, 2, 3, 4, 5};

perm(list, 0, 4);

printf("total:%d/n", n);

return 0;

}

谁有更高效的递归和非递归算法，请回贴。

///////////////////////////////////////

全排序

设R={r1,r2,...,rn}是要进行排列的n个元素，Ri = R-{ri}. 集合X 中元素的全排列记为Perm(X)。(ri)Perm(X)表示在全排列Perm(X)的每一个排列上加前缀ri得到的排列。R的全排列可归纳定义如下：

当n = 1 时，Perm(R) = (r),其中r 是集合R中唯一的元素；

当n >1 时，Perm(R)有(r1)Perm(R1),(r2)Perm(R2),.......,(rn)Perm(Rn)构成

依此递归定义，可设计产生Perm(R)的递归算法如下：

template

void Perm(Type list[], int k, int m){

if ( k == m ){

for ( inti = 0; i<= m; i++)

cout<< list[i];

cout<

}

else{

for ( inti = k; i<= m; i ++){

Swap( list[k],list[i] );

Perm( list,k + 1, m ) ;

Swap( list[k], list[i] );

}

template < class Type >

inline void Swap ( Type &a ,Type & b)

{

Type temp = a; a = b; b = temp;

}

////////////////////////////////////////

排列组合问题的通用算法

尽管排列组合是生活中经常遇到的问题，可在程序设计时，不深入思考或者经验不足都让人无从下手。由于排列组合问题总是先取组合再排列，并且单纯的排列问题相对简单，所以本文仅对组合问题的实现进行详细讨论。以在n个数中选取m(0

1. 首先从n个数中选取编号最大的数，然后在剩下的n-1个数里面选取m-1个数，直到从n-(m-1)个数中选取1个数为止。

2. 从n个数中选取编号次小的一个数，继续执行1步，直到当前可选编号最大的数为m。很明显，上述方法是一个递归的过程，也就是说用递归的方法可以很干净利索地求得所有组合。

下面是递归方法的实现：

/// 求从数组a[1..n]中任选m个元素的所有组合。

/// a[1..n]表示候选集，m表示一个组合的元素个数。

/// b[1..M]用来存储当前组合中的元素, 常量M表示一个组合中元素的个数。

void combine( int a[], int n, int m, int b[], constint M )

{

for(inti=n; i>=m; i--) // 注意这里的循环范围

{

b[m-1] = i - 1;

if (m > 1)

combine(a,i-1,m-1,b,M);

else // m == 1, 输出一个组合

{

for(int j=M-1; j>=0; j--)

cout<< a[b[j]] << " ";

cout<

}

因为递归程序均可以通过引入栈，用回溯转化为相应的非递归程序，所以组合问题又可以用回溯的方法来解决。为了便于理解，我们可以把组合问题化归为图的路径遍历问题，在n 个数中选取m个数的所有组合，相当于在一个这样的图中（下面以从1,2,3,4中任选3个数为例说明）求从[1,1]位置出发到达[m,x] (m<=x<=n)位置的所有路径：

1 2 3 4

2 3 4

3 4

上图是截取n×n右上对角矩阵的m行构成，我们要求的所有组合就相当于从第一行的第一列元素[1,1]出发，到第三行的任意一列元素作为结束的所有路径，规定每走一步需跨越一行，并且从上一行的任何一个元素到其下一行中列处于其右面的任何一个元素均有一路径相连，显然任一路径经过的数字序列就对应一个符合要求的组合。

下面是非递归的回溯方法的实现：

/// 求从数组a[1..n]中任选m个元素的所有组合。

/// a[1..n]表示候选集，m表示一个组合的元素个数。

/// 返回所有排列的总数。

int combine(int a[], int n, int m)

{

m = m > n ? n : m;

int* order = new int[m+1];

for(inti=0; i<=m; i++)

order[i] = i-1; // 注意这里order[0]=-1用来作为循环判断标识

int count = 0;

int k = m;

bool flag = true; // 标志找到一个有效组合

while(order[0] == -1)

{

if(flag) // 输出符合要求的组合

{

for(i=1; i<=m; i++)

cout<< a[order[i]] << " ";

cout<

count++;

flag = false;

}

order[k]++; // 在当前位置选择新的数字

if(order[k] == n) // 当前位置已无数字可选，回溯

{

order[k--] = 0;

continue;

}

if(k < m) // 更新当前位置的下一位置的数字

{

order[++k] = order[k-1];

continue;

}

if(k == m)

flag = true;

}

delete[] order;

return count;

}

下面是测试以上函数的程序：

int main()

{

constint N = 4;

constint M = 3;

int a[N];

for(inti=0;i

a[i] = i+1;

// 回溯方法

cout<< combine(a,N,3) <

// 递归方法

int b[M];

combine(a,N,M,b,M);

return 0;

}

由上述分析可知，解决组合问题的通用算法不外乎递归和回溯两种。在针对具体问题的时候，因为递归程序在递归层数上的限制，对于大型组合问题而言，递归不是一个好的选择，这种情况下只能采取回溯的方法来解决。

n个数的全排列问题相对简单，可以通过交换位置按序枚举来实现。STL提供了求某个序列下一个排列的算法next_permutation，其算法原理如下：

1. 从当前序列最尾端开始往前寻找两个相邻元素，令前面一个元素为*i，后一个元素为*ii，且满足*i<*ii；

2. 再次从当前序列末端开始向前扫描，找出第一个大于*i的元素，令为*j（j可能等于ii），将i，j元素对调；

3. 将ii之后（含ii）的所有元素颠倒次序，这样所得的排列即为当前序列的下一个排列。其实现代码如下：

template

bool next_permutation(BidirectionalIterator first, BidirectionalIterator last)

{

if (first == last) return false; // 空範圍

BidirectionalIteratori = first;

++i;

if (i == last) return false; // 只有一個元素

i = last; // i指向尾端

--i;

for(;;)

{

BidirectionalIterator ii = i;

--i;

// 以上，鎖定一組（兩個）相鄰元素

if (*i< *ii) // 如果前一個元素小於後一個元素

{

BidirectionalIterator j = last; // 令j指向尾端

while (!(*i< *--j)); // 由尾端往前找，直到遇上比*i大的元素

iter_swap(i, j); // 交換i, j

reverse(ii, last); // 將ii 之後的元素全部逆向重排

return true;

}

if (i == first) // 進行至最前面了

{

reverse(first, last); // 全部逆向重排

return false;

}

下面程序演示了利用next_permutation来求取某个序列全排列的方法：

int main()

{

intia[] = {1,2,3,4};

vector iv(ia,ia+sizeof(ia)/sizeof(int));

copy(iv.begin(),iv.end(),ostream_iterator(cout," "));

cout<

while(next_permutation(iv.begin(),iv.end()))

{

copy(iv.begin(),iv.end(),ostream_iterator(cout," "));

cout<

}

return 0;

}

注意：上面程序中初始序列是按数值的从小到大的顺序排列的，如果初始序列无序的话，上面程序只能求出从当前序列开始的后续部分排列，也就是说next_permutation求出的排列是按排列从小到大的顺序进行的。

///////////////////////////////////////////////////////

排列组合与回溯算法

KuiBing

感谢Bamboo、LeeMaRS的帮助

[关键字] 递归DFS

[前言] 这篇论文主要针对排列组合对回溯算法展开讨论，在每一个讨论之后，还有相关的推荐题。在开始之前，我们先应该看一下回溯算法的概念，所谓回溯：就是搜索一棵状态树的过程，这个过程类似于图的深度优先搜索（DFS），在搜索的每一步（这里的每一步对应搜索树的第i层）中产生一个正确的解，然后在以后的每一步搜索过程中，都检查其前一步的记录，并且它将有条件的选择以后的每一个搜索状态（即第i+1层的状态节点）。

需掌握的基本算法：

排列：就是从n个元素中同时取r个元素的排列，记做P(n,r)。（当r=n时，我们称P(n,n)=n!为全排列）例如我们有集合OR = {1,2,3,4},那么n = |OR| = 4,切规定r=3，那么P(4,3)就是：

{1,2,3}; {1,2,4}; {1,3,2}; {1,3,4};{1,4,2};{1,4,3};{2,1,3};{2,1,4}; {2,3,1}; {2,3,4}; {2,4,1}; {2,4,3}; {3,1,2}; {3,1,4}; {3,2,1}; {3,2,4}; {3,4,1}; {3,4,2}; {4,1,2}; {4,1,3}; {4,2,1}; {4,2,3}; {4,3,1}; {4,3,2}

算法如下：

int n, r;

char used[MaxN];

int p[MaxN];

void permute(intpos)

{ inti;

/*如果已是第r个元素了，则可打印r个元素的排列*/

if (pos==r) {

for (i=0; i

cout<< (p[i]+1);

cout<

return;