DFS排列组合问题

这四个使用DFS来求解所有组合和排列的例子很有代表性，这里做一个总结：

1.不带重复元素的子集问题

  public ArrayList<ArrayList<Integer>> subsets(int[] nums) {
         // write your code here
         ArrayList<ArrayList<Integer>> results = new ArrayList<>();
         if (nums == null || nums.length == 0) {
             return results;
         }
         Arrays.sort(nums);
         DFS(results, new ArrayList<Integer>(), nums, 0);
         return results;
     }
     public void DFS(ArrayList<ArrayList<Integer>> results, ArrayList<Integer> cur,
                     int[] nums, int start) {
         results.add(new ArrayList<Integer>(cur));
         for (int i = start; i < nums.length; i++) {
             cur.add(nums[i]);
             DFS(results, cur, nums, i+1);
             cur.remove(cur.size()-1);
         }
     }

2.带重复元素的子集问题

 public ArrayList<ArrayList<Integer>> subsetsWithDup(ArrayList<Integer> S) {
         // write your code here
         ArrayList<ArrayList<Integer>> results = new ArrayList<>();
         if (S == null || S.size() == 0) {
             return results;
         }
         Collections.sort(S);
         DFS(results, new ArrayList<Integer>(), S, 0);
         return results;
     }
     public void DFS(ArrayList<ArrayList<Integer>> results,
                     ArrayList<Integer> cur,
                     ArrayList<Integer> S,
                     int start) {
         results.add(new ArrayList<>(cur));
         for (int i = start; i < S.size(); i++) {
             if(i != start && S.get(i) == S.get(i - 1)) {
                 continue;
             }
             cur.add(S.get(i));
             DFS(results, cur, S, i+1);
             cur.remove(cur.size()-1);
         }
     }

3.不带重复元素的全排列问题

 public List<List<Integer>> permute(int[] nums) {
         // write your code here
         List<List<Integer>> results = new ArrayList<List<Integer>>();
         if (nums == null || nums.length == 0) {
             results.add(new ArrayList<Integer>());
             return results;
         }
         boolean[] used = new boolean[nums.length];
         DFS(results, new ArrayList<Integer>(), nums, used);
         return results;
     }
     public void DFS(List<List<Integer>> results, List<Integer> cur, int[] nums, boolean[] used) {
         if (cur.size() == nums.length) {
             results.add(new ArrayList<Integer>(cur));
             return;
         }
         for(int i = 0; i<nums.length; i++) {
             if (used[i]) {
                 continue;
             }
             used[i] =true;
             cur.add(nums[i]);
             DFS(results, cur, nums, used);
             used[i] =false;
             cur.remove(cur.size()-1);
         }
     }

4.带重负元素的全排列问题

 public List<List<Integer>> permuteUnique(int[] nums) {
         // Write your code here
         List<List<Integer>> results = new ArrayList<List<Integer>>();
         if (nums == null || nums.length == 0) {
             results.add(new ArrayList<Integer>());
             return results;
         }
         Arrays.sort(nums);
         boolean[] used = new boolean[nums.length];
         DFS(results, new ArrayList<Integer>(), used, nums);
         return results;
     }
     public void DFS(List<List<Integer>> results, List<Integer> cur, boolean[] used, int[] nums) {
         if (cur.size() == nums.length) {
             results.add(new ArrayList<Integer>(cur));
             return;
         }
         for (int i = 0; i < nums.length; i++) {
             if (used[i]) {
                 continue;
             }
             if (i > 0 && nums[i] == nums[i - 1] && !used[i-1]) {
                 continue;
             }
             used[i] = true;
             cur.add(nums[i]);
             DFS(results, cur, used, nums);
             used[i] = false;
             cur.remove(cur.size() -1);
         }
     }

寻找丢失的数 II*

给一个由 1 - n 的整数随机组成的一个字符串序列，其中丢失了一个整数，请找到它。

回溯，当前位置可以单独，也可以和下一个结合，当前为0一定不行。curIndex控制啥时候结束。

 public int findMissing2(int n, String str) {
         // Write your code here
         if (n < 1 || str == null) {
             return 0;
         }
         char[] chars = str.toCharArray();
         boolean[] appeared = new boolean[n + 1];
         int[] curIndex = {0};
         help(appeared, chars, curIndex, n);
         for (int i = 1; i < appeared.length; i++) {
             if (!appeared[i]) {
                 return i;
             }
         }
         return -1;
     }
     public void help(boolean[] appeared, char[] chars, int[] curIndex, int n) {
         if (curIndex[0] >= chars.length) {
             return;
         }
         if (chars[curIndex[0]] == '0') {
             return;
         }
         if (!appeared[chars[curIndex[0]] - '0']) {
             appeared[chars[curIndex[0]] - '0'] = true;
             curIndex[0]++;
             help(appeared, chars, curIndex, n);
             if (curIndex[0] >= chars.length) {
                 return;
             }
             curIndex[0]--;
             appeared[chars[curIndex[0]] - '0'] = false;
         }
         if (curIndex[0] < chars.length - 1) {
             int c1 = chars[curIndex[0]] - '0';
             int c2 = chars[curIndex[0] + 1] - '0';
             int newnum = c1 * 10 + c2;
             if (newnum <= n && !appeared[newnum]) {
                 appeared[newnum] = true;
                 curIndex[0] += 2;
                 help(appeared, chars, curIndex, n);
                 if (curIndex[0] >= chars.length) {
                     return;
                 }
                 curIndex[0]-=2;
                 appeared[newnum] = false;
             }
         }
     }