打印从n个数中选取m个数的组合数

打印从n个数种选取m个数的组合数

方法一：利用递归思想。

[cpp]   view plain copy

1. //从后往前选取，选定位置i后，再在前i-1个里面选取m-1个。  
2. //如 1 2 3 4 5 中选取 3 个  
3. //1、选取5后，再在前4个里面选取2个，而前4个里面选取2个又是一个子问题，递归即可。  
4. //2、如果不包含5，直接选定4，那么再在前3个里面选取2个，而前三个里面选取2个又是一个子问题，递归即可。  
5. //3、如果也不包含4，直接选取3，那么再在前2个里面选取2个，刚好只有两个。  
6. //纵向看，1、2、3刚好是一个for循环，初值为5，终值为m  
7. //横向看，该问题为一个前i-1个中选m-1的递归。  
8. void Combination(int arr[], int nLen, int m, int out[], int outLen)  
9. {  
10.     if(m == 0)  
11.     {  
12.         for (int j = 0; j < outLen; j++)  
13.             cout << out[j] << "\t";  
14.         cout << endl;  
15.   
16.         return;  
17.     }  
18.   
19.     for (int i = nLen; i >= m; --i)  //从后往前依次选定一个  
20.     {  
21.         out[m-1] = arr[i-1]; //选定一个后  
22.         Combination(arr,i-1,m-1,out,outLen); // 从前i-1个里面选取m-1个进行递归  
23.     }  
24. }  
25.   
26. void PrintCombination(int arr[], int nLen, int m)  
27. {  
28.     if(m > nLen)  
29.         return;  
30.   
31.     int* out = new int[m];  
32.     Combination(arr,nLen,m,out,m);  
33.     delete [] out;  
34. }  

 

方法二：二进制组合算法：
  思路是开一个数组，其下标表示1到m个数，数组元素的值为1表示其下标
  代表的数被选中，为0则没选中。    
  首先初始化，将数组前n个元素置1，表示第一个组合为前n个数。    
  然后从左到右扫描数组元素值的“10”组合，找到第一个“10”组合后将其变为“01”组合，同时将其左边的所有“1”全部移动到数组的最左端（只有第一位变为0才需要移动，否则其左边的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

 

代码如下：

[cpp]   view plain copy

1. void Combine(int arr[], int n, int m)  
2. {  
3.     if(m > n)  
4.         return;  
5.   
6.     int* pTable = new int[n];       //定义标记buf并将其前m个置1  
7.     memset(pTable,0,sizeof(int)*n);  
8.     for(int i = 0; i < m; ++i)  
9.         pTable[i] = 1;  
10.   
11.     bool bFind = false;  
12.     do   
13.     {  
14.         for (int i = 0; i < n; i++)  //打印当前组合  
15.         {  
16.             if(pTable[i])  
17.                 cout << arr[i] << "\t";  
18.         }  
19.         cout << endl;  
20.   
21.         bFind = false;  
22.         for(int i = 0; i < n-1; i++)  
23.         {  
24.             if(pTable[i]==1 && pTable[i+1]==0)  
25.             {  
26.                 swap(pTable[i],pTable[i+1]);    //调换10为01  
27.                 bFind = true;  
28.   
29.                 if(pTable[0] == 0)  //如果第一位为0，则将第i位置之前的1移到最左边，如为1则第i位置之前的1就在最左边，无需移动  
30.                 {  
31.                     for (int k=0, j=0; k < i; k++)   //O(n)复杂度使1在前0在后  
32.                     {  
33.                         if(pTable[k])  
34.                         {  
35.                             swap(pTable[k],pTable[j]);  
36.                             j++;  
37.                         }  
38.                     }  
39.                 }  
40.   
41.                 break;  
42.             }  
43.         }  
44.     } while (bFind);  
45.   
46.     delete [] pTable;  
47. }  

测试代码如下

[cpp]   view plain copy

1. int main()  
2. {  
3.     int arr[] = {1,2,3,4,5,6};  
4.     Combine(arr,sizeof(arr)/sizeof(int),3);  
5.     //PrintCombination(arr,sizeof(arr)/sizeof(int),3);  
6. }  

 

   方法一结果           方法二结果
       

 

 

 

[cpp]   view plain copy

1. #include<iostream>  
2. using namespace std;  
3. void show(int *a,int *out,int m)  
4. {  
5.     for(int j=0;j<m;j++)  
6.     {  
7.         cout<<a[out[j]]<<"\t";  
8.     }  
9.     cout<<endl;  
10. }  
11. int main()  
12. {  
13.     int m;  
14.     int n;  
15.     cin>>n>>m;  
16.     if(m>n)  
17.     {  
18.         break;  
19.     }  
20.     int *arr=new int[n];  
21.     int *out=new int[m];  
22.     int i;  
23.     int j;  
24.     for(i=0;i<n;i++)  
25.     {  
26.         cin>>arr[i];  
27.     }  
28.     for(i=0;i<m;i++)  
29.     {  
30.         out[i]=i;  
31.     }  
32.     while(1)  
33.     {  
34.         show(arr,out,m);  
35.         i=m-1;  
36.         while(out[i]==m-1+i)  
37.         {  
38.             i--;  
39.         }  
40.         if(i==-1)  
41.         {  
42.             break;  
43.         }  
44.         out[i]+=1;  
45.         j=i+1;  
46.         while(j<=m-1)  
47.         {  
48.             out[j]=out[j-1]+1;  
49.             j++;  
50.         }  
51.     }  
52. }  

由上面做的第二部分启发，可能会好点