排列組合算法


基本概念

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/


























注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



排列組合算法 排列組合算法 排列組合算法 排列組合算法 排列組合公式及排列組合算法 數組排列組合算法匯總 Java實現排列組合算法 排列組合算法問題 全排列組合算法 排列組合算法之排列算法 C++
 
粤ICP备14056181号  © 2014-2021 ITdaan.com