Leetcode047全排列(可能含重复元素)-----------回溯法加剪枝

地址：

描述：

​

 题解：

不含重复元素的46题——题解地址（）：

主要思路：

代码：

---

地址：

https://leetcode-cn.com/problems/permutations-ii/

描述：

 题解：

https://leetcode-cn.com/problems/permutations-ii/solution/dai-ma-sui-xiang-lu-dai-ni-xue-tou-hui-s-ki1h/

不含重复元素的46题——题解地址（）：

https://mp.csdn.net/mp_blog/creation/editor/119570812

相对于46题，本题增加了剪枝操作，需要我们将重复的组合删除。

主要思路：

图中我们对同一树层，前一位（nums[i-1]==false）表明使用过，那么就进行去重。比如[1',1,2]就和[1,1',2]重复了

而对于不在同一树层，但在同一树枝上，前一位（exist[i-1]==true），我们不需要去重。比如[1,1,2]

一般来说：组合问题和排列问题是在树形结构的叶子节点上收集结果，而子集问题就是取树上所有节点的结果。

代码：

java版

package Leetcode;

import java.util.ArrayList;
import java.util.List;

public class Leetcode047 {
    //用来存放所有的全排列组合
    List<List<Integer>> permuteUnique=new ArrayList<>();
    List<Integer> temp = new ArrayList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        //由于数组中存在重复元素，所以我们需要进行排序
        for(int i=0;i<nums.length-1;i++){
            for(int j=0;j<nums.length-i-1;j++){
                if(nums[j]>nums[j+1]){
                    int temp=nums[j];
                    nums[j]=nums[j+1];
                    nums[j+1]=temp;
                }
            }
        }
        //用来记载某一数字是否已经存在在这个组合里，默认都为false;
        boolean [] exist=new boolean [nums.length];
        if(nums.length==0){
            return permuteUnique;
        }
        for(int i=0;i<nums.length;i++) exist[i]=false;
        backtracking(nums,0,exist);
        return(permuteUnique);
    }
    public void  backtracking(int []nums,int index, boolean [] exist){
        if(index==nums.length){
            permuteUnique.add(new ArrayList<>(temp));//保存结果
            return;
        }
        for(int i=0;i<nums.length;i++){
            //某个数与它的前一个数相同，且它的前面那个数没被用过，跳过因为会重复
            if(i>0&&nums[i-1]==nums[i]&&exist[i-1]==false) continue;
            //找不存在的数添加到组合中
            if(!exist[i]) {
                temp.add(nums[i]);
                exist[i] = true;
                backtracking(nums, index + 1,exist);
                //开始回溯
                exist[i] = false;
                temp.remove(temp.size()-1);
            }
        }
    }
}

C++版

class Solution {
public:
    vector<int> temp;
    vector<vector<int>>ans;
    vector<bool> st;
    vector<vector<int>> permuteUnique(vector<int>& nums) {
     temp=vector<int>(nums.size());
     st=vector<bool>(nums.size());
     //重复数字我们需要先进行排序
     sort(nums.begin(),nums.end());
     dfs(nums,0);
     return ans;
    }
    void dfs(vector<int>&nums,int u){
        if(u==nums.size()){
            ans.push_back(temp);
            return ;
        }
        for(int i=0;i<nums.size();i++){
            if(i>0&&nums[i]==nums[i-1]&&st[i-1]==false) continue;
            if(!st[i]){
                temp[u]=nums[i];
                st[i]=true;
                dfs(nums,u+1);
                temp[u]=0;
                st[i]=false;
            }
        }
      
    }
};