文章目录

系列文章目录
前言
题录
- 131. 分割回文串
- 93. 复原 IP 地址
- 78. 子集
- 90. 子集 II
- 46. 全排列
- 47. 全排列 II
- 491. 递增子序列

系列文章目录

一、数组类型解题方法一：二分法
二、数组类型解题方法二：双指针法
三、数组类型解题方法三：滑动窗口
四、数组类型解题方法四：模拟
五、链表篇之链表的基础操作和经典题目
六、哈希表篇之经典题目
七、字符串篇之经典题目
八、字符串篇之 KMP
九、解题方法：双指针
十、栈与队列篇之经典题目
十一、栈与队列篇之 top-K 问题
十二、二叉树篇之二叉树的前中后序遍历
十三、二叉树篇之二叉树的层序遍历及相关题目
十四、二叉树篇之二叉树的属性相关题目
十五、二叉树篇之二叉树的修改与构造
十六、二叉树篇之二叉搜索树的属性
十七、二叉树篇之公共祖先问题
十八、二叉树篇之二叉搜索树的修改与构造
十九、回溯算法篇之组合问题
更新中 … …

前言

刷题路线来自：代码随想录
切割问题： 一个字符串按一定规则有几种切割方式
子集问题： 一个N个数的集合里有多少符合条件的子集
排列问题： N个数按一定规则全排列，有几种排列方式

题录

131. 分割回文串

Leetcode 链接
给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文串。返回 s 所有可能的分割方案。回文串是正着读和反着读都一样的字符串。

题解：

递归参数：可以传入 s，然后传入下层递归开始的下标，然后在下层分割字符串，也可以将字符串分割好作为参数，这里选择后者
收集结果：s 字符串无法再分割，即长度为 0 时（同结束条件）
剪枝：分割的部分子串不是回文串，continue 进行下次分割

class Solution {List<List<String>> res = new ArrayList<>();List<String> list = new ArrayList<>();public List<List<String>> partition(String s) {backtracking(s);return res;}public void backtracking(String s) {if (s.length() == 0) {res.add(new ArrayList<>(list));return;}// s 为没有分割过的子串，从头分割for (int i = 1; i <= s.length(); i++) {// 分割部分不是回文串if (!isE(s, 0, i)) continue;list.add(s.substring(0, i));// s.substring(i, s.length())：下层递归分割backtracking(s.substring(i, s.length()));// 回溯list.remove(list.size() - 1);}}// 判断回文串public boolean isE(String s, int l, int r) {r--;while (l < r) {if (s.charAt(l) != s.charAt(r)) {return false;}l++;r--;}return true;}
}

93. 复原 IP 地址

Leetcode 链接

题解： 相比上一题，细节繁多

回溯对象：StringBuilder 拼接 IP ，拼接前记录下长度，回溯时作为删除末尾子串的下标起始位置
收集结果：刚好分割为 4 个整数，并且字符串刚好分割完
返回列表：接下来要分割是子串 s，conut 记录分割的整数个数
结束条件/剪枝：分割的整数大于 255、前导有 0、分割的整数个数大于 4

class Solution {List<String> res = new ArrayList<>();StringBuilder sb = new StringBuilder();public List<String> restoreIpAddresses(String s) {backtracking(s, 0);return res;}public void backtracking(String s, int count) {if (s.length() == 0 && count == 4) {// 刚好分割为 4 个整数，删除拼接时的'.'，添加到返回列表sb.deleteCharAt(sb.length() - 1);res.add(new String(sb));return;}for (int i = 1; i <= s.length() && (count < 4); i++) {int num = Integer.valueOf(s.substring(0, i));// 结束条件,还有一个放在了for 循环的判断中if ((i > 1 && s.charAt(0) == '0') || num > 255) {return;}// 记录拼接前下标用来回溯int idx = sb.length();// 拼接sb.append(num).append('.');backtracking(s.substring(i, s.length()), count + 1);// 回溯sb.delete(idx, sb.length());}}
}

78. 子集

Leetcode 链接
给你一个整数数组 nums ，数组中的元素互不相同。返回该数组所有可能的子集（幂集）。解集不能包含重复的子集。你可以按任意顺序返回解集。

题解：

回溯对象：路径
收集结果：收集路径上的所有结果，注意还有一个额外的空集
结束条件：自然结束，因为套搜索到所有结果
参数列表：每层递归数组的起始位置

class Solution {List<List<Integer>> res = new ArrayList<>();List<Integer> path = new ArrayList<>();public List<List<Integer>> subsets(int[] nums) {res.add(path);backtracking(nums, 0);return res;}public void backtracking(int[] nums, int start) {for (int i = start; i < nums.length; i++) {// 收集路径上的所有结果path.add(nums[i]);res.add(new ArrayList<>(path));// 是 i + 1, 不是 start + 1backtracking(nums, i + 1);// 回溯path.remove(path.size() - 1);}}
}

90. 子集 II

Leetcode 链接
给你一个整数数组 nums ，其中可能包含重复元素，请你返回该数组所有可能的子集（幂集）。解集不能包含重复的子集。返回的解集中，子集可以按任意顺序排列。

题解： 相比上题，需要增加去重操作

回溯对象：路径
收集结果：同上题收集路径上所有结果
结束条件/剪枝：自然结束
去重：排序后，同层第一次出现的数不用去重，连续出现的数除第一个外全部 continue 跳过

class Solution {List<List<Integer>> res = new ArrayList<>();List<Integer> path = new ArrayList<>();public List<List<Integer>> subsetsWithDup(int[] nums) {res.add(path);Arrays.sort(nums);backtracking(nums, 0);return res;}public void backtracking(int[] nums, int start) {for(int i = start; i < nums.length; i++) {if (i > start && nums[i] == nums[i - 1]) {// 同层不是第一次出现continue;}path.add(nums[i]);res.add(new ArrayList<>(path));backtracking(nums, i + 1);path.remove(path.size() - 1);}}
}

46. 全排列

Leetcode 链接
给定一个不含重复数字的数组 nums ，返回其所有可能的全排列。你可以按任意顺序返回答案。

题解：

回溯对象：路径，boolean[ ] used
收集结果：路径长度等于数组长度 （同结束条件）
递归参数：因为全排列每层递归从头开始遍历，只需跳过已经过的数，无需 startIndex
去重操作：每一层递归可用的数都在减少，上题去重只需一个判断，而这里去重的数太多，所以要使用 set 来记录，当然我们也可以使用数组 boolean[ ] used 当遇到已经使用过的数，continue 跳过

class Solution {List<List<Integer>> res = new ArrayList<>();List<Integer> path = new ArrayList<>();boolean[] used;public List<List<Integer>> permute(int[] nums) {used = new boolean[nums.length];backtracking(nums);return res;}public void backtracking(int[] nums) {if (path.size() == nums.length) {// 长度判断，收集结果res.add(new ArrayList<>(path));return;}for (int i = 0; i < nums.length; i++) {if (used[i] == true) {// 使用过continue;}// 记录新的路径，并标记已经使用过path.add(nums[i]);used[i] = true;backtracking(nums);// 回溯path.remove(path.size() - 1);used[i] = false;}}}

47. 全排列 II

Leetcode 链接
给定一个可包含重复数字的序列 nums ，按任意顺序返回所有不重复的全排列。

题解：

回溯对象：路径，boolean[ ] used
收集结果：路径长度等于数组长度 （同结束条件）
递归参数：因为全排列每层递归从头开始遍历，只需跳过已经过的数，无需 startIndex
去重操作：
1.每一层递归可用的数都在减少，上题去重只需一个判断，而这里去重的数太多，所以要使用 set 来记录，当然我们也可以使用数组 boolean[ ] used 当遇到已经使用过的数，continue 跳过
2.层去重，同子集二，先排序再判断是否当前层第一次出现

哈希去重:

class Solution {List<List<Integer>> res = new ArrayList<>();List<Integer> path = new ArrayList<>();boolean[] used;public List<List<Integer>> permuteUnique(int[] nums) {used = new boolean[nums.length];Arrays.sort(nums);backtracking(nums);return res;}public void backtracking(int[] nums) {if (path.size() == nums.length) {res.add(new ArrayList<>(path));return;}for (int i = 0; i < nums.length; i++) {if (used[i] == true) {continue;}if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {continue;}path.add(nums[i]);used[i] = true;backtracking(nums);path.remove(path.size() - 1);used[i] = false;}}
}

排序去重：

class Solution {private List<List<Integer>> res = new ArrayList<>();private List<Integer> path = new ArrayList<>();private boolean[] used = null;public List<List<Integer>> permuteUnique(int[] nums) {used = new boolean[nums.length];//Arrays.sort(nums);backtracking(nums);return res;}public void backtracking(int[] nums) {if (path.size() == nums.length) {res.add(new ArrayList<>(path));return;}HashSet<Integer> hashSet = new HashSet<>();//层去重for (int i = 0; i < nums.length; i++) {if (hashSet.contains(nums[i]))continue;if (used[i] == true)//枝去重continue;hashSet.add(nums[i]);//记录元素used[i] = true;path.add(nums[i]);backtracking(nums);path.remove(path.size() - 1);used[i] = false;}}
}

491. 递增子序列

Leetcode 链接
给你一个整数数组 nums ，找出并返回所有该数组中不同的递增子序列，递增子序列中至少有两个元素。你可以按任意顺序返回答案。数组中可能含有重复元素，如出现两个整数相等，也可以视作递增序列的一种特殊情况。

题解：

回溯对象：路径
收集结果：路径长度 大于等于 2，收集结果完不可以 return
递归参数：因为全排列每层递归从头开始遍历，只需跳过已经过的数，无需 startIndex
结束条件/剪枝：不递增时 continue，注意不递增的判断 是 path 的最后一个数和当前数对比
去重操作：因为这里的数组无序切不能排序，使用 set 进行层去重，发现同层不是第一次出现 continue。

class Solution {List<List<Integer>> res = new ArrayList<>();List<Integer> path = new ArrayList<>();public List<List<Integer>> findSubsequences(int[] nums) {backtracking(nums, 0);return res;}public void backtracking(int[] nums, int startIndex) {if (path.size() >= 2) {res.add(new ArrayList<>(path));}Set<Integer> set = new HashSet<>();for (int i = startIndex; i < nums.length; i++) {//            if (i > 0 && nums[i - 1] > nums[i]) {   错误示范
//                continue;
//            }// 递增判断if (!path.isEmpty() && path.get(path.size() - 1) > nums[i]) {continue;}// 去重if (set.contains(nums[i])) {continue;}set.add(nums[i]);path.add(nums[i]);backtracking(nums, i + 1);// 回溯path.remove(path.size() - 1);}}
}

Leetcode 刷题笔记(二十) ——回溯算法篇之分割、子集、全排列问题相关推荐

Leetcode刷题笔记：栈与队列篇
基础知识栈和队列的原理大家应该很熟悉了,队列是先进先出,栈是先进后出. 如图所示: 那么我这里再列出四个关于栈的问题,大家可以思考一下.以下是以C++为例,使用其他编程语言的同学也对应思考一下,自己 ...
LeetCode刷题笔记（算法思想四）
LeetCode刷题笔记(算法思想四) 七.动态规划斐波那契数列 70. 爬楼梯 198. 打家劫舍 213. 打家劫舍 II 信件错排母牛生产矩阵路径 64. 最小路径和 62. 不同路径 ...
LeetCode刷题笔记2——数组2
LeetCode刷题笔记2--数组2 重塑数组题目在 MATLAB 中,有一个非常有用的函数 reshape ,它可以将一个 m x n 矩阵重塑为另一个大小不同(r x c)的新矩阵,但保留其原 ...
刷题笔记（十四）--二叉树：层序遍历和DFS,BFS
目录系列文章目录前言题录 102. 二叉树的层序遍历 BFS DFS_前序遍历 107. 二叉树的层序遍历 II BFS DFS 199. 二叉树的右视图 BFS DFS 637. 二叉树的层平 ...
leetcode刷题笔记——二分查找
leetcode刷题笔记--二分查找目前完成的贪心相关的leetcode算法题序号: 中等:80,81 困难:4 来源:力扣(LeetCode) 链接:https://leetcode-cn.com ...
卷进大厂系列之LeetCode刷题笔记：二分查找（简单）
LeetCode刷题笔记:二分查找(简单) 学算法,刷力扣,加油卷,进大厂! 题目描述涉及算法题目解答学算法,刷力扣,加油卷,进大厂! 题目描述力扣题目链接给定一个 n 个元素有序的(升序) ...
LeetCode刷题笔记汇总
LeetCode刷题笔记汇总第一次刷LeetCode写的一些笔记. 1.两数之和 3.无重复字符的最长子串 15.三数之和 18.四数之和 19.删除链表的倒数第 N 个结点 20.有效的括号 21 ...
LeetCode刷题笔记-动态规划-day4
文章目录 LeetCode刷题笔记-动态规划-day4 55. 跳跃游戏 1.题目 2.解题思路 3.代码 45. 跳跃游戏 II 1.题目 2.解题思路 3.代码 LeetCode刷题笔记-动态规划 ...
小何同学的leetcode刷题笔记基础篇（01）整数反转
小何同学的leetcode刷题笔记基础篇(01)整数反转[07] *** [01]数学取余法*** 对数字进行数位操作时,常见的方法便是用取余的方法提取出各位数字,再进行操作操作(1):对10取余 ...
【leetcode刷题笔记】动态规划
#[leetcode刷题笔记]动态规划石子游戏 public boolean stoneGame(int[] piles) {int N = piles.length;// dp[i][j] is ...

Leetcode 刷题笔记(二十) ——回溯算法篇之分割、子集、全排列问题