DFS 学习笔记

已于 2023-02-18 21:05:43 修改
阅读量628 收藏
点赞数
分类专栏： 算法题 文章标签： 深度优先 学习 算法
于 2023-02-17 00:01:14 首次发布
好好学习天天向上
本文链接：https://blog.csdn.net/weixin_37646636/article/details/129073761
版权

leetcode面试题 08.07. 无重复字符串的排列组合

方式1：第一步→DFS基本模板

public static String[] permutation(String S) {
    List<String> res = new ArrayList<>();
    StringBuilder sb = new StringBuilder();
    dfs(S, sb, res);
    
    return res.toArray(String[]::new);
}

public static void dfs(String str, StringBuilder sb, List<String> res) {
    if (sb.length() == 变量) {
        res.add(sb.toString());
        return;
    }
    
    for (int i = 0; i < str.length(); i++) {
        sb.append(str.charAt(i));
        dfs(str, sb, res);
        sb.deleteCharAt(sb.length() - 1);
    }
}

输入："qwe"

变量=1→3
["q","w","e"]

变量=2 → 3*3=9
["qq","qw","qe","wq","ww","we","eq","ew","ee"]

变量= 3→ 3*3*3=27
["qqq","qqw","qqe","qwq","qww","qwe","qeq","qew","qee","wqq","wqw","wqe","wwq","www","wwe","weq","wew","wee","eqq","eqw","eqe","ewq","eww","ewe","eeq","eew","eee"]

变量=4 → 3*3*3*3=81
["qqqq","qqqw","qqqe","qqwq","qqww","qqwe","qqeq","qqew","qqee","qwqq","qwqw","qwqe","qwwq","qwww","qwwe","qweq","qwew","qwee","qeqq","qeqw","qeqe","qewq","qeww","qewe","qeeq","qeew","qeee","wqqq","wqqw","wqqe","wqwq","wqww","wqwe","wqeq","wqew","wqee","wwqq","wwqw","wwqe","wwwq","wwww","wwwe","wweq","wwew","wwee","weqq","weqw","weqe","wewq","weww","wewe","weeq","weew","weee","eqqq","eqqw","eqqe","eqwq","eqww","eqwe","eqeq","eqew","eqee","ewqq","ewqw","ewqe","ewwq","ewww","ewwe","eweq","ewew","ewee","eeqq","eeqw","eeqe","eewq","eeww","eewe","eeeq","eeew","eeee"]

方式1：第二步→DFS排除自己

public static String[] permutation(String S) {
    List<String> res = new ArrayList<>();
    boolean[] visited = new boolean[S.length()];
    StringBuilder sb = new StringBuilder();
    dfs(S, sb, visited, res);
    
    return res.toArray(String[]::new);
}

public static void dfs(String str, StringBuilder sb, boolean[] isVisited, List<String> res) {
    if (sb.length() == 变量) {
        res.add(sb.toString());
        return;
    }
    
    for (int i = 0; i < str.length(); i++) {
        if (isVisited[i]) {
            continue;
        }
        
        sb.append(str.charAt(i));
        isVisited[i] = true;
        
        dfs(str, sb, isVisited, res);
        
        sb.deleteCharAt(sb.length() - 1);
        isVisited[i] = false;
    }
}

输入："qwe"

变量=1
["q","w","e"]

变量=2
["qw","qe","wq","we","eq","ew"]

变量=3
["qwe","qew","wqe","weq","eqw","ewq"]

变量=4
[]

leetcode面试题 08.08. 有重复字符串的排列组合

对于如上两个方法场景

场景1：DFS基本模板

输入："qww"

变量=1
["q","w","w"]

变量=2
["qq","qw","qw","wq","ww","ww","wq","ww","ww"]

变量=3
["qqq","qqw","qqw","qwq","qww","qww","qwq","qww","qww","wqq","wqw","wqw","wwq","www","www","wwq","www","www","wqq","wqw","wqw","wwq","www","www","wwq","www","www"]

变量=4
["qqqq","qqqw","qqqw","qqwq","qqww","qqww","qqwq","qqww","qqww","qwqq","qwqw","qwqw","qwwq","qwww","qwww","qwwq","qwww","qwww","qwqq","qwqw","qwqw","qwwq","qwww","qwww","qwwq","qwww","qwww","wqqq","wqqw","wqqw","wqwq","wqww","wqww","wqwq","wqww","wqww","wwqq","wwqw","wwqw","wwwq","wwww","wwww","wwwq","wwww","wwww","wwqq","wwqw","wwqw","wwwq","wwww","wwww","wwwq","wwww","wwww","wqqq","wqqw","wqqw","wqwq","wqww","wqww","wqwq","wqww","wqww","wwqq","wwqw","wwqw","wwwq","wwww","wwww","wwwq","wwww","wwww","wwqq","wwqw","wwqw","wwwq","wwww","wwww","wwwq","wwww","wwww"]


场景2：DFS排除自己

变量=1
["q","w","w"]

变量=2
["qw","qw","wq","ww","wq","ww"]

变量=3
["qww","qww","wqw","wwq","wqw","wwq"]

变量=4
[]

场景2去重时只排除了自己，并没有排除不同位置相同的元素

如上去重时只排除了自己，并没有排除不同位置相同的元素

方式1：追加去重逻辑

public static String[] permutation(String S) {
    char[] arr = S.toCharArray();
    
    // 排序之后，相同字符位于字符数组中的相邻位置，可以利用这一特点去重
    Arrays.sort(arr);
    
    boolean[] visited = new boolean[S.length()]; // 标记是否走过
    List<String> res = new ArrayList<>();
    StringBuilder sb = new StringBuilder();
    dfs(new String(arr), sb, visited, res);
    
    // 输出指定格式
    return res.toArray(String[]::new);
}
/**
 * @param str     素材字符串
 * @param sb      拼接字符串的临时变量
 * @param visited 标记是否走过
 * @param res     收集结果
 */
public static void dfs(String str, StringBuilder sb, boolean[] visited, List<String> res) {
    if (sb.length() == 变量) {
        res.add(sb.toString());
        return;
    }
    
    for (int i = 0; i < str.length(); i++) {
        // 去重时排除自己
        // 已经加入当前排列，则不能多次加入当前排列
        if (visited[i]) {
            continue;
        }
        
        // 确保arr[i−1]在arr[i]前加入排列
        // arr[i−1]未加入当前排列,则不能将arr[i]加入当前排列,否则arr[i−1]将在arr[i]之后加入当前排列,导致出现重复排列
        if (0 < i && str.charAt(i) == str.charAt(i - 1) && !visited[i - 1]) {
            continue;
        }
        
        // 递归下去
        sb.append(str.charAt(i));
        visited[i] = true;
        
        dfs(str, sb, visited, res);
        
        // 回溯上来
        visited[i] = false;
        sb.deleteCharAt(sb.length() - 1);
    }
}

输入："qww"

变量=1
[q, w]

变量=2
[qw, wq, ww]

变量=3
[qww, wqw, wwq]

变量=4
[]

方式2：08.07基础直接去重

public static String[] permutation(String S) {
    List<String> res = new ArrayList<>();
    boolean[] visited = new boolean[S.length()];
    StringBuilder sb = new StringBuilder();
    dfs(S, sb, visited, res);
    
    // 去重
    List<String> collect = res.stream().distinct().collect(Collectors.toList());
    
    return collect.toArray(String[]::new);
}
public static void dfs(String str, StringBuilder sb, boolean[] isVisited, List<String> res) {
    if (sb.length() == 变量) {
        res.add(sb.toString());
        return;
    }
    
    for (int i = 0; i < str.length(); i++) {
        if (isVisited[i]) {
            continue;
        }
        
        sb.append(str.charAt(i));
        isVisited[i] = true;
        
        dfs(str, sb, isVisited, res);
        
        sb.deleteCharAt(sb.length() - 1);
        isVisited[i] = false;
    }
}

输入："qww"

变量=1
[q, w]

变量=2
[qw, wq, ww]

变量=3
[qww, wqw, wwq]

变量=4
[]

leetcode77. 组合

public static List<List<Integer>> combine(int n, int k) {
    List<List<Integer>> res = new ArrayList<>();
    // 范围 [1, n] 中所有可能的 k 个数的组合
    // k<=0时没意义;
    // n<k时没意义,一共才n个想取k个不合理
    if (k <= 0 || n < k) {
        return res;
    }
    Deque<Integer> stack = new LinkedList<>();
    dfs(1, n, k, stack, res);
    return res;
}

public static void dfs(int start, int milestone, int limit, Deque<Integer> stack, List<List<Integer>> res) {
    if (stack.size() == limit) { // 一共收集limit层,已经收集到limit层时直接收工大退
        res.add(new ArrayList<>(stack));
        System.out.println(new ArrayList<>(stack));
        return;
    }
    for (int i = start; i <= milestone; i++) {
        stack.push(i);
        dfs(i + 1, milestone, limit, stack, res);
        stack.pop();
    }
}

范围 [1, 5] 中所有可能的 3 个数的组合
[3, 2, 1]
[4, 2, 1]
[5, 2, 1]
[4, 3, 1]
[5, 3, 1]
[5, 4, 1]
[4, 3, 2]
[5, 3, 2]
[5, 4, 2]
[5, 4, 3]

public static void dfs(int start, int milestone, int limit, Deque<Integer> stack, List<List<Integer>> res) {
    res.add(new ArrayList<>(stack));
    
    System.out.println(new ArrayList<>(stack));
    for (int i = start; i <= milestone; i++) {
        stack.push(i);
        dfs(i + 1, milestone, limit, stack, res);
        stack.pop();
    }
}

所有CASE:
[]
[1]
[2, 1]
[3, 2, 1]
[4, 3, 2, 1]
[5, 4, 3, 2, 1]
[5, 3, 2, 1]
[4, 2, 1]
[5, 4, 2, 1]
[5, 2, 1]
[3, 1]
[4, 3, 1]
[5, 4, 3, 1]
[5, 3, 1]
[4, 1]
[5, 4, 1]
[5, 1]
[2]
[3, 2]
[4, 3, 2]
[5, 4, 3, 2]
[5, 3, 2]
[4, 2]
[5, 4, 2]
[5, 2]
[3]
[4, 3]
[5, 4, 3]
[5, 3]
[4]
[5, 4]
[5]

leetcode491 找出整数数组中不同的递增子序列

方式1：第一步→DFS 基本模板

public static List<List<Integer>> findSubsequences(int[] nums) {
    if (nums == null || nums.length < 2) {
        return new ArrayList<>();
    }
    
    List<List<Integer>> res = new ArrayList<>();
    Deque<Integer> queue = new LinkedList<>();
    dfs(0, nums, queue, res);
    
    return res.stream().distinct().collect(Collectors.toList());
}

public static void dfs(int start, int[] arr, Deque<Integer> queue, List<List<Integer>> res) {
    res.add(new ArrayList<>(queue));
    System.out.println(new ArrayList<>(queue));
    
    for (int i = start; i < arr.length; i++) {
        queue.addLast(arr[i]);
        dfs(i + 1, arr, queue, res);
        queue.removeLast();
    }
}

输入源：1 2 3 4

[]
[1]
[1, 2]
[1, 2, 3]
[1, 2, 3, 4]
[1, 2, 4]
[1, 3]
[1, 3, 4]
[1, 4]
[2]
[2, 3]
[2, 3, 4]
[2, 4]
[3]
[3, 4]
[4]

输入：4 6 3 7 7

[]
[4]
[4, 6]
[4, 6, 3]
[4, 6, 3, 7]
[4, 6, 3, 7, 7]
[4, 6, 3, 7]
[4, 6, 7]
[4, 6, 7, 7]
[4, 6, 7]
[4, 3]
[4, 3, 7]
[4, 3, 7, 7]
[4, 3, 7]
[4, 7]
[4, 7, 7]
[4, 7]
[6]
[6, 3]
[6, 3, 7]
[6, 3, 7, 7]
[6, 3, 7]
[6, 7]
[6, 7, 7]
[6, 7]
[3]
[3, 7]
[3, 7, 7]
[3, 7]
[7]
[7, 7]
[7]

方式1：第二步→只保留升序的元素

public static List<List<Integer>> findSubsequences(int[] nums) {
    if (nums == null || nums.length < 2) {
        return new ArrayList<>();
    }
    
    List<List<Integer>> res = new ArrayList<>();
    Deque<Integer> queue = new LinkedList<>();
    dfs(0, nums, queue, res);
    
    return res.stream().distinct().collect(Collectors.toList());
}

public static void dfs(int start, int[] arr, Deque<Integer> queue, List<List<Integer>> res) {
    res.add(new ArrayList<>(queue));
    System.out.println(new ArrayList<>(queue));
    
    for (int i = start; i < arr.length; i++) {
        if (!queue.isEmpty() && queue.getLast() > arr[i]) {
            continue; // 不满足递增子序列(两整数相等视作递增)条件时，继续处理下一个数据
        }
        
        queue.addLast(arr[i]);
        dfs(i + 1, arr, queue, res);
        queue.removeLast();
    }
}

输入：4 6 3 7 7

[]
[4]
[4, 6]
[4, 6, 7]
[4, 6, 7, 7]
[4, 6, 7]
[4, 7]
[4, 7, 7]
[4, 7]
[6]
[6, 7]
[6, 7, 7]
[6, 7]
[3]
[3, 7]
[3, 7, 7]
[3, 7]
[7]
[7, 7]
[7]

方式1：第三步→（升序）+（>=2）+（去重）

/**
 * leetcode491 找出整数数组中不同的递增子序列
 */
public static List<List<Integer>> findSubsequences(int[] nums) {
    if (nums == null || nums.length < 2) {
        return new ArrayList<>();
    }
    
    List<List<Integer>> res = new ArrayList<>();
    Deque<Integer> queue = new LinkedList<>();
    dfs(0, nums, queue, res);
    
    return res.stream().distinct().collect(Collectors.toList());
}

public static void dfs(int start, int[] arr, Deque<Integer> queue, List<List<Integer>> res) {
    if (queue.size() >= 2) { // 满足条件就快照一下
        res.add(new ArrayList<>(queue));
        System.out.println(new ArrayList<>(queue));
    }
    
    for (int i = start; i < arr.length; i++) {
        if (!queue.isEmpty() && queue.getLast() > arr[i]) {
            continue; // 不满足递增子序列(两整数相等视作递增)条件时，继续处理下一个数据
        }
        queue.addLast(arr[i]);
        dfs(i + 1, arr, queue, res);
        queue.removeLast();
    }
}

输入源：4 6 3 7 7
[4, 6]
[4, 6, 7]
[4, 6, 7, 7]
[4, 6, 7]
[4, 7]
[4, 7, 7]
[4, 7]
[6, 7]
[6, 7, 7]
[6, 7]
[3, 7]
[3, 7, 7]
[3, 7]
[7, 7]

外层去重 res.stream().distinct().collect(Collectors.toList());

方式2：添加直接去重逻辑

public static List<List<Integer>> findSubsequences(int[] nums) {
    if (nums == null || nums.length < 2) {
        return new ArrayList<>();
    }
    
    List<List<Integer>> res = new ArrayList<>();
    Deque<Integer> queue = new LinkedList<>();
    dfs(0, nums, queue, res);
    
    return res;
}
/**
 * 递归枚举子序列的通用模板
 */
public static void dfs(int start, int[] arr, Deque<Integer> queue, List<List<Integer>> 
    if (queue.size() >= 2) { // 满足条件就快照一下
        res.add(new ArrayList<>(queue));
        System.out.println(new ArrayList<>(queue));
    }
    
    // 用hashset去重
    Set<Integer> visited = new HashSet<>();
    for (int i = start; i < arr.length; i++) {
        if (!queue.isEmpty() && queue.getLast() > arr[i]) {
            continue; // 不满足递增子序列(两整数相等视作递增)条件时，继续处理下一下
        }
        
        if (visited.contains(arr[i])) {
            continue;
        }
        
        visited.add(arr[i]);
        
        queue.addLast(arr[i]);
        dfs(i + 1, arr, queue, res);
        queue.removeLast();
    }
}

输入源：4 6 3 7 7

[4, 6]
[4, 6, 7]
[4, 6, 7, 7]
[4, 7]
[4, 7, 7]
[6, 7]
[6, 7, 7]
[3, 7]
[3, 7, 7]
[7, 7]
张紫娃
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2-sat学习笔记
01-08
例： struct TwoSAT{ ... int dfs(int x) { if (mark[x^1]) return 0; if (mark[x]) return 1; //和假设的值一样 mark[x]=1; S[c++]=x; for (int i=0;in=n; for (int i=0;i<2*n;i++) G[i].clear();
Hadoop学习笔记
01-20
在深入探讨Hadoop学习笔记之前，我们先了解一下Hadoop的核心组件和主要概念。Hadoop是一个开源框架，主要用于处理和存储大规模数据集。它基于Google的MapReduce编程模型和分布式文件系统GFS（Google File System）的...
深度优先搜索DFS
m0_62994512的博客
01-05 63
学习笔记
Nginx基本教程
wqww_1的博客
08-17 119
什么是nginx nginx是一个高性能HTTP和反向代理web服务器 （1）反向代理 （2）负载均衡 （3）动静分离 （4）高可用 安装过程 反向代理 负载均衡 动静分离 高可用
Java的反射机制和其简单的应用
wqww_1的博客
03-15 144
什么是反射 反射定义十分的难以理解但是我们可以知道反射可以做些什么？ Java的反射机制是在运行转态，对于任意个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用他的任意个方法和属性，这种动态获取信息以及动态调用对象方法的功能称为Java的反射机制。 Class类 要创建Class类的对象有3种方法 （1）使用class属性 Class classDemo = Demo.class...
DFS学习笔记
weixin_43522068的博客
06-20 303
重点二维数组的定义一定要搞清楚。
Dfs学习笔记
invalid_in的博客
01-12 152
DFS基于递归思想,有两个重要的标志，也就是两个数组，一个用来标记该点是否被访问过，一个用来把该点放入数组---即存答案. //注意bool数组初始化默认为false 模板 void dfs()//参数用来表示状态,一般什么在变化什么作参数. { if(到达终点状态) { ... return; } if(越界或者是不符合法状态)//剪枝 return; for(扩展方式) {
dfs学习笔记整理
qq_43235540的博客
01-21 431
一边学dfs，一边整理啦 dfs题型 1.连通块： 就是标记画图，算出每个小模块个数 2.寻找到达终点的途径数：理解dfs其实会无数次到达终点后，每次到达就ans++就可以算出，但是注意返回时vis[x][y]]要清0. 例如下面这个 #include&amp;amp;lt;cstdio&amp;amp;gt; #include&amp;amp;lt;algorithm&amp;amp;gt; #include&amp;amp;lt;iostream&am
dfs学习笔记 1
saber是我的！！！的博客
02-02 248
这篇文大概就是自己在学习过程中学到的一些模板和注意事项吧，emmm在此先膜拜各路大佬orz 先贴核心代码： void dfs()//参数用来表示状态 { if(到达终点状态) { ...//根据题意添加 return; } if(越界或者是不合法状态) return; i...
DFS学习笔记-POJ1416 Shredding Company
ex_voda的博客
07-17 496
关于初学者对DFS的一些浅要理解，以poj1416为例
学习笔记：dfs深搜
hui_li_yi_的博客
11-03 61
【代码】学习笔记：dfs深搜。
最新Hadoop学习笔记
08-25
**Hadoop学习笔记详解** Hadoop是一个开源的分布式计算框架，由Apache基金会开发，主要用于处理和存储海量数据。它的核心组件包括HDFS（Hadoop Distributed File System）和MapReduce，两者构成了大数据处理的基础...
cpp-算法学习笔记
08-16
【cpp-算法学习笔记】是一份专注于C++编程语言的算法学习资源，旨在帮助开发者深入理解和掌握各种基础及高级算法。这份笔记包含了丰富的实例、解释和练习，是C/C++开发人员提升算法技能的理想教材。在C++这个强大的...
python爬虫学习笔记.zip
02-21
Python爬虫学习笔记主要涵盖了使用Python进行网络数据抓取、处理和分析的相关技术。Python作为一门强大且易学的语言，因其丰富的库支持，成为爬虫开发者的首选工具。本笔记将深入探讨以下几个方面： 1. **基础概念*...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5138
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
【学习笔记】Day 2
最新发布
Akiiiira的博客
08-03 580
1、inversionnet_train_light 试运行——未成功2、DL-FWI基础入门培训-1,2，以及作业1的完成学习目的：进一步认识 “通过全波形反演探测地震数据” 这一系统。内容摘要（1）“全波形反演” 概述A. 关于正演与反演的逻辑B. FWI的数学表示C. FWI的端到端深度学习解释D. DL-FWI的优势E. DL-FWI的基本发展和分类F. 地震数据 (Seismic Data) 是什么样的?G. 速度模型 (Velocity Model) 是什么。
接口测试学习笔记1
weixin_53666393的博客
08-03 774
同时也像白盒测试那样，检查程序的代码，但这种检查不像白盒测试那样详细、完整，一般只对程序模块之间的调用、核心代码进行检查，在集成测试时经常采用，一般也是程序员大量采用。现在企业说的接口测试，一般指的是Web接口测试或Http接口测试，主要指的是基于B/S架构的接口测试（B/S架构主要基于HTTP 超文本传输协议，所以也叫HTTP接口测试）对请求对象（网页、文件、图片...）进行的操作，就是一些命令，程序员在编程的时候使用，在接口文档中会指明，测试人员测试接口的时候，按照说明选择正确的方法。
机械学习—零基础学习日志（高数18——无穷小与无穷大）
AI_freshfish的博客
08-01 561
这里可以记住，无穷小有一个特殊，那就是零。零是最高阶的无穷小，且零是唯一一个常数无穷小。张宇老师还是使用了超实数概念来讲解无穷小。其实是利于理解的，但希望大家接触新概念过程不要太抗拒。数学概念理解，其实可以借用生活概念。张宇老师这里把1除以无穷小，理解成把1分为若干个无穷小。所以得到的就是无穷大。1除以超实数所以得到超实数的结果。
机器学习与深度学习自学笔记：Python环境配置与Jupyter优化
"这是一份关于机器学习和深度学习的学习笔记，作者通过自学网课整理了重要的步骤和理解，旨在方便快速回顾学习过程，并且建议配合《Python3入门人工智能掌握机器学习+深度学习提升实战能力》课程使用。笔记涵盖了...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值