排列组合算法

基本概念

1、排列

从n个不同元素中任取m（m≤n）个元素，按照一定的顺序排列起来，叫做从n个不同元素中取出m个元素的一个排列。当m=n时所有的排列情况叫全排列。

 P(n,m)=n(n-1)...(n-m+1)=n!/(n-m)!  特别的，定义0!=1

2、组合

组合数公式是指从n个不同元素中，任取m(m≤n)个元素并成一组，叫做从n个不同元素中取出m个元素的一个组合；从n个不同元素中取出m(m≤n)个元素的所有组合的个数，叫做从n个不同元素中取出m个元素的组合数。用符号c(n,m) 表示。

c(n,m)=p(n,m)/m!=n!/((n-m)!*m!)

3、计算公式

排列算法

递归算法

#include <stdio.h>  
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) 
{     
    int i;     
    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; 
} 

template <typename T>  
inline void swap(T* array, unsigned int i, unsigned int j)  
{  
    T t = array[i];  
    array[i] = array[j];  
    array[j] = t;  
}  
  
/* 
 * 递归输出序列的全排列 
 */  
void FullArray(char* array, size_t array_size, unsigned int index)  
{  
    if(index >= array_size)  
    {  
        for(unsigned int i = 0; i < array_size; ++i)  
        {  
            cout << array[i] << ' ';  
        }  
  
        cout << '\n';  
  
        return;  
    }  
  
    for(unsigned int i = index; i < array_size; ++i)  
    {  
        swap(array, i, index);  
  
        FullArray1(array, array_size, index + 1);  
  
        swap(array, i, index);  
    }  
} 

#include "iostream"
using namespace std;

void permutation(char* a,int k,int m)
{
	int i,j;
	if(k == m)
	{
	<span style="white-space:pre">	</span>for(i=0;i<=m;i++)
		<span style="white-space:pre">	</span>cout<<a[i];
		cout<<endl;
	}
	else
	{
		for(j=k;j<=m;j++)
		{
			swap(a[j],a[k]);
			permutation(a,k+1,m);
			swap(a[j],a[k]);
		}
	}
}
int main(void)
{
	char a[] = "abc";
	cout<<a<<"所有全排列的结果为："<<endl;
	permutation(a,0,2);
	system("pause");
	return 0;
}

#include "iostream"
#include "algorithm"
using namespace std;

void permutation(char* str,int length)
{
	sort(str,str+length);
	do
	{
		for(int i=0;i<length;i++)
			cout<<str[i];
		cout<<endl;
	}while(next_permutation(str,str+length));

}
int main(void)
{
	char str[] = "acb";
	cout<<str<<"所有全排列的结果为："<<endl;
	permutation(str,3);
	system("pause");
	return 0;
}

/// 求从数组a[1..n]中任选m个元素的所有组合。
/// a[1..n]表示候选集，n为候选集大小，n>=m>0。
/// b[1..M]用来存储当前组合中的元素(这里存储的是元素下标)，
/// 常量M表示满足条件的一个组合中元素的个数，M=m，这两个参数仅用来输出结果。
void combine( int a[], int n, int m,  int b[], const int M )
{
  for(int i=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 << endl;
    }
  }
}

#include <iostream>
using namespace std;

/************************************************************************/
/* 
	num : 需要排列的数组
	count : 数组总数
	numC： 已经排列的数组
	iUse：已经排列的个数
	iNull：置0的个数  
	sum: 总排列数
*/
/************************************************************************/
template <class T>
void ComBineNum(T *num, const int count, T *numC, int iUse, int* sum)
{
	int iNull = 0;
	T *newNum = new T[count];
	for (int i = 0; i < count; ++i){	
		memcpy(newNum, num, count);
		if (newNum[i] == 0){
			++iNull;
			if (iNull == count){
				for (int i = 0; i < count; ++i){
					cout << numC[i];
				}
				cout << endl;
				++(*sum);
				return;
			}
			continue;
		}
		numC[count - iUse] = newNum[i];
		newNum[i] = 0;
		ComBineNum(newNum, count, numC, iUse - 1, sum);
	}
	delete[] newNum;
}


int main()
{
	int sum = 0;
	const int count = 4;
	char num[count], pNum[count];
	for (int i = 0; i < count; ++i){
		num[i] = i + '1';
	}
	ComBineNum<char>(num, count, pNum, count, &sum);
	cout << "sum :" << sum << endl;

	sum = 1;
	for (int i = 1; i <= count; ++i){
		sum *= i;
	}
	cout << "sum :" << sum << endl;

	return 0;
}

template <class T>
void Swap(T& a, T& b)
{
	T c = a;
	a = b;
	b = c;
}

template <class T>
void Perm(T list[], int k, int m, int* count)
{
	if (k == m){
		for (int i = 0; i < m; ++ i){
			cout << list[i];
		}
		cout << endl;
		++(*count);
	}
	else{
		for (int i = k; i < m; ++i){
			Swap(list[k], list[i]);
			Perm(list, k + 1, m, count);
			Swap(list[i], list[k]);
		}
	}
}

int main()
{
	const int m = 4;
	int count = 0;
	int list[m];
	for (int i = 0; i < m; ++i){
		list[i] = i + 1;
	}
	
	Perm(list, 0, m, &count);
	cout << count;
	return 0;
}

组合算法

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
#include<assert.h>

void Combination(char *string ,int number,vector<char> &result);

void Combination(char *string)
{
	assert(string != NULL);
	vector<char> result;
	int i , length = strlen(string);
	for(i = 1 ; i <= length ; ++i)
		Combination(string , i ,result);
}

void Combination(char *string ,int number , vector<char> &result)
{
	assert(string != NULL);
	if(number == 0)
	{
		static int num = 1;
		printf("第%d个组合\t",num++);

		vector<char>::iterator iter = result.begin();
		for( ; iter != result.end() ; ++iter)
			printf("%c",*iter);
		printf("\n");
		return ;
	}
	if(*string == '\0')
		return ;
	result.push_back(*string);
	Combination(string + 1 , number - 1 , result);
	result.pop_back();
	Combination(string + 1 , number , result);
}

int main(void)
{
	char str[] = "abc";
	Combination(str);
	return 0;
}

#include<stdlib.h>
#include<String.h>
#include<iostream.h>
inline void Swap(int*lhs,int*rhs)
{
	int tmp= *lhs; *lhs=*rhs; *rhs=tmp;
}
void Reverse(int*beg,int*end)
{
	while(beg<end)Swap(beg++,--end);
}
void Print(int*beg,int*end)
{
	while(beg!=end)cout<<*beg++<<' ';cout<<endl;
}

inline int Cmp(const void*lhs,const void*rhs)
{
	return *(const int*)rhs - *(const int*)lhs;
}
	
void Permutation(int* beg, int* mid, int* end)
{ 
	int k(0),*p,*q;
	int i(2);
	if(end-mid > 1)
	qsort(mid,end - mid,sizeof(int),Cmp);Print(beg,mid);
	int* nav = end - 1; 
	while(i)
	{     
		int* tmp = nav; 
		if(*--nav < *tmp) 
		{ 
			int* rmbt = end; 
			while(*--rmbt <= *nav)
			if(rmbt==mid)
			{
				Swap(nav,tmp);
				nav--;
				rmbt = end;
			}
			Reverse(nav, rmbt+1);
			qsort(mid, end - mid, sizeof(int), Cmp);
			Print(beg, mid);  
			nav = end - 1;
		} 
		i=2;
		for(q=p=beg;*p<=*++q;p=q)
		if(q==mid-1)i--;
		for(q=p=end-1;*p<=*--q;p=q)
		if(q==mid&&*q<=*beg)i--;
	}
}

int main()
{
	int a[] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	Permutation(a,a+3,a+7);
	return 0;
}

参考链接

1、http://dongxicheng.org/structure/permutation-combination/