[LeetCode] Subsets I (78) & II (90) 解题思路，即全组合算法

78. Subsets

Given a set of distinct integers, nums, return all possible subsets.

Note:

• Elements in a subset must be in non-descending order.
• The solution set must not contain duplicate subsets.

For example,
If nums = [1,2,3], a solution is:

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

问题： 给定一个集合，求集合元素的所有组合的情况。

实际上就是一题求全组合的题目。

nums[i...n) 的所有组合情况可以分为两种：包含nums[i] 的 和 不包含 nums[i] 的。

• 包含 nums[i] 的：nums[i] 依次加到 nums[i+1...n) 的全部情况即可。
• 不包含 nums[i] 的 ：就是 nums[i+1...n) 的全部情况。

上面的递推关系，实际上就是 DP 思路。

     vector<vector<int>> theset;

     void regardValue(int value){

         if (theset.size() == ) {
             vector<int> tmp0;
             vector<int> tmp1 = {value};
             theset.push_back(tmp0);
             theset.push_back(tmp1);
             return;
         }

         int LofPre = (int)theset.size();

         for (int i =  ; i < LofPre; i++) {
             vector<int> tmp = theset[i];
             tmp.push_back(value);
             theset.push_back(tmp);
         }
     }

     vector<vector<int>> subsets(vector<int>& nums) {

         std::sort(nums.begin(), nums.end());

         for (int i = ; i < nums.size(); i++) {
             regardValue(nums[i]);
         }

         return theset;
     }

90. Subsets II

Given a collection of integers that might contain duplicates, nums, return all possible subsets.

Note:

• Elements in a subset must be in non-descending order.
• The solution set must not contain duplicate subsets.

For example,
If nums = [1,2,2], a solution is:

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

问题：若集合中包含重复值，求所有的可能组合，即子集合。

要求：子集合内可以有重复值，但是子集合之间不可以有重复的子集合。

同样采用原来的思路，用 unordered_set<vector<int>> 代替 vector<vector<int>> ，就得最后结果后，再转为 vector<vector<int>> 即可。

在实现过程中发现 unordered_set<vector<int>> 不能直接使用。在 * 看到解法方法，增加对 vector<int> 结构进行 hash 即可使用。修改后，算法实现并通过。

     struct VectorHash {
         size_t operator()(const vector<int>& v) const {
             hash<int> hasher;
             size_t seed = ;
             for (int i : v) {
                 seed ^= hasher(i) + 0x9e3779b9 + (seed<<) + (seed>>);
             }
             return seed;
         }
     };

     vector<vector<int>> theset;

     unordered_set<vector<int>, VectorHash> uniSet;

     void regardValue(int value){

         if (uniSet.size() == ) {
             vector<int> tmp0;
             vector<int> tmp1 = {value};
             uniSet.insert(tmp0);
             uniSet.insert(tmp1);
             return;
         }

         unordered_set<vector<int>, VectorHash> cpSet = uniSet;

         unordered_set<vector<int>, VectorHash>::iterator t_iter;

         for (t_iter = cpSet.begin(); t_iter != cpSet.end(); t_iter++) {
             vector<int> tmp = *t_iter;

             tmp.push_back(value);
             uniSet.insert(tmp);
         }
     }

     vector<vector<int>> subsetsWithDup(vector<int>& nums) {

          sort(nums.begin(), nums.end());

         for (int i = ; i < nums.size(); i++) {
             regardValue(nums[i]);
         }

         unordered_set<vector<int>, VectorHash>::iterator t_iter;

         for (t_iter = uniSet.begin(); t_iter != uniSet.end(); t_iter++) {
             vector<int> tmp = *t_iter;
             theset.push_back(tmp);
         }

         return theset;

     }