综合回溯，剪枝，暴搜

class Solution {
    int sum;
    int path;//表示当前路径的返回值
    public int subsetXORSum(int[] nums) {
     dfs(nums,0);
     return sum;
    }
    public void dfs(int[] nums,int pos){
    sum+=path;
    for(int i=pos;i<nums.length;i++){
        //m添加当前数字
       path^=nums[i];
        dfs(nums,i+1);
        //此处，要想他回溯是什么时候回溯，是dfs走完了回溯，它会先走到下面，然后回到上一层，那么当他会到上一层时，是回溯什么，回溯到上一层的上一层，换句话说，那她就要把当前的值去除
        path^=nums[i];
    }
    }
}

class Solution {
    List<List<Integer>>ret=new ArrayList<>();
    List<Integer>path=new ArrayList<>();
    boolean []check;
    public List<List<Integer>> permuteUnique(int[] nums) {
    check=new boolean[nums.length];
      Arrays.sort(nums);
    dfs(nums);
    return ret;
    }
    public void dfs(int[]nums){
    if(path.size()==nums.length){
        ret.add(new ArrayList<>(path));
    }
  
    for(int i=0;i<nums.length;i++){
        //我们去重的时候想去nums[i]==nums[i+1],万一有可能他们两个重复的不在一起呢。
        //所以我们要进行排序
        //||从左往右执行的，假如左边不成立，那么右边必定成立的情况 true的潜台词是nums[i]==nums[i-1]
        //i==0的原因是，他是第一个元素，我们可以大胆去使用它。
    if(check[i]==false&&(i==0||nums[i]!=nums[i-1]||check[i-1]==true)){
    path.add(nums[i]);
    check[i]=true;
    dfs(nums);
    path.remove(path.size()-1);
    check[i]=false;
    }
    }
    }
}

class Solution {
    List<List<Integer>>ret=new ArrayList<>();
    List<Integer>path=new ArrayList<>();
    boolean []check;
    public List<List<Integer>> permuteUnique(int[] nums) {
    check=new boolean[nums.length];
      Arrays.sort(nums);
    dfs(nums);
    return ret;
    }
    public void dfs(int[]nums){
    if(path.size()==nums.length){
        ret.add(new ArrayList<>(path));
    }
  
    for(int i=0;i<nums.length;i++){
        //我们去重的时候想去nums[i]==nums[i+1],万一有可能他们两个重复的不在一起呢。
        //所以我们要进行排序
        //||从左往右执行的，假如左边不成立，那么右边必定成立的情况 true的潜台词是nums[i]==nums[i-1]
        //i==0的原因是，他是第一个元素，我们可以大胆去使用它。
    if(check[i]==true||(i!=0&&nums[i]==nums[i-1]&&check[i-1]!=true)){
    continue;
    }
    path.add(nums[i]);
    check[i]=true;
    dfs(nums);
    path.remove(path.size()-1);
    check[i]=false;
    }
    }
}

、class Solution {
    String[] hash={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
    List<String>ret=new ArrayList<>();
    StringBuffer path=new StringBuffer();
    public List<String> letterCombinations(String digits) {
    if(digits.length()==0){
        return ret;
    }
    dfs(digits,0);
    return ret;
    }
public void dfs(String digits,int pos){
    //为什么是等于pos,因为pos代表的是这个字符串有多长，够了就说明可以回溯了
     if(digits.length()==pos){
        ret.add(path.toString());
        return;
}
//把cur数组存储hash里面的字符串，pos的变化相当于是切换字符串 ，abc先a然后到达def的d
String cur=hash[digits.charAt(pos)-'0'];
//一次遍历cur里面的数组，然后path路径再次加入路径元素
for(int i=0;i<cur.length();i++){
    //i是表示假如说号码2，是说号码2的第几个，不是总体的长度
    path.append(cur.charAt(i));
    dfs(digits,pos+1);
    path.deleteCharAt(path.length()-1);
}
    }
}

class Solution {
    int left;
    int k;
    int right;
    List<String> ret=new ArrayList<>();
    StringBuffer path=new StringBuffer(); 
    public List<String> generateParenthesis(int n) {
     k=n;
     dfs();
     return ret;
    }
public void dfs(){
      if(right==k){
          ret.add(path.toString());
          return;
      }
假如left<括号的对数，那么我们就可以添加左括号
//在这里其实我有一个思考，什么时候+右括号呢，这不是一直都会进入左括号吗。
       if(left<k){
          path.append("(");
          left++;
          dfs();
          path.deleteCharAt(path.length()-1);
          left--;  
      }
//假如left>right就可以一直+右括号
      if(left>right){
          path.append(")");
          right++;
          dfs();
          path.deleteCharAt(path.length()-1);
          right--;  
      }
    }
}