回溯之全排列

        分享完用回溯解决组合问题与子集问题后，这次分享用回溯解决全排列问题。下面先给出回溯的模板代码。

private void backtracking(参数1,参数2,...){
	if(递归终止条件){
		收集结果;
		return;
	}
	for(遍历集合){
		处理;
		backtracking(参数1,参数2,...); // 递归;
		回溯;
	}
}

全排列

给定一个不含重复数字的数组nums，返回其所有可能的全排列。你可以按任意顺序返回答案。

示例 1：
输入：nums = [1,2,3]
输出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    int[] used;
    public List<List<Integer>> permute(int[] nums) {
        used = new int[nums.length];
        backtracking(nums);
        return ans;
    }
    private void backtracking(int[] nums){
        if(path.size() == nums.length){
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0;i < nums.length;i++){
            if(used[i] == 1) continue;
            used[i] = 1;
            path.add(nums[i]);
            backtracking(nums);
            used[i] = 0;
            path.remove(path.size() - 1);
        }
    }
}

        根据给出示例，详细说明上述代码的执行流程。定义所有排列的集合ans，定义集合path用于存储递归过程中for循环遍历到且符合要求的元素。当path的大小和数组的大小相等时，表示path为符合要求的一个排列，将其放入ans集合中。定义used数组，如果nums[i]在path中，则used[i]等于1，反之等于0。在permute方法中，初始化used数组，并调用backtracking方法收集所有排列，最终返回ans集合。
        进入backtracking方法后，path为空，不符合if条件，进入for循环，将元素1加入到path中，path为[1]，used[0] = 1，递归进入下一个backtracking，path大小为1，不满足if判断，进入for循环，used[0]等于1，continue，i++，将元素2加入path，path为[1, 2]，used[1] = 1，递归进入下一个backtracking，path大小为2，不符合if条件，进入for循环，此时，used[0]和used[1]都等于1，for循环遍历两次都是continue，第三次遍历将元素3加入到path中，此时path为[1, 2, 3]，used[2] = 1，递归进入下一个backtracking中，此时path大小为3，符合条件，将[1, 2, 3]放入集合中，并返回到上一个backtracking，将元素3从path中移除，used[2] = 0，i++，等于nums.length，for循环结束，递归返回上一个backtracking，将元素2从path中移除，此时path为[1]，used[1]等于0，for循环继续，i++，遍历到元素3，此时used[2]等于0，将元素3加入到path中，path为[1, 3]，used[2] = 1，递归进入下一个backtracking中，不满足if条件，进入for循环，used[0] = 1，continue，i++，由于used[1]等于0，将元素2加入到path中，path为[1, 3, 2]，used[1]等于1，递归进入下一个backtracking中，path大小为3，满足if条件，将[1, 3, 2]加入ans集合中，并返回上一个backtracking，将元素2从path集合中移除，path为[1, 3]，used[1]等于0，for循环继续，i++，由于used[2]等于1，i++，等于nums.length，跳出循环，递归返回上一个backtracking中，将元素3从集合中移除，path为[1]，used[2] = 0，for循环继续，i++，i等于nums.length，跳出循环，递归返回最初的backtracking中，将元素1从path中移除，path为空，used[0] = 0，此时就完成了最初backtracking中for循环的一轮。之后第二轮for循环，将元素2加入path作为首元素，能够将[2, 1, 3]和[2, 3, 1]加入到ans集合中，第三轮for循环，将元素3作为首元素，能够将[3, 1, 2]和[3, 2, 1]加入到ans集合中，这里就不再详细描述。

全排列II

给定一个可包含重复数字的序列nums，按任意顺序返回所有不重复的全排列。

示例 1：
输入：nums = [1,1,2]
输出：[[1,1,2], [1,2,1], [2,1,1]]

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    int used[];
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        used = new int[nums.length];
        backtracking(nums);
        return res;
    }
    private void backtracking(int[] nums){
        if(path.size() == nums.length){
            res.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0;i < nums.length;i++){
            if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == 0) continue;
            if(used[i] == 1) continue;
            path.add(nums[i]);
            used[i] = 1;
            backtracking(nums);
            path.remove(path.size() - 1);
            used[i] = 0;
        }
    }
}

        这一题与上一题的区别在于数组中可能出现重复元素，因此这题与上一题唯一的区别在于排除掉重复的排列，首先对数组进行排序，之后在for循环中加入if(i > 0 && nums[i] == nums[i - 1] && used[i - 1] == 0) continue;这个判断条件，就可以实现排列的去重。在子集问题说明了加入该if判断的整个执行流程。该if判断能够阻止for循环横向添加重复元素，允许通过递归纵向添加重复元素。

参考：带你学透回溯算法（理论篇）| 回溯法精讲！