常用排列与组合的相关算法

最新推荐文章于 2020-08-13 17:11:32 发布

Deutschester

最新推荐文章于 2020-08-13 17:11:32 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏：基本算法 (C++) 文章标签：算法 permutation list iostream class ini

本文链接：https://blog.youkuaiyun.com/Deutschester/article/details/5183529

基本算法 (C++) 专栏收录该内容

26 篇文章

订阅专栏

一、排列（permutation）

（1）递归方法 (非有序)

设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)的递归算法如下：

=================================================

比如：abcd四个字符，

首先，考虑放在第一个位置的字符，将第一个字符与第一，二，三，四个字符交换。

1－1：abcd

1－2：bacd

1－3：cbad

1－4：dbca

其次，考虑第2到n个字符，用递归做。每次都要重新恢复字符串的位置。

#include <iostream>

using namespace std;

template <class Type>

void Perm(Type list[], int k, int m) // 求数组中k到m的元素的全排列

{

if ( k == m ) //输出一个排列方式

{

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

cout << list[i];

cout << endl;

}

else{ //list[k：m ]有多个排列方式,递归地产生这些排列方式

for ( int i = 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;

}

测试程序：

int main()
{
char list[]="abcdef";
Perm(list,0,5); //因为是0~5，所以求的是全排列
return 0;
}

==========================================

（2）循环直接模拟法——又叫字典序生成算法 (有序)

字典序生成算法（详见：http://blog.youkuaiyun.com/goal00001111/archive/2008/11/18/3326619.aspx）：

设P是1～n的一个全排列:p = p1p2...pn = p1p2...pj-1pjpj+1......pk-1pkpk+1...pn

1）从排列的右端开始，找出第一个比右边数字小的数字的序号j（j从左端开始计算），即j = max{i | pi < pi+1}

2）在pj的右边的数字中，找出所有比pj大的数中最小的数字pk，即 k = max{i | pj < pi}

（右边的数从右至左是递增的，因此k是所有大于pj的数字中序号最大者）

3）对换pj，pk

4）再将pj+1......pk-1pkpk+1...pn倒转得到排列p' = p1p2...pj-1pjpn......pk+1pkpk-1...pj+1，

这就是排列p的下一个排列。

例如839647521是数字1～9的一个排列。从它生成下一个排列的步骤如下：

自右至左找出排列中第一个比右边数字小的数字4；

在该数字后的数字中找出比4大的数中最小的一个5；

将5与4交换得到839657421；

将7421倒转得到839651247；

所以839647521的下一个排列是839651247。

====================================

#include <iostream>
using namespace std;

void permutation(int n,long m) //循环直接模拟法又叫字典序生成算法--输出n个数的第m种全排列
{
int *a=new int[n];
for(int i=0;i<n;i++) //生成原始数列
a[i]=i+1;

cout<<"第"<<m<<"个全排列是:"<<'/t';
int left,right;
long temp;
for(i=1;i<m;i++)
{
  left = n-2;
  while(left>=0 && a[left]>a[left+1])
   left--;         //得到一个left右边是递减的数列
  right = n-1;    //右边界是最右边的元素
  while(a[right]<a[left]) //找到左边界右边数组中比a[left]大的最小的元素
   right--;
  temp=a[left]; a[left]=a[right];a[right]=temp;   //左右的元素交换
  left++;
  right = n-1;
  while(left<right) )    //逆置左右边界之间的元素，使其按增序排列
  {
   temp=a[left];
   a[left]=a[right];
   a[right]=temp;
   left++;
   right--;
  }
}
for(i=0;i<n;i++)
  cout<<a[i]<<" ";
cout<<endl;
delete []a;
}

int main()
{
int n=12;
for(int i=1000;i<10000001;i*=100)
permutation(n,i);
return 0;
}

========================================

二、组合(Combination)

来自：http://blog.youkuaiyun.com/xuhx/archive/2008/03/05/2150126.aspx

1.背景
上一篇介绍了枚举排列元组的方法，本篇介绍枚举组合元组的方法。上一篇介绍的枚举排列元组的方法实际是枚举的P(n,n)的元组，而不是通用的P(n,r)。但是本篇介绍完枚举组合元组C(n,r)的方法后，就可以根据公式P(n,r)=C(n,r)*P(r,r)很容易地实现枚举P(n,r)排列元组的方法了。

2.算法步骤
假定有0,1,...,n-1这些元素，枚举C(n,r)的元组。
（1）把组成组合的前r个元素从小到大排列，这当作组合的第一个元组。
0,1,...,r-1
（2）从后向前搜索当前元组中的元素，发现第一个位置，如果此位置的元素还小于最大值，则把此位置的元素的值加1。此新元组是需要的元组。把此位置用i表示，则此位置的最大值为n-r+i-1。
（3）对i位置后的元素，后面的元素是前面的元素加1。
（4）如果（2）能够构造新的元组则从（1）继续。否则结束。

3.算法代码

#include <stdio.h>
#define MAX 100
typedef void OutProc(int [],int);
//output
void OutputCombination(int ary[],int n)
{
    static int count=0;
    int i;
    printf("%05d : ",++count);
    for(i=0;i<n;i++)
    {
        printf("%d ",ary[i]);
    }
    printf(" /n");
}
//main algorithms
void Combination(int n,int r,OutProc proc)
{
    int ary[MAX];
    int i,k;
    for(i=0;i<r;i++) ary[i]=i;
    proc(ary,r);
    bool finished=false;
    while(!finished)
    {
        finished=true;
        for(i=r-1;i>=0;i--)
        {
            if(ary[i]<i+n-r)
            {
                ary[i]++;
                finished=false;
                for(k=i+1;k<r;k++)
                {
                    ary[k]=ary[k-1]+1;
                }
                proc(ary,r);
                break;
            }
        }
    }
}
//test
void combination_test()
{
    Combination(5,3,OutputCombination);
}
//main
int main()
{
    combination_test();
    return 0;
}
4.运算结果：

00001 : 0 1 2
00002 : 0 1 3
00003 : 0 1 4
00004 : 0 2 3
00005 : 0 2 4
00006 : 0 3 4
00007 : 1 2 3
00008 : 1 2 4
00009 : 1 3 4
00010 : 2 3 4

=========================

比较实用的算法——能够计算出所有的组合数

（1）递归

#include <stdio.h>
#include <stdlib.h>

int n,r;
int count = 0;
void printR(int a[])
{
count++;
for(int j = r-1;j>=0;j--)
printf(" %d",a[j]);
printf("/n");
}

void comb(int a[],int m,int k)
{
for(int i=m;i>=k;i--)
{
  a[k-1] = i;
  if(k>1)
   comb(a,i-1,k-1);
  else
   printR(a);
}
}

int main()
{
printf("n、r:");
scanf("%d %d",&n,&r);
int*a = (int*)malloc(sizeof(int)*n);
comb(a,n,r);
printf("Total number: %d",count);
printf("/n");
return 0;
}

（2）非递归

#include <time.h>
#include <iostream>
#include <iomanip>
using namespace std;

#define MAXN 100
void comb(int m,int r)
{
//a[r]是定位数组,用于指示选取元素集合数组的位置，选取元素集合数组0   起始
int*a = new int[r];
int cur;//指示定位数组中哪个成员正在移进
unsigned   int   count=0;
//初始化定位数组，0   起始的位置   ，开始的选择必是位置   0，1，2
for(int   i=0;i<r;i++)
  a[i]=i;
cur=r-1;//当前是最后一个成员要移进
cout<<"组合结果:"<<endl;
while(1)
{
  if(a[cur]-cur<=m-r)
  {
   count++;
   for(int j=0;j<r;j++)
    cout<<setw(4)<<a[j];
   cout<<endl;
   a[cur]++;
   continue;
  }
  else
  {
   if(cur==0)
   {
    cout<<"总数是: "<<count<<endl;
    break;
   }
   a[--cur]++;
   for(int i=1;i<r-cur;i++)
   {
    a[cur+i]=a[cur]+i;
   }
   //memcpy((void*)(a+cur+1),(void*)(b+a[cur]+1),sizeof(int)*(r-cur-1));原以为用内存移动效率比上面循环会高，可是......
   if(a[cur]-cur<m-r)
    cur=r-1;
  }
}
delete []a;
}

void printtime(void)   //打印当前时间的函数
{
char tmpbuf[128];
time_t ltime;
struct tm *today;

time(&ltime);
today = localtime(&ltime);
strftime(tmpbuf,128,"%Y-%m-%d %H:%M:%S",today);
cout<<tmpbuf<<endl;
}

int main(int argc, char* argv[])
{
int m,r;
cout<<"m(总数): ";
cin>>m;
cout<<"r(取数): ";
cin>>r;
printtime();
comb(m,r);
printtime();
return(0);
}