我的所有文章, 跪求拍砖!
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);
}
}