回溯算法---全排列

回溯算法：

回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况：

1、找到一个可能存在的正确的答案；
2、在尝试了所有可能的分步方法后宣告该问题没有答案。

个人理解来说，回溯算法就是穷举所有的可能性。再选择出所有满足条件的答案。就像高中做的全排列：

LeetCode上全排列的两个题：
46、全排列
47、全排列2

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

也就是说，只要全排列出所有答案并返回就行：
回溯算法代码如下：

class Solution {
    List<List<Integer>> list = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        LinkedList<Integer> track = new LinkedList<>();
        //判断当前节点是否被遍历过
        boolean[] visited = new boolean[nums.length];
        //回溯
        BackTrack(nums, track, visited);
        return list;
    }
    public void BackTrack(int[] nums, LinkedList<Integer> track, boolean[] visited){
    //如果遍历到根节点，也就是遍历完所有节点的时候，长度是相同的。递归终止条件
        if(track.size() == nums.length){
            list.add(new LinkedList(track));
            return;
        }
        //遍历数组
        for(int i = 0; i < nums.length; i++){
        //如果当前节点被遍历过，遍历下一个
            if(visited[i]){
                continue;
            }
            
            track.add(nums[i]);
            //标记为遍历过的节点
            visited[i] = true;
            //递归回溯
            BackTrack(nums, track, visited);
            //回溯操作，将最后的节点删除
            track.removeLast();
            //标记改变为未遍历
            visited[i] = false;
        }
    }
}

这一题只需要遍历所有节点，但是第47题需要去掉重复的结果。
这时候就可以采用回溯剪枝。
剪枝的前提条件是数组排序。
剪枝代码：

//剪枝
            if(i > 0 && nums[i] == nums[i - 1] && visit[i - 1] == false){
                continue;
            }

全部代码：

class Solution {
   List<List<Integer>> list = new ArrayList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        
        if(nums.length == 0){
            return list;
        }
       
        int n = nums.length;
        //排序是剪枝的前提
        Arrays.sort(nums);
        Deque<Integer> path = new ArrayDeque<>(n);
        boolean[] visit = new boolean[n];
        Back(nums, 0, path, visit);
        return list;
    }
    public void Back(int[] nums, int depth, Deque<Integer> path, boolean[] visit){
        if(depth == nums.length){
            list.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0; i < nums.length; i++){
            if(visit[i]) continue;

            //剪枝
            if(i > 0 && nums[i] == nums[i - 1] && visit[i - 1] == false){
                continue;
            }
            path.addLast(nums[i]);
            visit[i] = true;
            Back(nums, depth + 1, path, visit);
            visit[i] = false;
            path.removeLast();
        }
    }
}