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

小丁爱养花2024-09-10 20:06

目录

1、决策树

2、算法实战应用【leetcode】

[2.1 题一：全排列](#2.1 题一：全排列)

[2.2.1 算法原理](#2.2.1 算法原理)

[2.2.2 算法代码](#2.2.2 算法代码)

[2.2 题二：子集](#2.2 题二：子集)

[2.2.1 算法原理【策略一】](#2.2.1 算法原理【策略一】)

[2.2.2 算法代码【策略一】](#2.2.2 算法代码【策略一】)

[2.2.3 算法原理【策略二，推荐】](#2.2.3 算法原理【策略二，推荐】)

[2.2.4 算法代码【策略二，推荐】](#2.2.4 算法代码【策略二，推荐】)

[2.3 题三：找出所有子集的异或总和再求和](#2.3 题三：找出所有子集的异或总和再求和)

[2.3.1 算法原理](#2.3.1 算法原理)

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

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

[2.4 题四：全排列 II](#2.4 题四：全排列 II)

[2.4.1 算法原理](#2.4.1 算法原理)

[2.4.2 算法代码](#2.4.2 算法代码)

1、决策树

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

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

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

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

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

2、算法实战应用【leetcode】

2.1 题一：全排列

. - 力扣（LeetCode）

2.2.1 算法原理

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

2.2.2 算法代码

java 复制代码 
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 算法原理【策略一】

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

2.2.2 算法代码【策略一】

java 复制代码 
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中的元素的下标。叶子节点即为函数出口。

步骤：

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

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

java 复制代码 
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 算法代码【解法一】(不推荐)

java 复制代码 
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 算法代码【解法二】(推荐)

java 复制代码 
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 算法原理

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

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

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

  1. 剪枝：

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

  1. 筛选节点：

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

2.4.2 算法代码

java 复制代码 
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

相关推荐
无问8176 分钟前
数据结构-排序(冒泡，选择，插入，希尔，快排，归并，堆排)
java·数据结构·排序算法
m0_6312704024 分钟前
高级c语言（五）
c语言·开发语言
customer0827 分钟前
【开源免费】基于SpringBoot+Vue.JS在线文档管理系统（JAVA毕业设计）
java·vue.js·spring boot·后端·开源
2401_8582861130 分钟前
53.【C语言】 字符函数和字符串函数(strcmp函数)
c语言·开发语言
Flying_Fish_roe44 分钟前
Spring Boot-版本兼容性问题
java·spring boot·后端
程序猿进阶1 小时前
如何在 Visual Studio Code 中反编译具有正确行号的 Java 类？
java·ide·vscode·算法·面试·职场和发展·架构
Eloudy1 小时前
一个编写最快，运行很慢的 cuda gemm kernel, 占位 kernel
算法
程序猿练习生1 小时前
C++速通LeetCode中等第5题-无重复字符的最长字串
开发语言·c++·leetcode
slandarer1 小时前
MATLAB | R2024b更新了哪些好玩的东西？
java·数据结构·matlab
2401_858120261 小时前
MATLAB中的无线通信系统部署和优化工具有哪些
开发语言·matlab
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04CANoe Trace窗口过滤栏消失的几种解决方法（附上最终解决方案）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07Coze扣子平台完整体验和实践（附国内和国际版对比）08yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10浏览器插件——ModHeader 的分享和学习