DFS算法力扣46. 全排列

最新推荐文章于 2024-06-19 18:43:07 发布

看了个寂寞

最新推荐文章于 2024-06-19 18:43:07 发布

阅读量149

点赞数

分类专栏：算法文章标签： dfs leetcode

本文链接：https://blog.csdn.net/gtjsjj/article/details/111773310

版权

算法专栏收录该内容

50 篇文章 0 订阅

订阅专栏

参看：https://mp.weixin.qq.com/s?__biz=MzAxODQxMDM0Mw==&mid=2247484709&idx=1&sn=1c24a5c41a5a255000532e83f38f2ce4&chksm=9bd7fb2daca0723be888b30345e2c5e64649fc31a00b05c27a0843f349e2dd9363338d0dac61&scene=21#wechat_redirect

1.DFS算法

1）DFS算法需要思考的3个问题：

路径：已经做出的选择
选择列表：当前可以做的选择
结束条件：到达底层，无法再做选择的条件

2）框架

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

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

3）举例说明，如下图

处于红点位置，[2]就是「路径」，记录你已经做过的选择；[1,3]就是「选择列表」，表示你当前可以做出的选择；「结束条件」就是遍历到树的底层，在这里就是选择列表为空的时候。

4)题目

46. 全排列

给定一个没有重复数字的序列，返回其所有可能的全排列。

示例:

输入: [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>> res = new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        LinkedList<Integer> track = new LinkedList<>();
        backtrack(nums, track);
        return res;
    }
    // 路径：记录在 track 中
    // 选择列表：nums 中不存在于 track 的那些元素
    // 结束条件：nums 中的元素全都在 track 中出现
    private void backtrack(int[] nums, LinkedList<Integer> 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();
        }

    }
}

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        /*
        定义状态变量：
        1.depth:递归到第几层
        2.path:已经选了哪些数
        3.used:布尔数组，这个数是否已经使用
        */
        List<List<Integer>> res = new ArrayList<>();
        //输入数组长度
        int len = nums.length;
        if(len == 0){
            return res;
        }
        Deque<Integer> path = new ArrayDeque<>();
        boolean[] used = new boolean[len];
        //dfs(输入数组，输入数组长度,当前一共选择了几个数（初始化为0）,从根节点到任意节点列表(这是一个栈)，布尔数组，最终结果)
        dfs(nums, len, 0, path, used, res);
        return res;
    }
    private void dfs(int[] nums, int len, int depth, Deque<Integer> path, boolean[] used, List<List<Integer>> res){
        //递归终止条件，层数=输入数组大小
        if(depth == len){
            res.add(new ArrayList<>(path));
            return;
        }

        for(int i=0;i<len;i++){
            if(used[i]){
                continue;
            }
            path.addLast(nums[i]);
            used[i] = true;
            dfs(nums,len,depth+1,path,used,res);
            //回到上一层，之前做了什么，之后做其逆操作
            path.removeLast();
            used[i]=false;
        }
    }
}

参考：https://leetcode-cn.com/problems/permutations/solution/hui-su-suan-fa-python-dai-ma-java-dai-ma-by-liweiw/