回溯算法分析

学习：回溯算法入门级详解 + 练习（持续更新）

回溯算法可以大致想象成一棵树，根节点是一个空列表，然后以DFS深度搜索的形式从未访问集合中选择元素加入到列表中，当当前列表满足题目要求时，就将该路径视为一个答案，加入答案集中。在往前回溯的过程中要注意撤销当前选择，伪代码：

for(int i = 0 ; i < n; i++{   // 每次都对整个集合进行遍历
	if(visited[i]) continue;
	// 1.从未访问集合中选择一个元素加入列表，将该元素置为已访问
	path.add(nums[i]);
	visited[i] = true;
	2.进入下一层深搜，path添加新的元素，dfs
	dfs(path, depth+1, nums, visited);
	3.注意，在dfs返回后，需要重置状态，撤销选择，也就是把这个位置再空出来给下一个元素
	path.remove(path.size() - 1);
	visited[i] = false;
)

46. 全排列

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

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

示例 2：

输入：nums = [0,1]
输出：[[0,1],[1,0]]

示例 3：

输入：nums = [1]
输出：[[1]]

提示：

• 1 <= nums.length <= 6
• -10 <= nums[i] <= 10
• nums 中的所有整数 互不相同

题解

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        List<Integer> path = new ArrayList<>();
        boolean[] visited = new boolean[nums.length];
        dfs(path, 0, nums, visited);
        return ans;
    }

    public void dfs(List<Integer> path, int depth , int[] nums, boolean[] visited){
        if(depth == nums.length){
            ans.add(new ArrayList<>(path));
        }
        for(int i = 0; i < nums.length; i++){
            if(visited[i] == true) continue;
            visited[i] = true;
            path.add(nums[i]);
            dfs(path, depth + 1, nums, visited);
            visited[i] = false;
            path.remove(path.size() - 1);
        }
    }
}

47. 全排列 II

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

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

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

提示：

• 1 <= nums.length <= 8
• -10 <= nums[i] <= 10

题解

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        int n = nums.length;
        List<List<Integer>> ans = new ArrayList<>();
        boolean[] visited = new boolean[n];
        Deque<Integer> path = new ArrayDeque<>();
        dfs(ans, path, nums, visited, 0, n);
        return ans;
    }

    public void dfs(List<List<Integer>> ans, Deque<Integer> path, int[] nums, boolean[] visited, int depth, int n){
        if(depth == n){
            ans.add(new ArrayList<>(path));
        }
        Set<Integer> set = new HashSet<>();
        for(int i = 0; i < n; i++){
            if(visited[i] || set.contains(nums[i])){  // 如果当前路径已访问过该元素， 或者是当前层已经设置过相同值的元素
                continue;
            }
            // 添加元素
            visited[i] = true;
            path.addLast(nums[i]);
            // dfs
            dfs(ans, path, nums, visited, depth + 1, n);
            // 回溯
            visited[i] = false;
            path.removeLast();
            // 将该元素的值加入集合中
            set.add(nums[i]);
        }
    }
}