DFS算法专题(二)——穷举vs暴搜vs深搜vs回溯vs剪枝【OF决策树】

1、决策树

2、算法实战应用【leetcode】

2.1 题一：全排列

2.2.1 算法原理

2.2.2 算法代码

2.2 题二：子集

2.2.1 算法原理【策略一】

2.2.2 算法代码【策略一】

2.2.3 算法原理【策略二，推荐】

2.2.4 算法代码【策略二，推荐】

2.3 题三：找出所有子集的异或总和再求和

2.3.1 算法原理

2.3.2 算法代码【解法一】(不推荐)

2.3.3 算法代码【解法二】(推荐)

2.4 题四：全排列 II

2.4.1 算法原理

2.4.2 算法代码

1、决策树

决策树是一种树形结构的监督学习算法，广泛应用于分类任务和回归任务中。它通过递归地将数据集分割成更小的子集，最终形成一个树形模型，用于预测新数据的输出。

决策树是一种树形结构，其中每个内部节点表示一个属性上的测试，每个分支代表一个测试输出，每个叶节点代表一种类别。

决策树是一种十分常用的分类方法。它是一种监督学习，所谓监督学习就是给定一堆样本，每个样本都有一组属性和一个类别，这些类别是事先确定的，那么通过学习得到一个分类器，这个分类器能够对新出现的对象给出正确的分类。这样的机器学习就被称之为监督学习。

面对上难度的DFS算法题，我们首先要做的就是画出决策树。

注意：画出的决策树越详细越好！！！

2、算法实战应用【leetcode】

2.1 题一：全排列

. - 力扣（LeetCode）

2.2.1 算法原理

画出决策树，记住：决策树越详细越好！！！
设置全局变量(全局变量的设置因题而异)，本题设置二维数组ret为返回值，记录全部的全排列；数组path记录路径；布尔类型的check数组实现剪枝操作
对于递归函数，我们仍然要站在宏观角度，聚焦于某一层要做的事来设计
DFS算法，不可避免的就是回溯、剪枝与函数出口等细节问题的考虑
对于本题回溯的设计，在dfs完下一层，回到当前层后，再进行恢复现场的操作(删除下一层在path中的数据)，注意：本题需要对path和check均进行回溯操作
对于本题剪枝的设计，通过布尔数组的判断，判断数组中数据可否放进路径path中
对于本题递归函数的出口，将path中存放数据的数量和nums数组长度相比较，若相等，则添加到ret中。

2.2.2 算法代码

class Solution {
    List<List<Integer>> ret;
    List<Integer> path;
    boolean[] check;
    public List<List<Integer>> permute(int[] nums) {
        ret = new ArrayList<>();
        path = new ArrayList<>();
        check = new boolean[nums.length];
        dfs(nums);
        return ret;
    }
    public void dfs(int[] nums) {
        //函数出口
        if(path.size() == nums.length) {
            ret.add(new ArrayList<>(path));
            return;
        }

        for(int i = 0; i < nums.length; i++) {
            if(!check[i]) {
                path.add(nums[i]);
                check[i] = true;
                dfs(nums);
                //将下一层中的相关数据删除 -> 回溯 -> 恢复现场 -> 1.path 2.check
                //add新数据时，递归仍然在本层中，add的是本层i位置处的新数据，
                //dfs完后，i仍然为本层add时的数据的下标，
                //此时回溯要将path和check恢复现场
                path.remove(path.size() - 1);
                check[i] = false;
            }
        }
    }
}

2.2 题二：子集

. - 力扣（LeetCode）

2.2.1 算法原理【策略一】

画决策树
设置全局变量 : ①：List<List<Integer>> ret;//返回值 ②：List<Integer> path;//记录路径
设计函数头：void dfs(nums, pos);//pos为下一次进入path中元素的下标
设计函数体：①:选:path += nums[pos]; dfs(nums,pos+1)；②:不选:dfs(nums,pos+1);
考虑函数出口：pos == nums.length；将path添加进ret中，return；
处理细节问题：①:回溯 -> 恢复现场：path.remove(pathsize()-1); ②:剪枝：无

2.2.2 算法代码【策略一】

class Solution {
    List<List<Integer>> ret;
    List<Integer> path;
    public List<List<Integer>> subsets(int[] nums) {
        ret = new ArrayList<>();
        path = new ArrayList<>();
        dfs(nums, 0);
        return ret;
    }
    public void dfs(int[] nums, int pos) {
        //函数出口
        if(pos == nums.length) {
            ret.add(new ArrayList<>(path));
            return;
        }
        
        //选
        path.add(nums[pos]);
        dfs(nums, pos + 1);
        //回溯 -> 恢复现场
        path.remove(path.size() - 1);

        //不选(不做任何操作即可)
        dfs(nums, pos + 1);
    }
}

2.2.3 算法原理【策略二，推荐】

思想

分三个支线，每个节点就是一个子集，所以每刚进入递归函数时，就把path添加进ret中，pos依然为下一个要添加进path中的元素的下标。叶子节点即为函数出口。

步骤：

画决策树
设计代码 ①全局变量 ret/path ②函数头 void dfs(nums, pos); ③函数体 1.ret.add(path);2.依次枚举该节点后的元素 ④函数出口无
细节问题 ①回溯 -> 恢复现场:path.remove(path,size()-1) ②剪枝 -> 无

2.2.4 算法代码【策略二，推荐】

class Solution {
    List<List<Integer>> ret;
    List<Integer> path;
    public List<List<Integer>> subsets(int[] nums) {
        ret = new ArrayList<>();
        path = new ArrayList<>();
        dfs(nums, 0);
        return ret;
    }
    public void dfs(int[] nums, int pos) {
        ret.add(new ArrayList<>(path));
        //从pos位置开始向后枚举
        for(int i = pos; i < nums.length; i++) {
            //依次枚举，下标为i
            path.add(nums[i]);
            //从当前元素后面的元素中选
            dfs(nums, i + 1);
            //回溯 -> 恢复现场
            path.remove(path.size() - 1);
        }
    }
}

2.3 题三：找出所有子集的异或总和再求和

. - 力扣（LeetCode）

2.3.1 算法原理

本题与上一题解题思想如出一辙，

解法一：直接cv上一题的代码，再将每组子集相异或再求和。（不推荐）

解法二：将path设置为每个子集的异或值(策越二，每个节点都是一个子集)，再创建一个全局变量sum求和即可，回溯时直接利用异或消消乐的特性恢复现场即可。

解法二的时间效率更加优秀，建议大家使用解法二解题。

2.3.2 算法代码【解法一】(不推荐)

class Solution {
    List<List<Integer>> total;
    List<Integer> path;
    public int subsetXORSum(int[] nums) {
        total = new ArrayList<>();
        path = new ArrayList<>();
        List<Integer> sum = new ArrayList<>();
        dfs(nums, 0);
        for(int i = 0; i < total.size(); i++) {
            int ret = 0;
            for(int j = 0; j < total.get(i).size(); j++) {
                ret ^= (total.get(i).isEmpty() ? 0 : total.get(i).get(j));
            }
            sum.add(ret);
        }
        int val = 0;
        for(int x : sum) val += x;
        return val;
    }
    public void dfs(int[] nums, int pos) {
        total.add(new ArrayList<>(path));

        for(int i = pos; i < nums.length; i++) {
            path.add(nums[i]);
            dfs(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

2.3.3 算法代码【解法二】(推荐)

class Solution {
    int path;//每个子集所有元素的异或值
    int sum;
    public int subsetXORSum(int[] nums) {
        path = 0;
        sum = 0;
        dfs(nums, 0);
        return sum;
    }
    public void dfs(int[] nums, int pos) {
        sum += path;

        for(int i = pos; i < nums.length; i++) {
            path ^= nums[i];
            dfs(nums, i + 1);
            //回溯 -> 恢复现场 -> 异或：消消乐
            path ^= nums[i];
        }
    }
}

2.4 题四：全排列 II

. - 力扣（LeetCode）

2.4.1 算法原理

本题整体框架与上文题一全排列相同，回溯函数出口函数体等设计这里不再赘述。

由于出现重复的元素，故本题算法需要添加更多的剪枝操作。

在数组有序的情况下(有序时相同的元素才会相邻)，我们可以这样来设计剪枝：

剪枝：

①：同一个元素只能出现一次 --> boolean[] check
②：在一个节点的分支中，相同数值的元素只能选择一次

筛选节点：

符合条件的节点：
check[i]==flase && (i==0 || nums[i-1] != nums[i] || check[i-1]==true)

2.4.2 算法代码

class Solution {
    List<List<Integer>> ret;
    List<Integer> path;
    boolean[] check;//同一个数据，只能出现一次
    public List<List<Integer>> permuteUnique(int[] nums) {
        ret = new ArrayList<>();
        path = new ArrayList<>();
        check = new boolean[nums.length];
        //数据有序的情况下，保证重复的元素是相邻的
        Arrays.sort(nums);
        dfs(nums);
        return ret;
    }
    public void dfs(int[] nums) {
        if(path.size() == nums.length) {
            ret.add(new ArrayList<>(path));
            return;
        }
        for(int i = 0; i < nums.length; i++) {
            //剪枝 -> 筛选出符合条件的分支
            //同一个数据只能出现一次 && 一个节点上，相同数值的元素只能选择一次
            if(!check[i] && (i == 0 || nums[i - 1] != nums[i] || check[i - 1])) {
                path.add(nums[i]);
                check[i] = true;
                dfs(nums);
                //回溯 -> 恢复现场
                path.remove(path.size() - 1);
                check[i] = false;
            }
        }
    }
}

END