排列与组合算法解析-优快云博客

首先说排列，可以根据递归定义，从n个元素里面选m个进行排列，第一步先从n个元素里面选任意一个元素，然后再在剩下的n-1个元素里面选m-1个元素进行排列。这个就是递归定义。因为是任意一个元素，因此必须进行一个从第0个元素到n-1个元素的循环。

比如从集合[1，2，3]中取2个数进行排列

（1）第一个循环，取出元素1作为集合的第一个排列数;然后再利用递归从剩下的元素[2，3]中取1个元素进行排列，这个得到的集合就是[2]和[3];最后再将第一个排列数1加到第二步递归得到的所有集合中，即得到第一个循环找出的两个集合[1，2]和[1，3]

（2）第二个循环，取出元素2作为集合的第一个排列数;然后再利用递归从剩下的元素[1，3]中取1个元素进行排列，这个得到的集合就是[1]和[3];最后再将第一个排列数2加到第二步递归得到的所有集合中，即得到第二个循环找出的两个集合[2，1]和[2，3]

（3）依次类推，当所有的循环完成后，把每一趟循环得到的结果集都收集起来，就是这个3取2排列的所有结果。

然后说组合。从n个元素里面取m个进行组合，安照数据公式的理解，组合比排列要复杂一些，其实排列数已经包含了组合数，只是组合数不需要包含重复的集合，比如集合[1,2,3]和集合[3,2,1]就是不同的排列，但是是同一种组合。在计算组合数的时候，需要注意不要有重复的组合。组合也是利用递归来求解。不同的组合，要点就是其中某个集合包含某个元素，其他元素不包含这个元素，就构成不同的集合。也是从n个元素从取任意一个元素，表示为Ni，表示m个元素的i组合中，必定含有元素Ni。然后再对剩下的数求m-1个元素的组合，此时要注意，后续的递归中，原始数据集中必不包含Ni这个元素。这也需要一个循环。比如从集合[1，2，3]从取2个元素的组合：

（1）第一趟循环，取元素1为第一个组合数，然后对集合[2，3]求取1个元素的组合，这两个结果为[2]和[3];然后再加入第一个组合数1，则得到组合[2，1]和[3，1]

（2）第二趟循环，取元素2为第一个组合数，然后对集合[3]求取1个元素的组合（此时初始数据已经不能包含1了，因为在第一趟循环的时候，含有元素1的所有组合已经存在了），结果只有[3];然后加入第一个组合数2，则得到组合[3，2]

（3）如果此时剩下的元素不足m个，则不需要进行无谓的循环了，此时已经找出所有的组合

代码如下：

#include <iostream>
#include <string>
#include <vector>
using namespace std;

//从集合中取m个元素的所有组合
vector<vector<int>> Combine(vector<int> &vt, int m)
{
	vector<vector<int> > ret;
	if (vt.size() < m)
	{
		return ret;
	}

	//如果是集合大小vt.size() 和 m相同，也可以确定结果，相当于在有m个元素的集合里面取m个元素的组合，只有一种
	//因此不需要往后做多余的递归调用
	if (vt.size() == m)
	{
		ret.push_back(vt);
		return ret;
	}

	//递归出口
	if (1 == m)
	{
		for (auto &item : vt)
		{
			vector<int> vtTemp;
			vtTemp.push_back(item);
			ret.push_back(vtTemp);
		}
		return ret;
	}
	int i = 1;
	for (auto it = vt.begin(); it != vt.end() && (vt.size() - i) >= (m - 1); it++, i++)
	{
		//单趟循环，得到的集合中，取出的m个元素中必含有当前元素it，下一个循环得到的集合中，必不含有前一个循环必定会包含的元素
		//这就做到每次循环都不会有重复的集合
		//依次对剩下的元素进行取m-1个元素的递归调用
		//但是剩下的元素要满足元素个数大于等于m-1这个条件，避免无谓的递归调用
		if (it + 1 != vt.end())
		{
			vector<int> vtBack(it + 1, vt.end());
			vector<vector<int>> vtCombi1 = Combine(vtBack, m - 1);
			//加入当前元素
			for (auto &item : vtCombi1)
			{
				item.push_back(*it);
			}
			ret.insert(ret.end(), vtCombi1.begin(), vtCombi1.end());
		}
		
	}

	return ret;
}

//从集合中取m个元素进行全排，递归实现
vector<vector<int> > Arrange(vector<int> &vt, int m)
{
	vector<vector<int> > ret;
	if (vt.size() < m)
	{
		return ret;
	}

	//递归出口，当递归到m=1时，就可以确定所有的集合
	if (1 == m)
	{
		for (auto &item : vt)
		{
			vector<int> vtTemp;
			vtTemp.push_back(item);
			ret.push_back(vtTemp);
		}
		return ret;
	}

	for (auto it = vt.begin(); it != vt.end(); it++)
	{
		//取集合中的一个元素，然后让剩下的元素取m-1个元素进行全排，递归
		vector<int> vtTemp;
		//取当前元素的前面部分元素
		if (it != vt.begin())
		{
			vtTemp.insert(vtTemp.end(), vt.begin(), it);
		}
		//取当前元素的后面部分
		if (it + 1 != vt.end())
		{
			vtTemp.insert(vtTemp.end(), it + 1, vt.end());
		}
		vector<vector<int> > vtArrage = Arrange(vtTemp, m - 1);//递归，分解问题
		//把当前元素加入集合,并把集合加入结果集
		for (auto &vtSet : vtArrage)
		{
			auto itInsert = ret.insert(ret.end(), vtSet);
			itInsert->push_back(*it);//加入当前元素
		}
	}

	return ret;
}

int main(int argc, char** argv)
{
	vector<int> vt = { 1, 2, 3 ,4, 5};
	vector<vector<int>> ret = Combine(vt, 2);
	//vector<vector<int>> ret = Arrange(vt, 2);

	for (auto &vtInt : ret)
	{
		for (auto &item : vtInt)
		{
			cout << item << "";
		}
		cout << endl;
	}

	cout << "size:" << ret.size() << endl;
	return 0;
}