LeetCode47.全排列II 的不同剪枝法的解析

首先贴上两种差距微妙的解题代码

第一种

public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> result = new LinkedList<>();
        boolean[] visited = new boolean[nums.length];
        Arrays.sort(nums);
        backtrack(result,nums,visited,new ArrayList<>());
        return result;
    }

    public void backtrack(List<List<Integer>> result,int[] nums,boolean[] visited, List<Integer> list){
        if(nums.length == list.size()){
            result.add(new ArrayList<>(list));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if(visited[i] || i > 0 && nums[i] ==nums[i-1] && !visited[i-1]){
                continue;
            }
            visited[i] = true;
            list.add(nums[i]);
            backtrack(result,nums,visited,list);
            visited[i] = false;
            list.remove(list.size()-1);
        }
    }

执行用时：1 ms, 在所有 Java 提交中击败了99.30%的用户
内存消耗：38.5 MB, 在所有 Java 提交中击败了99.01%的用户

第二种

public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> result = new LinkedList<>();
        boolean[] visited = new boolean[nums.length];
        Arrays.sort(nums);
        backtrack(result,nums,visited,new ArrayList<>());
        return result;
    }

    public void backtrack(List<List<Integer>> result,int[] nums,boolean[] visited, List<Integer> list){
        if(nums.length == list.size()){
            result.add(new ArrayList<>(list));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if(visited[i] || i > 0 && nums[i] ==nums[i-1] && visited[i-1]){
                continue;
            }
            visited[i] = true;
            list.add(nums[i]);
            backtrack(result,nums,visited,list);
            visited[i] = false;
            list.remove(list.size()-1);
        }
    }

执行用时：2 ms, 在所有 Java 提交中击败了41.87%的用户
内存消耗：39.1 MB, 在所有 Java 提交中击败了67.89%的用户

非常直观的1ms的差距，并且这个差距并不是因为leetCode服务的压力带来的，多次执行的结果基本稳定
而这里面的代码差距只有一行

if(visited[i] || i > 0 && nums[i] ==nums[i-1] && !visited[i-1]){

对比

if(visited[i] || i > 0 && nums[i] ==nums[i-1] && visited[i-1]){

一个！的区别
首先讲讲这个分支条件做了什么，这是一个剪枝条件，作用是用于保证重复数字只会被填入一次
但是两个不同的判断不一样在什么地方呢？
前者，有！的版本，保证的是：对于重复数的集合，一定是从左往右逐个填入的。
后者，没有！的，则保证的是：对于重复数的集合，一定是从右往左逐个填入的。
咋一看这似乎没有区别啊，笔者刚发现这个问题的时候也是一脸懵，遂深入进行了细致分析，直接把不同的程序过程的过梳理出来
假设输入条件：

输入：nums = [1,1,1,2]

这里面3个重复元素分别用 A,B,C来表示

剪枝法1

剪枝法2

从上图可以看出，在仅有1种3个重复元素的情况下，第二种剪枝法的确可以减少递归层数，可想在更多重复元素的情况下，使用第一种剪枝方式可以更加有效减少递归层数，因此才会出现1ms的用时差距
不过笔者现在还没有想出如何使用数学的方式证明这一点，尽管官方给出了第一种方式的时间复杂度分析