#LeetCode 491. Non-decreasing Subsequences
#LeetCode 491. 视频讲解:回溯算法精讲,树层去重与树枝去重 | LeetCode:491.递增子序列_哔哩哔哩_bilibili
首先,本题不能考虑首先对数组排序,排序会导致数组直接变为一个递增的序列。本题依然是一个组合问题,所以无序,i 在for loop中依然是从startIndex 开始。与之前的去重逻辑不同,每一层会有一个uset 变量,是记录本层元素是否重复使用,新的一层uset都会重新定义,不是之前去重那样的全局变量,同样回溯的时候也不需要删除元素,也是在树层去重。
代码:
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> findSubsequences(int[] nums) {
backtracking(nums, 0);
return result;
}
public void backtracking(int[] nums, int startIndex) {
if (startIndex > nums.length) {
return;
}
if (path.size() > 1) {
result.add(new ArrayList<>(path));
}
HashSet<Integer> uset = new HashSet<>();
for (int i = startIndex; i < nums.length; i++) {
if (!path.isEmpty() && path.getLast() > nums[i] || uset.contains(nums[i])) {
continue;
}
uset.add(nums[i]);
path.addLast(nums[i]);
backtracking(nums, i + 1);
path.removeLast();
}
}
}
#LeetCode 46. Permutations
#LeetCode 46. 视频讲解:组合与排列的区别,回溯算法求解的时候,有何不同?| LeetCode:46.全排列_哔哩哔哩_bilibili
与之前的组合问题不同的地方在于,排列是有序的,[1, 2] 和[2, 1] 是不同的,如果用used 数组,那么在for loop 遍历的时候也是通过used 数组的标记,来判断下一次取具体哪一个数字。
回溯方法代码:
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> permute(int[] nums) {
boolean[] used = new boolean[nums.length];
Arrays.fill(used, false);
backtracking(nums, used);
return result;
}
public void backtracking(int[] nums, boolean[] used) {
if (path.size() == nums.length) {
result.add(new LinkedList<>(path));
return;
}
for (int i = 0; i < nums.length; i++) {
if (used[i]) {
continue;
}
used[i] = true;
path.addLast(nums[i]);
backtracking(nums, used);
used[i] = false;
path.removeLast();
}
}
}
#LeetCode 47. Permutations II
#LeetCode 47. 视频讲解:回溯算法求解全排列,如何去重?| LeetCode:47.全排列 II_哔哩哔哩_bilibili
如果完成了之前的题目,那么这个题目较简单,排列的思想与上一个题目相似,去重与之前组合去重相似,记得数组需要排序。
回溯方法代码:
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> permuteUnique(int[] nums) {
boolean[] used = new boolean[nums.length];
Arrays.fill(used, false);
Arrays.sort(nums);
backtracking(nums, used);
return result;
}
public void backtracking(int[] nums, boolean[] used) {
if (path.size() == nums.length) {
result.add(new LinkedList<>(path));
return;
}
for (int i = 0; i < nums.length; i++) {
if (i > 0 && nums[i] == nums[i-1] && !used[i-1]) {
continue;
}
if (used[i]) {
continue;
}
path.addLast(nums[i]);
used[i] = true;
backtracking(nums, used);
used[i] = false;
path.removeLast();
}
}
}