LeetCode 491.递增子序列
本题需要注意以下几点:
1.题目中要求的递增子序列是在原数组的基础上,不能对原数组进行排序,否则求出来的子序列都是递增的,和leetcode90题就没有区别了;
2.如何对子序列去重,和之前的回溯一样,需要用到startIndex来控制下一次循环的起始位置,此外,对于同一层的元素,如果访问过了则不能再加入子序列,这里可以用哈希表进行处理。
代码如下:(上述两个坑都踩了一遍)
//leetcode submit region begin(Prohibit modification and deletion)
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(path.size() >= 2){
result.add(new ArrayList(path));
}
HashSet<Integer> hs = new HashSet<>();
for(int i=startIndex; i< nums.length; i++){
if(path.size() != 0 && path.get(path.size()-1) > nums[i] || hs.contains(nums[i])){
continue;
}
// 满足要求,将访问过的元素加入hashset
hs.add(nums[i]);
path.add(nums[i]);
backtracking(nums, i+1);
path.removeLast();
}
}
}
//leetcode submit region end(Prohibit modification and deletion)
LeetCode 46.全排列
全排列问题是大家比较熟悉的数学问题,这里依然采用startIndex来控制每次循环的起始位置,但与之前不同的是,这里的循环每次都需要执行nums.length次,每个数字都要取到,同时取过的元素就不能再取了,所以可以先判断一下nums[i]在不在path中,在的话就continue。代码如下:
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> permute(int[] nums) {
backtracking(nums,0);
return result;
}
public void backtracking(int[] nums, int start){
if(path.size() == nums.length){
result.add(new ArrayList(path));
return;
}
for(int i=start; i-start< nums.length; i++){
if(path.contains(nums[i%nums.length])) continue;
path.add(nums[i%nums.length]);
backtracking(nums, (i+1)%nums.length);
path.removeLast();
}
}
}
//leetcode submit region end(Prohibit modification and deletion)
LeetCode 47.全排列 II
本题最开始的思路想要仿照上题,使用start来去重,想避免使用used数组来存储状态,最终发现用start循环数组取数会破坏数组的部分有序,实在是没写出来。看了题解后,发现使用used数组也没想象中那么难,可能之前习惯了使用start所以对相对陌生的used数组有些抗拒。
本题与上题的不同在于数组中会有重复的元素,但我们最后要求的是不重复的全排列,可以用used数组来存储数组元素状态,先对nums数组排序,used[i-1] == false说明同一层i-1使用过,used[i-1] == true说明同一树枝使用过,而明显我们需要处理的是同层去重,即used[i-1] == false,虽然使用used[i-1] == true也同样能做出来,但是树的宽度和深度都会变大,时间花销不划算。代码如下:
//leetcode submit region begin(Prohibit modification and deletion)
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> permuteUnique(int[] nums) {
Arrays.sort(nums);
boolean[] used = new boolean[nums.length];
backtracking(nums,used);
return result;
}
public void backtracking(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] == false说明同一层i-1使用过
// used[i-1] == true说明同一树枝使用过
if(i>0 && nums[i] == nums[(i-1)] && used[i-1] == false) continue;
if(used[i] == false){
// 未使用过
used[i] = true;
path.add(nums[i]);
backtracking(nums,used);
path.removeLast();
used[i] = false;
}
}
}
}
//leetcode submit region end(Prohibit modification and deletion)
树层去重,used[i-1] == false时树的情况:
树枝去重,used[i-1] == true时树的情况: