排列组合专题

用回溯法求解。

 1. Permutations

    vector<vector<int> > permute(vector<int> &num) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        vector<vector<int>> res;
        if(num.empty())
            return res;
        vector<bool> bvisited(num.size(),false);
        vector<int> permu;
        dfs(0,num,bvisited,permu,res);
        return res;
        
    }
    
    void dfs(int cnt,vector<int>& num,vector<bool>& bvisited,vector<int>& permu,vector<vector<int>>& res)
    {
        if(cnt == num.size())
        {
            res.push_back(permu);
            return;
        }
        for(int i=0;i<num.size();i++)
        {
            if(!bvisited[i])
            {
                bvisited[i] = true;
                permu.push_back(num[i]);
                dfs(cnt+1,num,bvisited,permu,res);
                permu.pop_back();
                bvisited[i] = false;
            }
        }
    
    }

　　

2.Permutations II

 

    vector<vector<int> > permuteUnique(vector<int> &num) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        sort(num.begin(),num.end());
        vector<vector<int>> res;
        vector<int> permu;
        vector<bool> bvisited(num.size(),false);
        dfs(num,bvisited,permu,res);
        return res;
    }
    
    void dfs(vector<int>& num,vector<bool>& bvisited,vector<int>& permu,vector<vector<int>>& res)
    {
        if(permu.size()==num.size())
        {
            res.push_back(permu);
            return;
        }
        
        for(int i=0;i<num.size();i++)
        {
            if(bvisited[i]||(i>0&&num[i]==num[i-1]&&!bvisited[i-1]))
                continue;
            bvisited[i] = true;
            permu.push_back(num[i]);
            dfs(num,bvisited,permu,res);
            permu.pop_back();
            bvisited[i] = false;
        }
        
    }

　　

 3.Combinations  C(n,k)

    vector<vector<int> > combine(int n, int k) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        vector<vector<int>> res;
        vector<int> path;
        construct(1,n,k,path,res);
        return res;
        
    }
    
    void construct(int pos,int& n,int k,vector<int>& path,vector<vector<int>>& res)
    {
        if(k==0)
        {
            res.push_back(path);
            return;
        }
        if(n-pos+1<k)
            return;
        path.push_back(pos);
        construct(pos+1,n,k-1,path,res);
        path.pop_back();
        construct(pos+1,n,k,path,res);
    }

　　4.Combination Sum

    vector<vector<int> > combinationSum(vector<int> &candidates, int target) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        sort(candidates.begin(),candidates.end());
        vector<vector<int> > res;
        vector<int> comb;
        
        dfs(0,target,candidates,comb,res);
        return res;
    }
    
    void dfs(int pos,int target,vector<int>& candidates,vector<int>& comb, vector<vector<int>>& res)
    {
        if(target==0)
        {
            res.push_back(comb);
            return;
        }
        if(target<0)
            return;
        if(pos<candidates.size())
        {
            comb.push_back(candidates[pos]);
            dfs(pos,target-candidates[pos],candidates,comb,res);  //select candidates[pos];
            comb.pop_back();
            dfs(pos+1,target,candidates,comb,res);  //not selected
        }
    }

　

　5. Combination Sum II

 

    vector<vector<int> > combinationSum2(vector<int> &num, int target) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        sort(num.begin(),num.end());
        vector<vector<int>> res;
        vector<int> comb;
        dfs(0,target,comb,res,num);
        return res;
    }
    
    void dfs(int pos,int sum,vector<int>& comb,vector<vector<int>>& res,vector<int> &num)
    {
        if(sum==0)
        {
            res.push_back(comb);
            return;
        }
        
        if(sum<0||pos==num.size())
            return;
        for(int i=pos;i<num.size();i++)
        {
            if(i>pos&&num[i]==num[i-1])
                continue;
            comb.push_back(num[i]);
            dfs(i+1,sum-num[i],comb,res,num);
            comb.pop_back();
        }
        
    }

　　

6. Subsets II

    vector<vector<int> > subsetsWithDup(vector<int> &S) {
        // Note: The Solution object is instantiated only once and is reused by each test case.
        vector<vector<int>> res;
        vector<int> subset;
        sort(S.begin(),S.end());
        dfs(0,S,subset,res);
        return res;
    }
    
    void dfs(int curpos,vector<int>& S,vector<int>& subset,vector<vector<int>>& res)
    {
        
        res.push_back(subset);

        for(int i=curpos;i<S.size();i++)
        {
            if(i>curpos&&S[i]==S[i-1])
                continue;
            subset.push_back(S[i]);
            dfs(i+1,S,subset,res);
            subset.pop_back();
        }
    }