数组的全排列和全子集

给定一个数组，求数组的全排列和全子集，暴力枚举法。

1，求不含重复元素的数组的全排列

  vector<vector<int>> permute(vector<int>& nums) {
       
        vector<vector<int>> result;
        if(nums.size()==0)
           return result;
        //中间结果
        vector<int> path;
        permute(nums,path,result);
        
        return result;
        
    }
    
    void permute(vector<int>&nums,vector<int>&path,vector<vector<int>> & result)
    {
       //收敛条件
       if(path.size()==nums.size())
       {
           result.push_back(path);
           return ;
       }
        
        for(auto i:nums)
        {
            //i在path中没有出现过就放到path中
            auto pos=find(path.begin(),path.end(),i);
            if(pos==path.end())
            {
                path.push_back(i);
                permute(nums,path,result);
                path.pop_back();
            }
        }
    }

2.求含有重复元素的全排列，比如[1,2,2] 的全排列只有[1,2,2] ,[2,1,2] ,[2,2,1]。

    size_t n;
    void permute(std::vector<pair<int,int>>::iterator first,std::vector<pair<int,int>>::iterator last,
                 vector<int>& path,vector<vector<int>> &result)
    {
        //收敛条件
        if(n==path.size())
        {
            result.push_back(path);
            return;
        }
        for(auto i=first;i!=last;i++)
        {
            //统计ele在path中出现的次数
            int count=0;
            for(auto j=path.begin();j!=path.end();j++)
            {
                if(*j==i->first)
                    count++;
            }
            
            if(count<i->second)
            {
                path.push_back(i->first);
                permute(first,last,path,result);
                path.pop_back();//撤销动作，返回上一层
            }
        }
    }
    vector<vector<int>> permuteUnique(vector<int>& nums) {
        //记录每个元素出现的次数
        unordered_map<int,int> ele_count;
        for(int i=0;i<nums.size();i++)
        {
            if(ele_count.find(nums[i])!=ele_count.end())
                ele_count[nums[i]]++;
            else
                ele_count[nums[i]]=1;
        }
        
        //将ele_count放到一个vector中
        vector<pair<int,int>> elems;
        for_each(ele_count.begin(),ele_count.end(),[&elems](const pair<int,int> &e){elems.push_back(e);});
        
        vector<vector<int>> result;
        vector<int> path;
        
        n=nums.size();
        permute(elems.begin(),elems.end(),path,result);
        return result;
    }

3.求不含重复元素的数组的子集（含空子集）

    void subsets(vector<int>& nums,vector<int>& path,vector<vector<int>>& result,int step)
    {
        if(step==nums.size())
        {
            result.push_back(path);
            return ;//不能忘
        }
        
        subsets(nums,path,result,step+1);
        path.push_back(nums[step]);
        subsets(nums,path,result,step+1);
        
        path.pop_back();//返回之前要要删除元素
        return;
    }



     vector<vector<int>> subsets(vector<int>& nums) {
        //sort(nums.begin(),nums.end());
        vector<vector<int> > result;
        if(nums.size()==0)
            return result;
        vector<int>path;
        subsets(nums,path,result,0);
        return result;
    }
    
   

4.求含重复元素的数组的子集

    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
        //必须先排序
        sort(nums.begin(),nums.end());
        
        vector<vector<int>> result(1);//加入空子集
        int pre_size=0;//记录前一个result的大小
        for(int i=0;i<nums.size();i++)
        {
            int size=result.size();
            for(int j=0;j<size;j++)
            {
                //当是nums的第一个元素时，或前后连个元素不等时，或前后两元素相等但size不等时
                if(i==0||nums[i]!=nums[i-1]||j>=pre_size)
                {
                    result.push_back(result[j]);
                    result.back().push_back(nums[i]);
                }
            }
            pre_size=size;
        }
        return result;
    }