[LintCode] 17 & 18 解题思路与方法 SubSets & SubSets II （付Quick Sort 代码）

我的所有文章， 跪求拍砖！

Subsets
给定一个含不同整数的集合，返回其所有的子集。
子集中的元素排列必须是非降序的，解集必须不包含重复的子集。

Subsets II
给定一个可能具有重复数字的列表，返回其所有可能的子集。

子集中的每个元素都是非降序的
两个子集间的顺序是无关紧要的
解集中不能包含重复子集

分析一下区别， 唯一的区别就是2 元素有可能有重复， 1 元素排列是非降序的

思路：（这思路上我的理解算 动态规划DP， 不是特别确定所以 欢迎拍砖）

1 先排序 （保证相同的元素会在一起（2），也保证元素是非降序的（1））
2 在结果List中加入空List
3 遍历给的数组 （以下叫 currentNum)， 对于每个新的数字， 遍历结果数组 (以下叫resultOne)，依次append。

在subset II中，对duplicate元素的处理非常的tricky。 为了避免重复子集，会维护一个与result相对应的Index
队列（resultIndexs)。 遇到currentNum == lastCurrentNum 的时候只加resultOneIndex为lastCurrentNum Index的子集。
这里其实就是加上一次循环加入的子集（看下边的例子）

比如 1，2，2
以下是每次遍历新加的子集
初始：[[]]
遍历1 的时候[[1]]
遍历第一个2的时候 [[2], [1,2]]
遍历第二个2的时候 [[2,2],[1,2,3]]

废话说太多，上代码

public class Solution {  //Subset
    /**
     * @param nums: A set of numbers
     * @return: A list of lists
     */
    public List<List<Integer>> subsets(int[] nums) {
        Arrays.sort(nums);
        System.out.println(Arrays.toString(nums));
        List<List<Integer>> result = new ArrayList<>();
        result.add(new ArrayList<Integer>());
        for (int i = 0; i < nums.length; i++) {
            int size = result.size();
            for (int j = 0; j < size; j++) {
                
                result.add(new ArrayList<Integer>(result.get(j)));   
                //这里要小心，ArrayList是Object, 直接加就会联动，所以这里加的只是value，new 一个列表
                result.get(result.size()-1).add(nums[i]);
            }
        }
        return result;
         // write your code here
    }
    }

-------分割线----------------

public class Solution {   //subset II
    /**
     * @param nums: A set of numbers.
     * @return: A list of lists. All valid subsets.
     */
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> indexs = new ArrayList<>();
        indexs.add(-1);
        result.add(new ArrayList<Integer>());
        if (nums.length == 0) {
            return result;
        }
        sort(nums);
        helper(nums, 0, result, indexs);
        //sort(nums);
        return result;
        // write your code here
    }
    
    //这是递归方法， 非递归把startIndex 做在loop里就好啦
    private void helper(int[] nums, int startIndex, List<List<Integer>> subset, List<Integer> indexs) {
            int size = subset.size();
            for (int i = 0; i < size; i++) {
                List<Integer> current = subset.get(i);
                if (startIndex > 0 && nums[startIndex] == nums[startIndex -1] && indexs.get(i) != startIndex - 1){
                    continue;
                }
                subset.add(new ArrayList<Integer>(subset.get(i)));
                 //这里要小心，ArrayList是Object, 直接加就会联动，所以这里加的只是value，new 一个列表
                subset.get(subset.size()-1).add(nums[startIndex]);
                indexs.add(startIndex);
            }
        if (startIndex >= 0 && startIndex < nums.length-1) {
            helper(nums, startIndex+1, subset, indexs);
        }
    }
    
    //Quick sort 练练手
    private void sort(int[] nums) {
        sortHelper(nums, 0, nums.length-1);
    }
    
    private void sortHelper(int[] nums, int start, int end) {
        if (start > end) {
            return;
        }
        int indexStart = start;
        int indexEnd = end;
        int pivot = nums[end];
        
        while (indexStart < indexEnd) {
            while (indexStart < indexEnd && nums[indexStart] < pivot) {
                indexStart++;
            }
            while (indexStart < indexEnd && nums[indexEnd] >= pivot) {
                indexEnd--;
            }
            if (indexStart < indexEnd) {
                int temp = nums[indexStart];
                nums[indexStart] = nums[indexEnd];
                nums[indexEnd] = temp;
            }
        }
        int temp1 = nums[end];
        nums[end] = nums[indexEnd];
        nums[indexEnd] = temp1;
        sortHelper(nums, start, indexEnd -1);
        sortHelper(nums, indexEnd + 1, end);
    }    
}