491.递增子序列
- 标签:递归、回溯
- 难度:8.0
和子集II的区别有:
- 虽然遍历每个节点还是要把path加入到res里,但是这次要判断path的长度,大于等于2才能加
- 数组不是递增有序,所以对于continue条件的判断,增加了是否小于前一个元素
- used数组记录同层兄弟是否访问过,每一层都会有一个新的,所以不需要回溯
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> findSubsequences(int[] nums) {
backTracking(nums,0);
return res;
}
public void backTracking(int[] nums, int startIndex){
if(path.size() >= 2){
res.add(new ArrayList<>(path));
}
boolean[] used = new boolean[201];
for(int i = startIndex; i < nums.length; i++){
if(path.size() > 0 && nums[i] < path.get(path.size() - 1) || used[nums[i] + 100]){
continue;
}
path.add(nums[i]);
used[nums[i] + 100] = true;
backTracking(nums, i+1);
path.remove(path.size() - 1);
//没有对used的回溯,因为每一层要创建一个新的空used
}
}
46.全排列
- 标签:递归、回溯
- 难度:7.5
排列问题的不同:
- 每层都是从0开始搜索而不是startIndex
- 需要used数组记录path里都放了哪些元素了
List<List<Integer>> result = new ArrayList<>();// 存放符合条件结果的集合
LinkedList<Integer> path = new LinkedList<>();// 用来存放符合条件结果
boolean[] used;
public List<List<Integer>> permute(int[] nums) {
if (nums.length == 0){
return result;
}
used = new boolean[nums.length];
permuteHelper(nums);
return result;
}
private void permuteHelper(int[] nums){
if (path.size() == nums.length){
result.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < nums.length; i++){
if (used[i]){
continue;
}
used[i] = true;
path.add(nums[i]);
permuteHelper(nums);
path.removeLast();
used[i] = false;
}
}
47.全排列II
- 标签:递归、回溯
- 难度:8.0
要去重,但是此题树枝去重和树层去重都是可以的。
List<List<Integer>> result = new ArrayList<>();
//暂存结果
List<Integer> path = new ArrayList<>();
public List<List<Integer>> permuteUnique(int[] nums) {
boolean[] used = new boolean[nums.length];
Arrays.fill(used, false);
Arrays.sort(nums);
backTrack(nums, used);
return result;
}
private void backTrack(int[] nums, boolean[] used) {
if (path.size() == nums.length) {
result.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < nums.length; i++) {
// used[i - 1] == true,说明同⼀树⽀nums[i - 1]使⽤过
// used[i - 1] == false,说明同⼀树层nums[i - 1]使⽤过
// 如果同⼀树层nums[i - 1]使⽤过则直接跳过
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
}
//如果同⼀树⽀nums[i]没使⽤过开始处理
if (used[i] == false) {
used[i] = true;//标记同⼀树⽀nums[i]使⽤过,防止同一树枝重复使用
path.add(nums[i]);
backTrack(nums, used);
path.remove(path.size() - 1);//回溯,说明同⼀树层nums[i]使⽤过,防止下一树层重复
used[i] = false;//回溯
}
}
}