排列问题汇总

排列问题有两种解决方案：1）基于swap。 2）基于选择。基于swap的方法就是回溯法中解空间树是排列树的情况，candidate分别排(swap)第一位，然后全排列后面的部分，是in place的。基于选择的思路是，依次填每个位置，每次选择都是顺序从全candidate集合选取，如果前面没选过，就是合法的candiate。缺点很明显：一是每次都是尝试从全candidate集合选取，还要到已选的集合查看是否被选过，复杂度比基于swap的方法高，当然可以用引入hashset 的办法优化。空间复杂度方面，不是in place的，需要另外一个集合存放排列的结果。但基于选择的方法有一个好处，就是输出的排列是字典序的。

import java.util.Arrays;

class HelloWorld {
    public static void main(String[] args) {
        dfs(new int[] {1, 2, 3}, new boolean[3], new int[3], 0);
    }
    static void dfs(int[] arr, boolean[] used, int[] res, int t) {
        if (t == arr.length) {
            System.out.println(Arrays.toString(res));
            return;
        }
        for (int i = 0; i < arr.length; ++i) {
            if (!used[i]) {
                used[i] = true;
                res[t] = arr[i];
                dfs(arr, used, res, t + 1);
                used[i] = false;
            }
        }
        /*
        for (int i = t; i < res.length; ++i) {
            res[t] = arr[]
            dfs(arr, t + 1);
            swap(arr, t , i);
        }*/
    }
    static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

 上面代码可以看出，两种方式在复杂度方面区别不大

有重复的元素的情况：

1）基于swap的方案

对于一个位置的每个candidate，判断在这个位置上是这个值否出现过，如果出现过则忽略，因为二者的排列是一样的：第一个位置一样，后面的集合是一样的，全排列是相同的。

2）基于选择的方法

class Solution {
    List<List<Integer> >  ans = new ArrayList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        dfs(nums, new int[nums.length], new boolean[nums.length], 0);
        return ans;
    }
    void dfs(int[] nums, int[] res, boolean[] used, int t) {
        if (t == res.length) {
            ans.add(IntStream.of(res).boxed().collect(Collectors.toList()));
            return;
        }
        for (int i = 0; i < nums.length; ++i) {
            if (used[i] || i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) continue;
            used[i] = true;
            res[t] = nums[i];
            dfs(nums, res, used, t + 1);
            used[i] = false;
        }
    }
}