491.递增子序列
关键点1:将path加入res,结果是除开size<2的所有节点(path.size() > 1 );
关键点2:终止条件可要可不要,因为下面的循环也会终止;
关键点3:continue的几个条件;
3-1:nums[i] < path最后一个值,不加;
3-2:set 里曾经有过这个值了,不加,实现了树层去重;
关键点4:set.add(nums[i]);加入,递归,弹出,set不用再弹出,是因为set每层会新建新的set。
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> findSubsequences(int[] nums) {
backStracking(nums,0);
return res;
}
public void backStracking(int[] nums,int starIndex){
if(path.size() > 1){
res.add(new ArrayList<>(path));
}
// 终止条件
if(starIndex >= nums.length){
return;
}
// 单层循环条件
HashSet<Integer> set = new HashSet<>();
for(int i = starIndex;i < nums.length;i++){
// nums[i] < path最后一个值,不加;
// set里曾经有过这个值了,不加,实现了树层去重;
if(!path.isEmpty() && nums[i] < path.get(path.size()-1) ||set.contains(nums[i])){
continue;
}
set.add(nums[i]);
path.add(nums[i]);
backStracking(nums,i+1);
path.remove(path.size()-1);
}
}
}
46.全排列
关键点1:当path的长度等于这个原始数组的长度则证明到了根节点;
关键点2:单层循环条件可以从0开始,因为排列问题,1,2和2,1是两个排列,之前使用过的元素不再使用,用used来排除;
关键点3:used[i] = 1,添加,递归,used[i] = 0,弹出。
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> permute(int[] nums) {
int[] used = new int[nums.length];
backStacking(nums,used);
return res;
}
public void backStacking(int[] nums,int[] used){
// 结束条件
if(path.size() == nums.length){
res.add(new ArrayList<>(path));
return;
}
// 单层循环条件
for(int i = 0; i < nums.length;i++){
// 使用过的元素不再使用
if(used[i] == 1){
continue;
}
used[i] = 1;
path.add(nums[i]);
backStacking(nums,used);
used[i] = 0;
path.remove(path.size() - 1);
}
}
}
47.全排列 II
关键点1:当path的长度等于这个原始数组的长度则证明到了根节点;
关键点2:单层循环条件可以从0开始,因为排列问题,1,2和2,1是两个排列,之前使用过的元素不再使用,用used来排除;
关键点3:与全排列问题的区别在于,它有重复元素,需要用树层去重,用 i>0 && nums[i] == nums[i - 1] && used[i-1] == 0 进行树层去重
关键点3:used[i] = 1,添加,递归,used[i] = 0,弹出。
class Solution {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> permuteUnique(int[] nums) {
Arrays.sort(nums);
int[] used = new int[nums.length];
backStracking(nums,used);
return res;
}
public void backStracking(int[] nums,int[] used){
// 结束条件
if(path.size()==nums.length){
res.add(new ArrayList<>(path));
return;
}
// 单层循环条件
for(int i = 0;i < nums.length;i++){
// 树层去重
if(i>0 && nums[i] == nums[i - 1] && used[i-1] == 0){
continue;
}
// 使用过的元素不再使用
if(used[i] == 1){
continue;
}
used[i] = 1;
path.add(nums[i]);
backStracking(nums,used);
path.remove(path.size() - 1);
used[i] = 0;
}
}
}