回溯入门问题——全排列

全排列(Medium)

力扣46

class Solution {
    private List<List<Integer>> res = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        LinkedList<Integer> track = new LinkedList<>();
        dfs(nums, track);
        return res;
    }
    private void dfs(int[] nums,LinkedList<Integer> track){
    //触发递归结束条件
        if (track.size() == nums.length){
            res.add(new LinkedList<>(track));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
        //排除不合法的选择
            if (track.contains(nums[i])) {
                continue;
            }
            //做选择
            track.add(nums[i]);
            //进入下一层决策树
            dfs(nums, track);
            //取消选择
            track.removeLast();
        }
    }
}

track.contains(nums[i])这一行代码的复杂度是 O(n)，代码复杂度很高，正确的做法是使用标记数组visited[]判断当前元素是否使用过visited可为boolean[]类型，也可为int[]类型(访问过为1，未访问为0)

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new LinkedList<>();
        LinkedList<Integer> track = new LinkedList<>();
        boolean[] visited = new boolean[nums.length];
        dfs(nums, track,visited,res);
        return res;
    }

    private void dfs(int[] nums, LinkedList<Integer> track, boolean[] visited, List<List<Integer>> res){
        if (track.size() == nums.length){
            res.add(new LinkedList<>(track));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (visited[i] == true) {
                continue;
            }
            visited[i] = true;
            track.add(nums[i]);
            dfs(nums, track,visited,res);
            visited[i] = false;
            track.removeLast();
        }
    }
}

使用标记数组来处理填过的数是一个很直观的思路，但是可不可以去掉这个标记数组呢？毕竟标记数组也增加了我们算法的空间复杂度。

答案是可以的，我们可以将题目给定的 n 个数的数组 nums[] 划分成左右两个部分，左边的表示已经填过的数，右边表示待填的数，我们在递归搜索的时候只要动态维护这个数组即可。

以[1,2,3]为例，第一个数有1,2,3三种选择，固定第一个数后，第二个数有2个选择，固定第二个数后，第三个数只剩一种选择

注：这样生成的全排列并不是按字典序存储在答案数组中的（这种方法[3,2,1]排[3,1,2]前面），如果题目要求按字典序输出，那么请还是用标记数组或者其他方法。

class Solution {
    public void backtrack(int n, ArrayList<Integer> output, List<List<Integer>> res, int first) {
        // 所有数都填完了
        if (first == n) res.add(new ArrayList<Integer>(output));
        for (int i = first; i < n; i++) {
            // 动态维护数组
            Collections.swap(output, first, i);
            // 继续递归填下一个数
            backtrack(n, output, res, first + 1);
            // 撤销操作
            Collections.swap(output, first, i);
        }
    }

    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> res = new LinkedList();

        ArrayList<Integer> output = new ArrayList<Integer>();
        for (int num : nums)
            output.add(num);

        int n = nums.length;
        backtrack(n, output, res, 0);
        return res;
    }
}