全排列，组合问题

包括了排列，组合，子集问题，子集带重复问题，基本全了，就差在看看leetcode以前怎么写的了

//全排列的两种方法
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

//方法一，采用swap方法
void quanpailie(char * A,int first,int n)
{
    if(A==NULL)
    {
        cout<<"A is NULL"<<endl;
        return;
    }
    if(n<=1)
    {
        cout<<A<<endl;
        return;
    }
    for(int i=first;i<first+n;i++)
    {
        swap(A[i],A[first]);
        quanpailie(A,first+1,n-1);
        swap(A[i],A[first]);
    }
    return;
}

//采用字典序全排序，就是采用的字典排序思想，从后向前找出第一个A[i]<A[i+1]，如果没有就说明结束，
//然后在从右向左找出第一个大于A[i]的，进行交换，然后逆序i+1到最后（也就是逆序j到最后）。
void quanpailie2(char * A,int n)
{
    cout<<A<<endl;              //输出最开始的“abc”
    if(A==NULL||n<=0)
        return;
    while(true)
    {
        int i;
        for(i=n-2;i>=0;i--)
        {
            if(A[i]<A[i+1])
                break;
        }
        if(i<0)
        {
            break;
        }
        for(int k=n-1;k>=0;k--)
        {
            if(A[k]>A[i])
            {
                swap(A[i],A[k]);
                break;
            }
        }
        reverse(A+i+1,A+n);
        cout<<A<<endl;
    }
}

/*
子集问题，子集问题有两种情况，比如正常的{1,2,3}求子集就是{}，{1}，{2}，{3}，{1,2}，{1,3}，{2,3}，{1,2,3}
还有就是有重复的情况比如{1,2,2}求子集就是{}，{1}，{2}，{1,2}，{2,2}，{1,2,2}
注意区分子集问题和组合问题，组合问题为最简单的递归回溯问题1,2,3,4，选2个为{1,2}，{1,3}，{1,4}，{2,3}，{2,4}，{3,4}，{3，4}
*/

//组合问题（子集问题），方法一，采用vector,比较取巧,完全不计较空间的解法了,这个是全组合问题给你abc返回
//{}，{a}，{b}，{c},{a,b},{a,c},{b,c},{a,b,c},注意和C（n，k）的区别
//最简单情况，没有重复的方法一，{1,2,3}
void subsets(char *A ,int n,vector<vector<char>> &result)
{
    vector<char> tmp;                            //空vector
        result.push_back(tmp);
    for(int i=0;i<n;i++)
    {
        int size=result.size();                //注意，必须提前村上size，不然每次result.size()都是新的
        for(int j=0;j<size;j++)
        {
            vector<char> t=result[j];         //必须用个临时的新的，否则会更改result[j]的值。
            t.push_back(A[i]);                //注意是push_back(A[i])
            result.push_back(t);
        }
    }
    //最后result里面有一个空的
    //result.erase(result.begin());  //或者不删除也行，在显示的时候也可以不显示,但会多打出一个换行符
    /*for(int i=0;i<result.size();i++)
    {
        for(int j=0;j<result[i].size();j++)
        {
            cout<<result[i][j];
        }
        cout<<endl;
    }*/
}

//子集问题，方法二，采用递归方法,也是普通的{1,2,3,4}
void subsets2(char *A,int n,int first,vector<vector<char>> &result,vector<char> &tmp)
{
    result.push_back(tmp);
    for(int i=first;i<n;i++)
    {
        tmp.push_back(A[i]);
        subsets2(A,n,i+1,result,tmp);
        tmp.pop_back();
    }

}


//子集问题，特殊的情况处理如{1,2,2}这种情况的子集，方法一，也是迭代方法，只不过加了去重的思想

void subsets_without_repeat(char *A ,int n,vector<vector<char>> &result)
{
    sort(A,A+n);//注意必须先排序
    vector<char>tmp;
    result.push_back(tmp);
    int size,pre_size,j;
    for(int i=0;i<n;i++)
    {
        size=result.size();
        if(i-1>=0&&A[i]==A[i-1])             //如果重复了，就让j是从上次的size开始，注意初始判断i-1>=0
            j=pre_size;
        else
            j=0;
        while(j<size)
        {
            vector<char> t=result[j];
            t.push_back(A[i]);
            result.push_back(t);
            j++;
        }
        pre_size=size;                    //记录上次的size
    }
}

/*子集问题，特殊的情况处理如{1,2,2}这种情况的子集，方法二，也是采用递归方法，只不过加了去重的思想,去重的思路是{1,2,2}，
当是{}，{1}，{1,2}，{1,2,2}，tmp原来是{1,2}，然后弹出2，tmp是{1}，下一个元素是第二个2时，这个就可以跳过了，不用再有{1,2}了，然后1弹出
2入为{2}，即i！=first&&A[i]==A[i-1]就可以跳过了
*/
void  subsets_without_repeat2(char *A,int n ,int first,vector<vector<char>> & result,vector<char> & tmp)
{
    result.push_back(tmp);
    for(int i=first;i<n;i++)
    {
        if(i!=first&&i-1>=0&&A[i]==A[i-1])
            continue;
        tmp.push_back(A[i]);
        subsets_without_repeat2(A,n,i+1,result,tmp);
        tmp.pop_back();
    }
}


/*
组合问题，C（n，k）问题，很容易，用递归回溯的典型，1,2,3,4 ，给定n为4，k=2,则{1,2}，{1,3}，{1,4}，{2,3}，{2,4}，{3,4}
*/
void compose(char *A,int n,int start,int dep,vector<vector<char>> &result,vector<char> &tmp)
{
    if(A==NULL||n<=0)
        return;
    if(dep==2)
    {
        result.push_back(tmp);
        return;
    }
    for(int i=start;i<n;i++)
    {
        tmp.push_back(A[i]);
        compose(A,n,i+1,dep+1,result,tmp);
        tmp.pop_back();
    }
}

int main()
{
    char A[]="1234";
    vector<vector<char>> result;
    vector<char> tmp;
    //quanpailie(A,0,4);
    //quanpailie2(A,4);
    //subsets(A,3,result);
    //subsets2(A,4,0,result,tmp);
    //subsets_without_repeat(A,3,result);
    //subsets_without_repeat2(A,3,0,result,tmp);
    compose(A,4,0,0,result,tmp);
    for(int i=0;i<result.size();i++)
    {
        for(int j=0;j<result[i].size();j++)
        {
            cout<<result[i][j];
        }
        cout<<endl;
    }
    system("pause");
}