全排列和全组合实现
全排列
所谓全排列，就是打印出字符串中所有字符的所有排列。例如输入字符串abc，则打印出 a、b、c 所能排列出来的所有字符串 abc、acb、bac、bca、cab 和 cba 。
一般最先想到的方法是暴力循环法，即对于每一位，遍历集合中可能的元素，如果在这一位之前出现过了该元素，跳过该元素。例如对于abc，第一位可以是 a 或 b 或 c 。当第一位为 a 时，第二位再遍历集合，发现 a 不行，因为前面已经出现 a 了，而 b 和 c 可以。当第二位为 b 时 ， 再遍历集合，发现 a 和 b 都不行，c 可以。可以用递归或循环来实现，但是复杂度为 O(nn) 。有没有更优雅的解法呢。
首先考虑bac和cba这二个字符串是如何得出的。显然这二个都是abc中的 a 与后面两字符交换得到的。然后可以将abc的第二个字符和第三个字符交换得到acb。同理可以根据bac和cba来得bca和cab。
因此可以知道 全排列就是从第一个数字起每个数分别与它后面的数字交换，也可以得出这种解法每次得到的结果都是正确结果，所以复杂度为 O(n!)。找到这个规律后，递归的代码就很容易写出来了：
#include
#include
//交换两个字符
void Swap(char *a ,char *b)
{
char temp = *a;
*a = *b;
*b = temp;
}
//递归全排列，start 为全排列开始的下标， length 为str数组的长度
void AllRange(char* str,int start,int length)
{
if(start == length-1)
{
printf("%s\n",str);
}
else
{
for(int i=start;i<=length-1;i++)
{ //从下标为start的数开始，分别与它后面的数字交换
Swap(&str[start],&str[i]);
AllRange(str,start+1,length);
Swap(&str[start],&str[i]);
}
}
}
void Permutation(char* str)
{
if(str == NULL)
return;
AllRange(str,0,strlen(str));
}
void main()
{
char str[] = "abc";
Permutation(str);
}
#include
#include
using namespace std;
//交换
template
void Swap(T &a ,T &b)
{
T temp = a;
a = b;
b = temp;
}
template
void ALLRange(vector &v, int cur, const int size, vector> &result){
if(cur==size-1){
result.push_back(v);
return;
}else{
for(int i=cur; i<=size-1; i++){
//从下标为cur的元素开始，分别与它后面的元素交换
Swap(v[cur],v[i]);
ALLRange(v,cur+1,size,result);
Swap(v[cur],v[i]);
}
}
return;
}
template
void Permutation(const vector &v, vector> &result){
vector v2(v);
if(v.empty()){
return;
}else if(v.size()==1){
result.push_back(v);
}else{
ALLRange(v2, 0, v2.size(), result);
}
}
int main(int argc, char *argv[])
{
vector v{1,2,3};
vector> result;
Permutation(v,result);
for(auto a:result){
for(auto b:a){
cout< 类似题目：
1、输入一个含有8个数字的数组，判断有么有可能把这8个数字分别放到正方体的8个顶点上，使得正方体上三组相对的面上的4个顶点的和相等。
思路：相当于求出8个数字的全排列，判断有没有一个排列符合题目给定的条件，即三组对面上顶点的和相等。
2、N皇后问题：在8 X 8的国际象棋上摆放八个皇后，使其不能相互攻击，即任意两个皇后不得处于同一行，同一列或者同意对角线上，求出所有符合条件的摆法。
思路：由于8个皇后不能处在同一行，那么肯定每个皇后占据一行，这样可以定义一个数组A[8]，数组中第i个数字，即A[i]表示位于第i行的皇后的列号。先把数组A[8]分别用0-7初始化，接下来对该数组做全排列，由于我们用0-7这7个不同的数字初始化数组，因此任意两个皇后肯定也不同列，那么我们只需要判断每个排列对应的8个皇后中是否有任意两个在同一对角线上即可，即对于数组的两个下标i和j，如果i-j==A[i]-A[j]或i-j==A[j]-A[i]，则认为有两个元素位于了同一个对角线上，则该排列不符合条件。
去重的全排列
为了得到不一样的排列，可能我们最先想到的方法是当遇到和自己相同的就不交换了。如果我们输入的是abb，那么第一个字符与后面的交换后得到 bab、bba。然后abb中，第二个字符和第三个就不用交换了。但是对于bab，它的第二个字符和第三个是不同的，交换后得到bba，和之前的重复了。因此，这种方法不行。
因为abb能得到bab和bba，而bab又能得到bba，那我们能不能第一个bba不求呢？ 我们有了这种思路，第一个字符a与第二个字符b交换得到bab，然后考虑第一个字符a与第三个字符b交换，此时由于第三个字符等于第二个字符，所以它们不再交换。再考虑bab，它的第二个与第三个字符交换可以得到bba。此时全排列生成完毕，即abb、bab、bba三个。
这样我们也得到了在全排列中去掉重复的规则：去重的全排列就是当str[i]与str[j]交换时，判断[i,j)中是否有与str[j]相同的元素，如果有则跳过此次交换，否则执行交换。下面给出完整代码：
#include
#include
//交换两个字符
void Swap(char *a ,char *b)
{
char temp = *a;
*a = *b;
*b = temp;
}
//在 str 数组中，[start,end) 中是否有与 str[end] 元素相同的
bool IsSwap(char* str,int start,int end)
{
for(;start #include
#include
using namespace std;
//交换
template
void Swap(T &a ,T &b)
{
T temp = a;
a = b;
b = temp;
}
//判断在v[start,end) 中是否有与 v[end] 元素相同的元素。如果有则返回false,没有则返回true
template
bool IsSwap(const vector &v, int start, int end){
for(int i=start; i
void ALLRange(vector &v, int cur, const int size, vector> &result){
if(cur==size-1){
result.push_back(v);
return;
}else{
for(int i=cur; i<=size-1; i++){
if(IsSwap(v,cur,i)){
//从下标为cur的元素开始，分别与它后面的元素交换
Swap(v[cur],v[i]);
ALLRange(v,cur+1,size,result);
Swap(v[cur],v[i]);
}
}
}
return;
}
template
void Permutation(const vector &v, vector> &result){
vector v2(v);
if(v.empty()){
return;
}else if(v.size()==1){
result.push_back(v);
}else{
ALLRange(v2, 0, v2.size(), result);
}
}
int main(int argc, char *argv[])
{
vector v{1,2,2};
vector> result;
Permutation(v,result);
for(auto a:result){
for(auto b:a){
cout<
全组合
如果不是求字符的所有排列，而是求字符的所有组合应该怎么办呢？还是输入三个字符 a、b、c，则它们的组合有a b c ab ac bc abc。当然我们还是可以借鉴全排列的思路，利用问题分解的思路，最终用递归解决。不过这里介绍一种比较巧妙的思路 —— 基于位图。
假设原有元素 n 个，则最终组合结果是 2^n−1 个。我们可以用位操作方法：假设元素原本有：a,b,c 三个，则 1 表示取该元素，0 表示不取。故取a则是001，取ab则是011。所以一共三位，每个位上有两个选择 0 和 1。而000没有意义，所以是2^n−1个结果。
这些结果的位图值都是 1,2…2^n-1。所以从值 1 到值 2^n−1 依次输出结果：
001,010,011,100,101,110,111 。对应输出组合结果为：a,b,ab,c,ac,bc,abc。
因此可以循环 1~2^n-1，然后输出对应代表的组合即可。有代码如下：
#include
#include
void Combination(char *str)
{
if(str == NULL)
return ;
int len = strlen(str);
int n = 1< #include
#include
using namespace std;
//求全组合，对于长度为n的v，组合的种类数一共有2^n-1种
/*
参数:
v是基础元素集合
result用于保存所有组合结果
*/
template
void Combination(const vector &v, vector> &result)
{
if(v.empty()){
return;
}else if(v.size()==1){
result.push_back(v);
return;
}
int size = v.size();
int n = 1< temp_v;
for(int j=0; j v{1,2,3};
vector> result;
Combination(v,result);
for(auto &a:result){
for(auto &b:a){
cout< 递归解法：
假设我们想在长度为n的元素集合中求m个元素的组合。我们先从头扫描元素集合的第一个元素。针对第一个元素，我们有两种选择：第一是把这个元素放到组合中去，接下来我们需要在剩下的n-1个元素中选取m-1个字符；第二是不把这个元素放到组合中去，接下来我们需要在剩下的n-1个元素中选择m个元素。这两种选择都很容易用递归实现。下面是这种思路的参考代码：
#include
#include
using namespace std;
//求长度为number的组合
/*
参数：
v：基础元素集合
cur_v：当前递归过程中的中间组合变量
cur_index:当前递归处理到v中第几个元素了
number:要求的组合的长度值
result:用于保存组合结果
*/
template
void Combination_n(const vector &v,vector &cur_v, int cur_index, int number, vector> &result){
if(number==0){
result.push_back(cur_v);
return;
}
if(cur_index>=v.size()){
return;
}
cur_v.push_back(v[cur_index]);
Combination_n(v,cur_v,cur_index+1,number-1,result);
cur_v.pop_back();
Combination_n(v,cur_v,cur_index+1,number,result);
}
//求全组合，对于长度为n的v，组合的种类数一共有2^n-1种
/*
参数:
v是基础元素集合
result用于保存所有组合结果
*/
template
void Combination(const vector &v, vector> &result)
{
if(v.empty()){
return;
}else if(v.size()==1){
result.push_back(v);
return;
}
//求不同长度的组合
vector temp_v;
for(int i=1; i<=v.size(); ++i){
Combination_n(v,temp_v,0,i,result);
}
}
int main(int argc, char *argv[])
{
vector v{1,2,3};
vector> result;
Combination(v,result);
for(auto &a:result){
for(auto &b:a){
cout<
参考文献：
https://www.cnblogs.com/zengshangzhi/p/9305534.html
http://wuchong.me/blog/2014/07/28/permutation-and-combination-realize/