代码随想录算法训练营day29 | 491.递增子序列，46.全排列，47.全排列 II
- 491.递增子序列
- 解法一：回溯（map进行数层去重）
- 解法二：回溯（仅针对本题，不具有普适性）
- 46.全排列
- 解法一：回溯（used数组记录去重，不是树层去重）
- 解法二：回溯（根据path中是否含有该元素去重）
- 47.全排列 II
- 解法一：回溯
- 总结
491.递增子序列
教程视频：https://www.bilibili.com/video/BV1EG4y1h78v/?vd_source=ddffd51aa532d23e6feac69924e20891
本题的难点是不能排序，因此我们不能像90、子集II那样直接采用used数组记录使用情况，而应该采用map记录path中已经包含的数字进行数层去重。针对本题，因为nums中的数据范围有限，可以使用数组索引对应每一种数值来进行树层去重。
解法一：回溯（map进行数层去重）
//用map去重
class Solution {
//结果集合
List<List<Integer>> res = new ArrayList<>();
//路径集合
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> findSubsequences(int[] nums) {
getSubsequences(nums,0);
return res;
}
private void getSubsequences( int[] nums, int start ) {
if(path.size()>1 ){
res.add( new ArrayList<>(path) );
// 注意这里不要加return，要取树上的节点
}
HashMap<Integer,Integer> map = new HashMap<>();
for(int i=start ;i < nums.length ;i++){
if(!path.isEmpty() && nums[i]< path.getLast()){
continue;
}
// 使用过了当前数字
if ( map.getOrDefault( nums[i],0 ) >=1 ){
continue;
}
map.put(nums[i],map.getOrDefault( nums[i],0 )+1);
path.add( nums[i] );
getSubsequences( nums,i+1 );
path.removeLast();
}
}
}
//用set去重
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;
}
public void backtracking(int[] nums, int startIndex){
if(path.size()>1){
result.add(new ArrayList<>(path));
}
//求子集可以不写终止条件
if(startIndex>=nums.length){
return;
}
Set<Integer> used = new HashSet<>();
for(int i=startIndex; i<nums.length; i++){
//树层去重
if(used.contains(nums[i]) || (!path.isEmpty() && path.get(path.size()-1)>nums[i])){
continue;
}
used.add(nums[i]);
path.add(nums[i]);
backtracking(nums,i+1);
path.remove(path.size()-1);
}
}
}
解法二：回溯（仅针对本题，不具有普适性）
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;
}
public void backtracking(int[] nums, int startIndex){
if(path.size()>1){
result.add(new ArrayList<>(path));
}
int[] used = new int[201];
for(int i=startIndex;i<nums.length;i++){
//前半部分是去除非递增子串，后半部分数层去重
if((!path.isEmpty() && path.get(path.size()-1)>nums[i]) || (used[nums[i]+100]==1)){continue;}
used[nums[i]+100]=1;
path.add(nums[i]);
backtracking(nums,i+1);
path.remove(path.size()-1);
}
}
}
46.全排列
教程视频：https://www.bilibili.com/video/BV19v4y1S79W/?spm_id_from=333.788&vd_source=ddffd51aa532d23e6feac69924e20891
这是排列问题，有两个需要关注的点：1、每层都是从0开始搜索而不是startIndex；2、需要记录path里都放了哪些元素了。
解法一：回溯（used数组记录去重，不是树层去重）
因为每层used要在上一层的基础上修改，因此used需要作为回溯参数传递。
class Solution {
List<List<Integer>> result = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> permute(int[] 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++){
if(used[i]){
continue;
}
path.add(nums[i]);
used[i]=true;
backtracking(nums,used);
used[i]=false;
path.remove(path.size()-1);
}
}
}
解法二：回溯（根据path中是否含有该元素去重）
针对本题nums中数值互不相同，可以根据path中是否含有该元素去重
class Solution {
List<List<Integer>> result = new ArrayList<>();
List<Integer> path = new ArrayList<>();
public List<List<Integer>> permute(int[] nums) {
backtracking(nums);
return result;
}
public void backtracking(int[] nums){
if(path.size()==nums.length){
result.add(new ArrayList<>(path));
return;
}
for(int i=0;i<nums.length;i++){
if(path.contains(nums[i])){
continue;
}
path.add(nums[i]);
backtracking(nums);
path.remove(path.size()-1);
}
}
}
47.全排列 II
教程视频：https://www.bilibili.com/video/BV1R84y1i7Tm/?spm_id_from=pageDriver&vd_source=ddffd51aa532d23e6feac69924e20891
解法一：回溯
class Solution {
List<List<Integer>> result = new ArrayList<>();
List<Integer> path = new ArrayList<>();
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]控制在同一层去重
if(i>0 && nums[i-1]==nums[i] && !used[i-1]){
continue;
}
if(used[i]){
continue;
}
path.add(nums[i]);
used[i]=true;
backtracking(nums,used);
used[i]=false;
path.remove(path.size()-1);
}
}
}
总结
1、不能排序时，需要采用Map进行树层去重。同时，求子集可以省略终止条件。
2、排列问题，有两个需要关注的点：a、每层都是从0开始搜索而不是startIndex；b、需要记录path里都放了哪些元素了。
3、47.全排列 II 是46.全排列和40.组合总和II的结合。树枝不去重，树层去重。
