递增子序列
题目:给你一个整数数组 nums ,找出并返回所有该数组中不同的递增子序列,递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。
数组中可能含有重复元素,如出现两个整数相等,也可以视作递增序列的一种特殊情况。
思路:主要考虑在不能排序的前提下怎么去重复,至于为什么不能排序,因为排序完了之后可能影响结果,例如[4,7,6,7],排序完之后[4,6,7,7],将会收集到结果 4 6 7 7但是一开始的数组是不存在4 6 7 7的子序列的。使用一个set集合记录当前递归层的元素是否使用过
class Solution {
public List<List<Integer>> findSubsequences(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
backtracking(nums,0,path,res);
return res;
}
private void backtracking(int[] nums,int startIndex,List<Integer> path,List<List<Integer>> res){
if(path.size() >= 2){
res.add(new ArrayList<>(path));
}
// 这里可以不用判断startIndex>=nums.length 然后return,因为即使这里不返回,下面的for循环中会有个i = startIndex;i<nums.length,也会返回
// 记录每一层递归中使用过的元素
Set<Integer> used = new HashSet<>();
for(int i = startIndex;i<nums.length;i++){
if((path.size() > 0 && nums[i] < path.get(path.size()-1)) || used.contains(nums[i])){
continue;
}
path.add(nums[i]);
used.add(nums[i]);
backtracking(nums,i+1,path,res);
path.remove(path.size() - 1);
// used是记录每一层递归中的元素是否用过,不存在跨层(跨递归),所有不需要remove
}
}
}
全排列
题目:给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
思路:全排列就是所有的元素都要用到,然后组成的集合的不同(包括顺序),排列就不需要使用startIndex了,因为startIndex是防止后续出现的集合和前面的集合是同一个组合,例如[1,2]和[2,1]这两个是一个组合,但是是两个排列,所有本题就不用startIndex了;但是需要一个used数组记录数组元素是否用过,因为排列中的元素是不能够重复的
class Solution {
public List<List<Integer>> permute(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
int[] used = new int[nums.length];
backtracking(nums,path,res,used);
return res;
}
private void backtracking(int[] nums,List<Integer> path,List<List<Integer>> res,int[] used){
// 当收集的结果等于nums的大小的时候就可以收集结果了
if(path.size() == nums.length){
res.add(new ArrayList<>(path));
return;
}
for(int i = 0;i<nums.length;i++){
// 如果当前路径结果中使用了当前元素,那么就跳过
if(used[i] == 1){
continue;
}
path.add(nums[i]);
used[i] = 1;
backtracking(nums,path,res,used);
path.remove(path.size()-1);
used[i] = 0;
}
}
}
全排列||
题目:给定一个可包含重复数字的序列 nums ,按任意顺序 返回所有不重复的全排列。
思路:需要在树层上去重,还要在树枝上去重
class Solution {
public List<List<Integer>> permuteUnique(int[] nums) {
List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();
int[] used = new int[nums.length];
Arrays.sort(nums);
backtracking(nums,path,res,used);
return res;
}
private void backtracking(int[] nums,List<Integer> path,List<List<Integer>> res,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;
}
// 这里是判断path中不能重复,因为每次for循环都是从0开始的所有会重复 树枝去重
if(used[i] == 0){
path.add(nums[i]);
used[i] = 1;
backtracking(nums,path,res,used);
path.remove(path.size()-1);
used[i] = 0;
}
}
}
}