法一(回溯法)
public class Solution90 {
private List<List<Integer>> ans;
private List<Integer> path;
/**
* 无参构造函数
*/
public Solution90() {
this.ans = new LinkedList<>();
this.path = new LinkedList<>();
}
/**
* 回溯
* used[i - 1] == true,说明同一树支candidates[i - 1]使用过
* used[i - 1] == false,说明同一树层candidates[i - 1]使用过
* 对于组合问题,要去重的是同一树层上的“使用过”,同一树枝上的都是一个组合里的元素,不用去重
*
* @param nums
* @param start
* @param used
*/
private void backTracking(int[] nums, int start, boolean used[]) {
ans.add(new LinkedList<>(path));
for (int i = start; i < nums.length; i++) {
if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) { // 跳过同一树层使用过的元素
continue;
}
used[i] = true;
path.add(nums[i]);
backTracking(nums, i + 1, used);
path.remove(path.size() - 1);
used[i] = false;
}
}
/**
* 法一(回溯法)
* 组合问题和排列问题是在树形结构的叶子节点上收集结果,而子集问题就是取树上所有节点的结果
*
* @param nums
* @return
*/
public List<List<Integer>> subsetsWithDup(int[] nums) {
boolean used[] = new boolean[nums.length];
Arrays.sort(nums); // 先进行排序,保证重复元素挨在一起
backTracking(nums, 0, used);
return ans;
}
}
法二(动态规划)
public class Solution90 {
/**
* 法二(动态规划)
* (1)确定dp数组以及下标的含义
* dp[i]表示前i个数的解集
* (2)确定递推公式
* dp[i] = dp[i - 1] + collections(i)
* collections(i)表示把dp[i-1]的所有子集都加上第i个数形成的子集
* 例如[1,2,2],一开始解集为[[]],表示只有一个空集
* (1)遍历到1时,依次拷贝解集中所有子集,只有[],把1加入拷贝的子集中得到[1],然后加回解集中。此时解集为[[], [1]]。
* (2)遍历到第一个2时,依次拷贝解集中所有子集,有[], [1],把2加入拷贝的子集得到[2], [1, 2],然后加回解集中。此时解集为
* [[], [1], [2], [1, 2]]。
* (3)遍历到第二个2时,同理,此时解集为[[], [1], [2], [1, 2], *[2]*, *[1, 2]*, [2, 2], [1, 2, 2]]。
* *[2]*, *[1, 2]*就是第三个元素遍历以后,产生的重复部分
* 此时,curSize = 4,lastLen = 2,从curSize - lastLen开始拷贝子集即可去重
*
* @param nums
* @return
*/
public List<List<Integer>> subsetsWithDup_2(int[] nums) {
Arrays.sort(nums); // 先进行排序,保证重复元素挨在一起
List<List<Integer>> dp = new ArrayList<>();
dp.add(new ArrayList<>()); // 先将空集加入解集中
int lastLen = 1; // 上一次没有出现重复元素时,dp的长度
for (int i = 0; i < nums.length; i++) {
int curSize = dp.size(); // 当前子集数
if (i != 0 && nums[i] != nums[i - 1]) { // 更新lastLen
lastLen = curSize;
}
for (int j = curSize - lastLen; j < curSize; j++) { // 从curSize - lastLen开始遍历,避免重复
List<Integer> list = new ArrayList<>(dp.get(j)); // 拷贝子集
list.add(nums[i]); // 向拷贝的子集中加入当前数形成新的子集
dp.add(list);
}
}
return dp;
}
}
本地测试
/**
* 90. 子集 II
*/
lay.showTitle(90);
int[] nums90 = new int[]{1, 2, 2};
Solution90 sol90 = new Solution90();
List<List<Integer>> ans90_1 = sol90.subsetsWithDup(nums90);
arrayOpt.showIntLists(ans90_1);
System.out.println();
List<List<Integer>> ans90_2 = sol90.subsetsWithDup_2(new int[]{4, 4, 4, 1, 4});
arrayOpt.showIntLists(ans90_2);