学习目标:
- 491.递增子序列
- 46.全排列
- 47.全排列 II
学习内容:
491.递增子序列
题目:给定一个整型数组, 你的任务是找到所有该数组的递增子序列,递增子序列的长度至少是2。
利用hashset完成去重,for中if条件是当path中最后一位元素大于当前遍历的元素或当前遍历的元素已经存在path中时跳过该循环
先将元素加入到hs中,再加入到path中(hs是每进一次方法就会刷新一次)
去重操作2:可以用hashmap,元素是键,出现次数是值
class Solution {
List<List<Integer>> result = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> findSubsequences(int[] nums) {
backTracking(nums, 0);
return result;
}
private 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.isEmpty() && path.get(path.size() -1 ) > nums[i] || hs.contains(nums[i]))
continue;
hs.add(nums[i]);
path.add(nums[i]);
backTracking(nums, i + 1);
path.remove(path.size() - 1);
}
}
}
46.全排列
题目:给定一个 没有重复 数字的序列,返回其所有可能的全排列。
直接在path中对比是否存在遍历的元素若出现就直接跳过
在储存时linkedlist转为arraylist更节约内存
class Solution {
List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> permute(int[] nums) {
if (nums.length == 0) return result;
backtrack(nums, path);
return result;
}
public void backtrack(int[] nums, LinkedList<Integer> path) {
if (path.size() == nums.length) {
result.add(new ArrayList<>(path));
}
for (int i =0; i < nums.length; i++) {
// 如果path中已有,则跳过
if (path.contains(nums[i])) {
continue;
}
path.add(nums[i]);
backtrack(nums, path);
path.removeLast();
}
}
}
47.全排列 II
题目:给定一个可包含重复数字的序列 nums ,按任意顺序 返回所有不重复的全排列。
permuteunque:用used确定使用情况(先全部重置为false),sort整理nums的大小顺序
backtrack:如果遍历path长度与nums长度一致,将其返回到res中
if条件说明是在前后元素一致时前元素没用过时跳过,若used[i]没有在同一树枝使用过时再进行处理
used[i - 1] == true,说明同⼀树⽀nums[i - 1]使⽤过
used[i - 1] == false,说明同⼀树层nums[i - 1]使⽤过
class Solution {
//存放结果
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;//回溯
}
}
}
}