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;
            }
        }
    }