目标：寻找所有可行解

解决一个回溯问题，实际上就是一个决策树的遍历过程

三要素

1. 路径：也就是已经做出的选择。
2. 选择列表：也就是你当前可以做的选择。
3. 结束条件：也就是到达决策树底层，无法再做选择的条件。

算法框架

result = []
def backtrack(路径, 选择列表):
    if 满足结束条件:
        result.add(路径)
        return

    for 选择 in 选择列表:
        做选择
        backtrack(路径, 选择列表)
        撤销选择

1.全排列

public class Permute {

    /**
     * 结果集
     */
    private static List<List<Integer>> res = new ArrayList<>();

    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        System.out.println(permute(nums));
    }

    private static List<List<Integer>> permute(int[] nums) {
        //路径
        LinkedList<Integer> track = new LinkedList<>();
        backtrack(nums, track);
        return res;
    }

    private static void backtrack(int[] nums, LinkedList<Integer> track) {
        // 路径：记录在 track 中
        // 选择列表：nums 中不存在于 track 的那些元素
        // 结束条件：nums 中的元素全都在 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]);
            //进入下一层决策树
            backtrack(nums, track);
            //撤销选择
            track.removeLast();
        }
    }
}

2.重复数组的全排列

public class PermuteUnique {
    /**
     * 标记已经填过的数
     */
    boolean[] vis;

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

    /**
     * 回溯搜索
     * @param nums 目标数组
     * @param ans 结果集
     * @param perm 当前路径
     */
    public void backtrack(int[] nums, List<List<Integer>> ans,  List<Integer> perm) {
        //结束条件
        if (perm.size() == nums.length) {
            ans.add(new ArrayList<Integer>(perm));
            return;
        }
        for (int i = 0; i < nums.length; ++i) {
            //防止重复数字填入，排序后比较
            // 假设我们有 3 个重复数排完序后相邻，那么我们一定保证每次都是拿从左往右第一个未被填过的数字，
            // 即整个数组的状态其实是保证了
            // [未填入，未填入，未填入] 到 [填入，未填入，未填入]，
            // 再到 [填入，填入，未填入]，最后到 [填入，填入，填入] 的过程的，因此可以达到去重的目标。
            if (vis[i] || (i > 0 && nums[i] == nums[i - 1] && !vis[i - 1])) {
                continue;
            }
            //选择
            perm.add(nums[i]);
            vis[i] = true;
            //下一层回溯
            backtrack(nums, ans,  perm);
            //取消选择
            vis[i] = false;
            perm.remove(perm.size()-1);
        }
    }
}