热门标签
热门文章
- 1【深度学习】多头注意力机制详解
- 2GeoTrust SSL证书有什么优势？
- 3一文教你如何将Eclipse项目导入到IDEA运行_eclipse项目导入idea
- 4python文字转语音的五种方式win32com，pyttsx3，百度api，可使用自己的声音_pyttsx3修改成自己下载的声音
- 5NineAi推出全新AI系统网站源码 ChatGPT交互体验_nine ai网站源码
- 6【NLP练习】Pytorch文本分类入门
- 7亚太地区数学建模优秀论文_2020 年 APMCM 亚太地区大学生数学建模竞赛
- 8使用printf输出string类型字符串_printf string
- 9JVM原理_jvm的原理
- 10云计算OpenStack---云计算、大数据、人工智能_云计算的大事记
当前位置: article > 正文
DFS+回溯算法专题_dfs回溯
作者：IT小白 | 2024-04-10 14:17:27
赞
踩
dfs回溯
基础知识
回溯法是一种选优搜索法（试探法），被称为通用的解题方法，这种方法适用于解一些组合数相当大的问题。通过剪枝（约束+限界）可以大幅减少解决问题的计算量（搜索量）。
深度优先搜索（Depth-First-Search，DFS）是一种用于遍历或搜索树或图的算法。沿着树的深度遍历树的节点，尽可能深的搜索树的分支。当节点v的所在边都己被探寻过，搜索将回溯到发现节点v的那条边的起始节点。这一过程一直进行到已发现从源节点可达的所有节点为止。如果还存在未被发现的节点，则选择其中一个作为源节点并重复以上过程，整个进程反复进行直到所有节点都被访问为止。
回溯和深度优先搜索的区别
回溯是一种更通用的算法。可以用于任何类型的结构，其中可以消除域的部分 ——无论它是否是逻辑树。
深度优先搜索是与搜索树或图结构相关的特定回溯形式。它使用回溯作为其使用树的方法的一部分，但仅限于树/图结构。
回溯法采用的是深度优先搜索的策略，当搜索到解空间树的某一结点时，用约束条件判断对该结点是否需要剪枝，如果结点不可行需要剪枝，则跳过以当前结点为根节点的子树的搜索，回溯到父结点；否则，继续按DFS策略搜索子树。
单纯的DFS以深度为关键词进行搜索时，不会对约束条件进行判断，而是在搜索完成（到达边界）时才会判断是否满足约束条件，进而判断是否形成一个可行解。
总的来说：回溯算法 = 树的深度优先搜索 + 剪枝函数
解题技巧
1、 一般矩阵或者棋盘的题，当数据范围比较小的时候用搜索算法（DFS || BFS），当数据范围比较大的时候用动态规划算法。
2、dfs + 回溯解题框架
dfs算法的过程其实就是一棵递归树，所有的dfs算法的步骤大概有以下几步：
- 找到终止条件，即递归树从根节点走到叶子节点时的返回条件，此时一般情况下已经遍历完了从根节点到叶子结点的一条路径，往往就是我们需要存下来的一种合法方案；
- 如果还没有走到底，那么我们需要对当前层的所有可能选择方案进行枚举，加入路径中，然后走向下一层；
- 在枚举过程中，有些情况下需要对不可能走到底的情况进行预判，例如一些不满足基本规则的情况，如果已经知道这条路不可能到达我们想去的地方，那我们干嘛还要一条路走到黑呢，这就是我们常说的剪枝的过程；
- 当完成往下层的递归后，我们需要将当前层的选择状态进行清零，它下去之前是什么样子，我们现在就要让它恢复初始状态，也叫恢复现场。该过程就是回溯，目的是回到最初选择路口的起点，好再试试其他的路。
void dfs(参数) {
if (终止条件) {
存放结果;
return;
}
for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
处理节点;
如果不满足基本规则，则剪枝
dfs(路径，选择列表); // 递归
回溯，撤销处理结果
}
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
3、dfs中最重要的是确定搜索顺序，做到不重不漏！！！
4、涉及到的排列组合这样的问题，也就是一堆数（或字符）中选数要求不重复使用（或者说满足某种规则，本质还是不能重复），通常可以通过设置额外的布尔数组记录每个数（字符）的使用状态，如46，47，90，51，52，37等都是这样的题目；
5、在写代码前务必理清楚满足题目要求的基本规则并制定出相应的剪枝策略！！如51，37，473
6、一般需要设置一个index负责枚举目标序列的每个元素是否满足条件，使用时务必明确index代表什么，如17,79,46,47,78,90。
题目练习
17. 电话号码的字母组合
给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。
题目分析
DFS + 回溯
搜索顺序：依次枚举每个组合由给定的按键中哪些字符组成
代码实现
class Solution { //回溯算法 时间复杂度为O(3^m + 4^n)，证明见官方 //初始对应所有的数字，为了直接对应2-9，新增了两个无效的字符串"" String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"}; //涉及大量的字符串拼接，选择更为高效的StringBuilder StringBuilder combination = new StringBuilder(); //存储结果 List<String> result = new ArrayList<String>(); public List<String> letterCombinations(String digits) { if (digits.length() == 0) { return result; } backTracking(digits, 0); return result; } public void backTracking(String digits, int index) { //终止条件 if (index == digits.length()) { result.add(combination.toString()); return; } //获取对应的字符 String chars = numString[digits.charAt(index) - '0']; //遍历字符 for (int i = 0; i < chars.length(); i++) { combination.append(chars.charAt(i)); //继续递归获取下一个号码对应的字符并组合 backTracking(digits, index + 1); //回溯，去除已经遍历的字符， //如digits="23" ，初始时遍历'a',递归获得"ad",index=1,继续递归，index=2,加入result， //回溯到index=1这一层，执行下方代码，删除'd',继续执行，获得"ae","af", //回溯到index=0这一层，删除'a'，i++,遍历'b',以此类推。 combination.deleteCharAt(index); } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
79. 单词搜索
给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。
单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
题目分析
代码实现
class Solution { //dfs 时间复杂度是O(n^2 3^k) //从单词矩阵中枚举每个单词的起点，从该起点出发往四周dfs搜索目标单词，并记录当前枚举到第几个单词， //若当前搜索到的位置(i,j)的元素恰好是word单词第depth个字符，则继续dfs搜索， //直到depth到最后一个字符则表示有了符合的方案，返回true int[] dx = new int[]{0, -1, 0, 1}; int[] dy = new int[]{-1, 0, 1, 0}; int m, n; public boolean exist(char[][] board, String word) { //获取单词矩阵的行列数 m = board.length; //行数 n = board[0].length; //列数 //遍历矩阵每个字符 for(int i = 0; i < m; i++){ for(int j = 0; j < n; j++){ //如果是目标单词首字母，则从该字符出发向四周搜索目标单词 if(board[i][j] == word.charAt(0)){ if(dfs(board, word, 0, i, j)){ return true; } } } } //如果遍历完所有字符都没有目标单词首字母，说明不存在 return false; } //向四周搜索目标单词 index表示单词位 public boolean dfs(char[][] board, String word, int index, int x, int y){ //终止条件 如果所遍历的矩阵字符与对应单词位上的字符不等 和 搜索完单词所有字符 if(board[x][y] != word.charAt(index)) return false; if(index == word.length() - 1) return true; char c = board[x][y]; //标记已遍历的字符 board[x][y] = '*'; //获取当前字符上下左右的相邻字符 for(int i = 0; i < 4; i++){ int u = x + dx[i]; int v = y + dy[i]; //如果超出矩阵边界 if(u < 0 || u >= m || v < 0 || v >= n) continue; //已使用过的字符不能重复再用 剪枝 if(board[u][v] == '*') continue; //如果匹配上了，则继续匹配单词其他字符，直到匹配完或匹配失败 if(dfs(board, word, index + 1, u, v)) return true; } //回溯 恢复初始状态 board[x][y] = c; return false; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
46. 全排列
题目链接
给定一个不含重复数字的数组 nums ，返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
题目分析
第一种顺序：
第二种顺序：
这里给出的搜索顺序为：依次枚举每个位置放什么数
代码实现
class Solution { //DFS+回溯 时间复杂度O(n∗n!) 每个位置放什么数 int len; //数组长度 List<Integer> res = new ArrayList<>(); //每次排列的结果 List<List<Integer>> result = new ArrayList<>(); //全排列 boolean[] state; //标志排列时是否使用过该数字 public List<List<Integer>> permute(int[] nums) { len = nums.length; if(nums == null || len == 0) return result; state = new boolean[len]; dfs(nums, 0); return result; } public void dfs(int[] nums, int index){ //终止条件 if(index == len){ //必须新建ArrayList对象存储此时res的值， //否则因为存入的是res的引用地址，最后回溯清空后，未存入任何结果 result.add(new ArrayList<>(res)); return; } //遍历nums中的每个数字 枚举每个位置放什么数 for(int i = 0; i < len; i++){ if(!state[i]){ //剪枝 不满足条件则跳过 //标记该数字本次排列已经使用过 state[i] = true; res.add(nums[i]); //递归继续遍历其他数字 dfs(nums, index + 1); //回溯 恢复初始状态 state[i] = false; res.remove(res.size() - 1); } } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
47. 全排列 II
题目链接
给定一个可包含重复数字的序列 nums ，按任意顺序 返回所有不重复的全排列
题目分析
1、对数组从小到大排序，使得相同的数都是相邻的；
2、从前往后枚举当前数组中没有选过的元素，由于相同的数保证从第一个开始用，直到最后一个，才会保证枚举的顺序不会出现重复的情况，若nums[i] == nums[i - 1]，并且i - 1位置元素未使用过，则表示前面的枚举顺序已经存在了该枚举情况，造成重复；
3、将枚举到的元素插入到当前存数字的链表t中，并标记为已使用过，递归到下一层，直到枚举完所有数为止（u == n），把当前链表t加入到存列表的result列表中，并进行回溯，恢复现场，把使用过的标记为未使用过。
这里给出的搜索顺序为：依次枚举每个位置放什么数
代码实现
class Solution { //DFS+回溯+去重 时间复杂度 O(n∗n!) 每个位置放什么数 //关键在于如何去重：首先对数组从小到大排序，使得相同的数都是相邻的； //然后从前往后枚举当前数组中没有选过的元素，由于相同的数保证从第一个开始用，直到最后一个， //才会保证枚举的顺序不会出现重复的情况，若nums[i]==nums[i - 1]，并且i-1位置元素状态为未使用， //则表示前面的枚举顺序已经存在了该枚举情况，造成重复 int len; List<Integer> res = new ArrayList<Integer>(); List<List<Integer>> result = new ArrayList<List<Integer>>(); boolean[] state; public List<List<Integer>> permuteUnique(int[] nums) { len = nums.length; state = new boolean[len]; Arrays.sort(nums); dfs(nums, 0); return result; } public void dfs(int[] nums, int index){ //终止条件 index表示当前排列的长度 if(index == len){ result.add(new ArrayList<>(res)); return; } //遍历nums中的每个数字 for(int i = 0; i < len; i++){ //如果与前一个数字相等且前一个数字的状态为true,说明刚被使用，不会重复排列，继续 //如果与前一个数字相等且前一个数字的状态为false,说明前一个数字在上一轮已使用并回溯为未使用状态， //继续递归得到的排列是和上一轮重复的，因此剪枝去重 if(i > 0 && nums[i] == nums[i - 1] && !state[i - 1]) continue; //未使用 if(!state[i]){ //不满足未使用该数的条件则不执行 剪枝 //标记该数字本次排列已经使用 state[i] = true; res.add(nums[i]); dfs(nums, index + 1); //回溯，恢复初始状态 state[i] = false; res.remove(res.size() - 1); } } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
78. 子集
给你一个整数数组 nums ，数组中的元素 互不相同 。返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
题目分析
搜索顺序为：依次枚举数组中每个位置的数 选 还是 不选，
不断递归到下一层，当index == nums.length时，表示有一种满足题意的情况看，加入到result 列表中
代码实现
class Solution { //DFS+回溯 枚举每个位置的数选还是不选，并递归到下一层 //时间复杂度：O(n×2^n )。一共 2^n个状态，每种状态需要O(n) 的时间来构造子集。空间复杂度：O(n) List<List<Integer>> result = new ArrayList<>(); List<Integer> path = new ArrayList<>(); public List<List<Integer>> subsets(int[] nums) { result.clear(); dfs(nums, 0); return result; } public void dfs(int[] nums, int index){ //终止条件 if(index == nums.length) { result.add(new ArrayList(path)); return; } //不选 直接跳过该数 执行下方语句得到[] dfs(nums, index + 1); //选 初始时index=2 得到[3] path.add(nums[index]); //继续递归，对下一个数进行选择 dfs(nums, index + 1); //回溯 path.remove(path.size() - 1); } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
90. 子集 II
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。
解集 不能 包含重复的子集。返回的解集中，子集可以按 任意顺序 排列。
题目分析
搜索顺序为：依次枚举数组中每个位置的数 选 还是 不选，
先对数组从小到大排序，每个数有选和不选两种情况，若选的话，假设上一个数与当前数一致，且上一个数没有选，则当前数一定不能选，否则会产生重复情况
需要注意的是先做不选，因此index索引是由大到小执行选择的。
代码实现
class Solution { //DFS + 回溯 + 去重 时间复杂度：O(n×2^n) //先对数组从小到大排序，每个数有选和不选两种情况， //若选的话，假设上一个数与当前数一致，且上一个数状态为未选，则当前数一定不能选，否则会产生重复情况 List<Integer> path = new ArrayList<>(); List<List<Integer>> result = new ArrayList<>(); boolean[] state; public List<List<Integer>> subsetsWithDup(int[] nums) { state = new boolean[nums.length]; Arrays.sort(nums); //O(nlogn) dfs(nums, 0); return result; } public void dfs(int[] nums, int index){ //终止条件 index表示自己长度，也表示访问nums的索引 if(index == nums.length){ result.add(new ArrayList(path)); return; } //先考虑不选 dfs(nums, index + 1); //选 index由大到小 如1 2 2 index=2 跳过 index = 1 选得到[2]、[2,2] //去重 如果上一个数与当前数相等，且上一个数状态为未选，当前数一定不能选，否则重复 if(index > 0 && nums[index] == nums[index - 1] && !state[index - 1]) return; if(!state[index]){ //剪枝 state[index] = true; path.add(nums[index]); //继续递归 dfs(nums, index + 1); //回溯 path.remove(path.size() - 1); state[index] = false; } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
216. 组合总和 III *****
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
说明：
所有数字都是正整数。
解集不能包含重复的组合。
题目分析
1、搜索顺序为：依次枚举每个数从哪个位置选；
2、考虑参数dfs(int k, int n, int index, int count, int sum)：k表示只能用k个数，n表示题目给定需要用k个数凑出来的总值，index表示从哪个数开始往下枚举，避免重复，count表示目前用的数的个数，sum表示当前已经凑出来的总值
3、如果当前用了数是x，那下一次枚举的位置 index 就需要从x + 1（或index+1）开始枚举，避免重复操作；
代码实现
class Solution { //DFS + 回溯 依次枚举每个数从哪个位置(1-9)上选 List<Integer> path = new ArrayList<>(); List<List<Integer>> result = new ArrayList<>(); public List<List<Integer>> combinationSum3(int k, int n) { //小优化 if(n < k || k > 9 || n > 45) return result; dfs(k, n, 1, 0, 0); return result; } //需要的参数（k, n，开始枚举的位置， 枚举到第几个数，当前选择的数的总和） public void dfs(int k, int n, int index, int count, int sum){ //终止条件 if(sum > n || count > k) return; //剪枝 if(k == count){ if(sum == n) result.add(new ArrayList(path)); return; } //枚举每个数 for(int i = index; i <= 9; i++){ path.add(i); //继续枚举凑和 dfs(k, n, i + 1, count + 1, sum + i); //回溯 恢复初始状态 path.remove(path.size() - 1); } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
51. N 皇后 *****
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案，该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
题目分析
皇后，是国际象棋中的棋子，意味着国王的妻子。皇后只做一件事，那就是“吃子”。当她遇见可以吃的棋子时，就迅速冲上去吃掉棋子。当然，她横、竖、斜都可走一到七步，可进可退。
搜索顺序： 依次枚举确定每行皇后的位置
DFS + 回溯 ，注意顺序！！！
1、递归终止条件：当皇后来到martix.length - 1的位置的时候，就已经是摆放皇后的最后一个位置了，然后用一个变量来记录当前皇后的递归深度：y，所以递归终止条件: y == n 时退出递归。
2、利用for 循环来遍历二维矩阵的所有列，使得皇后在每个列上作为开头找到对应的组合方案(递归)
3、题目中说到，在摆放的当前皇后的位置的同一行，同一列，同一斜率的方向都不能摆放其他皇后，这就是剪枝条件了。
- 首先是不让皇后在同一行上，只要我们成功摆放了一个皇后，就进入递归，去到下一行摆放新皇后的位置。
- 然后是不让皇后在同一列上：定义一个标志各列是否有皇后的布尔型数组column[]，只要成功摆放一个皇后的位置，就把当前列对应的数组索引元素置为true，后面的皇后只要发现此列为true，说明后面的皇后与前面的皇后处于同一列，当前列位置不能进行摆放。
- 最后是同一斜率，其实就是过当前位置的45度斜线和135斜线，如下图；通过当前位置可以就得参数c1和c2，若其他位置执行两个斜线函数的结果也等于c1，c2，说明在这两条斜线上，不能放置皇后（这里使用两个数组分别标志c1和c2）。
代码实现
class Solution { //DFS + 回溯 排列枚举(见官方) 时间复杂度：O(N!)，其中N是皇后数量,空间复杂度：O(N) //具有如下标准：不能同行 不能同列 不能同斜线 （45度和135度） int N = 20; //后面y-x+n可能为8-0+9=17因此设为20 写为20是为了避免处理越界的情况 boolean[] column = new boolean[N]; //标志当前列是否有皇后 boolean[] dg = new boolean[N]; //45度斜线 boolean[] udg = new boolean[N]; //135度斜线 char[][] chessboard = new char[N][N]; List<List<String>> result = new ArrayList<>(); public List<List<String>> solveNQueens(int n) { result.clear(); //构造棋盘 先用空位填满 for(int i = 0; i < n; i++){ for(int j = 0; j < n; j++){ chessboard[i][j] = '.'; } } dfs(n, 0); return result; } //明确两点：一次根节点到叶子节点就代表一种解法；总解法数不会超过n public void dfs(int n, int y){ //终止条件 y表示当前行数 if(y == n){ //存储当前解法 List<String> path = new ArrayList<>(); for(int i = 0; i < n; i++){ String temp = ""; for(int j = 0; j < n; j++){ //存储具体的每种解法 temp += chessboard[i][j]; } path.add(temp); } result.add(path); return; } //确定皇后的位置 x表示当前列 for(int x = 0; x < n; x++){ //剪枝 //y+x-c1=0经过棋盘每个点(i,index)的135度斜线，c2=y-x经过棋盘每个点的45度斜线 //由y和x可以求出参数c1,c2,从而可以判断其他点是否在斜线上，若在，则不能放皇后 if(!column[x] && !dg[y - x + n] && !udg[y + x]){ //这里+n是为了便于存储（y-x可能为负数） //标志该列以及两条斜线上不能放皇后 column[x] = dg[y - x + n] = udg[y + x] = true; //放皇后 chessboard[y][x] = 'Q'; //当确定一个皇后就进入递归确定本解法中下一行皇后的位置，从而保证皇后不再同一行上 dfs(n, y + 1); //回溯 便于寻找下一种解法 chessboard[y][x] = '.'; column[x] = dg[y - x + n] = udg[y + x] = false; } } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
52. N皇后 II
n 皇后问题 研究的是如何将 n 个皇后放置在 n × n 的棋盘上，并且使皇后彼此之间不能相互攻击。
给你一个整数 n ，返回 n 皇后问题 不同的解决方案的数量。
题目分析
和51解法基本一致，分析这里给出另一种参考代码，对斜线的处理相对更容易理解
参考
代码实现
class Solution { //DFS + 回溯 排列枚举(见官方) 时间复杂度：O(N!)，其中N是皇后数量,空间复杂度：O(N) //具有如下标准：不能同行 不能同列 不能同斜线 （45度和135度） int result = 0; int N = 20; //这里写为20是为了避免处理越界的情况 boolean[] dg = new boolean[N]; //45度斜线 boolean[] udg = new boolean[N]; //135度斜线 boolean[] column = new boolean[N]; //列 public int totalNQueens(int n) { dfs(n, 0); return result; } public void dfs(int n, int y){ //终止条件 if(y == n){ //y表示第几行 result++; //如果无解(如n=3,最后有y=2<n)，根本不会执行这里的代码 return; } for(int x = 0; x < n; x++){ //x表示第几列 //如果满足基本规则 不满足则跳过（剪枝） if(!column[x] && !dg[x+y] && !udg[y-x+n]){ //由于y-x可能为负数，+n便于存储 //标志已经放了皇后，满足下方条件的位置不能放皇后了 column[x] = dg[x+y] = udg[y-x+n] = true; //继续递归放置其他皇后，进入下一行 dfs(n, y + 1); //回溯 恢复初始状态寻找下一种解法 column[x] = dg[x+y] = udg[y-x+n] = false; } } } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
37. 解数独
编写一个程序，通过填充空格来解决数独问题。
数独的解法需 遵循如下规则：
数字 1-9 在每一行只能出现一次。
数字 1-9 在每一列只能出现一次。
数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。（请参考示例图）
数独部分空格内已填入了数字，空白格用 ‘.’ 表示。
题目分析
八皇后问题和本题中的解数独问题都可以归类于精确覆盖问题，使用Dancing Links算法可以完美解决
DFS + 回溯 搜索顺序为： 从前往后从上到下依次枚举每个空格该填哪个数
这道题还是按DFS+回溯框架解题就可以，但是要通过调试代码想清楚每一行代码的意义，特别是回溯部分，存在以下含义：
- 如果当前尝试的填法不满足基本规则，则恢复棋盘，重新填下一个暂时满足规则的数；
- 如果填完当前行还是不满足基本规则，就再次回溯，直到找到当前行正确的填数顺序，再开始填下一行;
- 如果当前行始终找不到正确的填数顺序，则回到x-1的那一层进行回溯重填，也就是重填上一行，，直到正确
代码实现
class Solution { //DFS + 回溯 从前往后枚举每个空格该填哪个数 //基本规则； 同行不能重复 同列不能重复 同一个九宫格内不能重复 boolean[][] row = new boolean[10][10]; //记录每行中使用了哪些数 如row[0][5]=true表示第一行使用了5 boolean[][] col = new boolean[10][10]; //记录每列中使用了哪些数 如col[0][5]=true表示第一列使用了5 这里写为10是为了防止越界 //记录每个九宫格中使用了哪些数 如cell[4/3][4/3][8]=true表示第1行第1列的九宫格中使用了8 boolean[][][] cell = new boolean[3][3][10]; public void solveSudoku(char[][] board) { //初始化 for(int i = 0; i < 9; i++){ //遍历行 for(int j = 0; j < 9; j++){ //遍历列 //分别在row,col,cell中记录已经有数的位置并记录是哪个数，避免重复 if(board[i][j] != '.'){ int temp = board[i][j] - '0'; row[i][temp] = col[j][temp] = cell[i / 3][j / 3][temp] = true; } } } //从（0，0）开始依次枚举每个空格该填哪个数 dfs(board, 0, 0); } //递归枚举每个空格应该填什么数 x表示当前行，y表示当前列 public boolean dfs(char[][] board, int x, int y){ //判断边界 if(y == 9){ //遍历完该行所有列则继续遍历下一行 x++; y = 0; //终止条件，遍历完所有行所有列，说明已完成填数 if(x == 9) return true; } //跳过已经填了数的位置 if(board[x][y] != '.'){ return dfs(board, x, y + 1); } //在递归所枚举的空格处 枚举1-9中的每个数 尝试填数 for(int i = 1; i <= 9; i++){ //如果待填数不满足基本规则，则跳过 剪枝 if(row[x][i] || col[y][i] || cell[x / 3][y / 3][i]) continue; //填数 记得强转类型 board[x][y] = (char)('0' + i); //更新状态 row[x][i] = col[y][i] = cell[x / 3][y / 3][i] = true; //继续填下一个空格 if(dfs(board, x, y + 1)) return true; //回溯 //如果当前尝试的填法不满足基本规则，则恢复棋盘，重新填下一个暂时满足规则的数， //如果填完当前行还是不满足基本规则，就不断回溯重填，直到找到当前行正确的填数顺序，再开始填下一行; //如果当前行始终找不到正确的填数顺序，则回到x-1的那一层进行回溯重填，也就是重填上一行，直到正确 board[x][y] = '.'; row[x][i] = col[y][i] = cell[x / 3][y / 3][i] = false; } //如果该空格处9个数都试完了都不行，返回false，恢复现场 //如果恢复到x=初始值, y=初始值还是不行，说明无解，返回false，程序停止 return false; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
473. 火柴拼正方形****
还记得童话《卖火柴的小女孩》吗？现在，你知道小女孩有多少根火柴，请找出一种能使用所有火柴拼成一个正方形的方法。不能折断火柴，可以把火柴连接起来，并且每根火柴都要用到。
输入为小女孩拥有火柴的数目，每根火柴用其长度表示。输出即为是否能用所有的火柴拼成正方形。
题目分析
DFS + 回溯 且必须用好剪枝 搜索顺序为：依次拼正方形的每条边
本题是关于剪枝的经典问题，遵循以下策略：
1、总长度应是4的倍数，火柴个数不能小于4以及最长的火柴不能大于正方形边长；
2、将火柴从大到小排序，进行搜索，这样每次剪枝去掉的分支会更多；
3、如果当前木棍填充失败，那么跳过接下来所有相同长度的木棍；
4、如果当前木棍填充失败，且是当前边的第一个，则直接剪掉当前分支(直接返回false)，因为这说明还没有使用的最长的火柴找不到可匹配的组合。
5、如果当前木棍填充失败，并且是当前边的最后一个，则直接剪掉当前分支，因为火柴已经被降序排列，当前火柴之后的火柴 和 当前边长度curLen 的和必然小于边的目标长度singleLen。
策略3、4、5可以让程序从100+ms，变成0-8ms。
代码实现
class Solution { //DFS + 回溯 时间复杂度：O(4^N) //基本规则：每条边目标长度固定不能超出(正方形每条边相等) 每根火柴都要使用且不重复使用 //本题重点是如何剪枝 遵循以下策略： // 1. 总长度应是4的倍数，火柴个数不能小于4以及最长的火柴不能大于正方形边长； // 2. 每条边的内部木棍长度从大到小填 // 3. 如果当前木棍填充失败，那么跳过接下来所有相同长度的木棍 // 4. 如果当前木棍填充失败，并且是当前边的第一个，则直接剪掉当前分支 // 5. 如果当前木棍填充失败，并且是当前边的最后一个，则直接剪掉当前分支 //策略3、4可以让程序从100+ms，变成0-8ms。 boolean[] state; public boolean makesquare(int[] nums) { //首先考虑特殊情况 if(nums.length < 4) return false; //求和 因为是正方形，总长度应该是4的倍数 如果最大的数大于正方形边长直接不满足基本规则 int sum = IntStream.of(nums).sum(); if(sum % 4 != 0 || nums[0] > sum / 4) return false; //使数组元素降序 2. 每条边的内部木棍长度从大到小填 nums = IntStream.of(nums).boxed().sorted(Comparator.reverseOrder()).mapToInt(Integer::intValue).toArray(); state = new boolean[nums.length]; return dfs(nums, 0, 0, sum / 4); } //dfs(nums,当前边,每条边当前长度,每条边目标长度) public boolean dfs(int[] nums, int index, int curLen, int singleLen){ //当前边达到目标长度就进入下一条边 if(curLen == singleLen){ index++; //终止条件 if(index == 4) return true; curLen = 0; } //枚举每条边由哪些火柴组成 for(int i = 0; i < nums.length; i++){ //剪枝 保证火柴未使用或拼接该火柴后当前边长度小于目标长度 if(!state[i] && curLen + nums[i] <= singleLen){ //标记当前火柴已经使用过 state[i] = true; //继续寻找当前边的下一根火柴 if(dfs(nums, index, curLen + nums[i], singleLen)) return true; //回溯 //如果当前尝试的拼法不满足基本规则，则去掉当前火柴，重新选择下一个暂时满足规则的火柴， //如果拼完当前边不满足基本规则，就不断回溯重拼，直到找到当前边正确拼法，再开始拼下一条边; //如果当前边无法正确拼接，则回到index-1的那一层进行回溯重填，也就是重拼上一条边，直到正确 state[i] = false; //剪枝 //3.如果当前火柴填充失败，那么跳过接下来所有相同长度的火柴 while(i + 1 < nums.length && nums[i + 1] == nums[i]) i++; //4.执行到这里说明当前火柴填充失败，满足if条件说明当前火柴是当前边的第一个， //这说明未使用的最长的火柴找不到可匹配的组合，因此直接剪掉当前分支 if(curLen == 0) return false; //5.执行到这里说明当前火柴填充失败，若满足if条件，由于火柴已被降序排列， //当前火柴之后的火柴 和 curLen 的和必然小于等于singleLen, 因此直接剪掉当前分支 if(curLen + nums[i] == singleLen) return false; } } return false; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
或者
class Solution { boolean[] state; int n; public boolean makesquare(int[] nums) { n = nums.length; if(n < 4) return false; int sum = 0; for(int i : nums) sum += i; Arrays.sort(nums); if(sum % 4 != 0 || nums[n - 1] > sum / 4) return false; state = new boolean[n]; return dfs(nums, 0, 0, sum / 4); } private boolean dfs(int[] nums, int index, int curLen, int singleLen){ if(curLen == singleLen){ index++; if(index == 4) return true; curLen = 0; } for(int i = n - 1; i >= 0; i--){ if(!state[i] && curLen + nums[i] <= singleLen){ state[i] = true; if(dfs(nums, index, curLen + nums[i], singleLen)) return true; state[i] = false; //如果当前长度填充失败，则相同长度都跳过 while(i > 0 && nums[i] == nums[i - 1]) i--; //如果当前火柴是当前边第一个，填充失败，则未使用的最长的火柴找不到匹配的，当前填法不行 if(curLen == 0) return false; //如果当前火柴填充失败，则小于等于当前火柴长度的火柴都会填充失败 if(curLen + nums[i] == singleLen) return false; } } return false; } }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
本文内容由网友自发贡献，转载请注明出处：https://www.wpsshop.cn/w/IT小白/article/detail/399165
推荐阅读
相关标签
