给大家的福利
零基础入门
对于从来没有接触过网络安全的同学,我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线,大家跟着这个大的方向学习准没问题。
同时每个成长路线对应的板块都有配套的视频提供:
因篇幅有限,仅展示部分资料
网络安全面试题
绿盟护网行动
还有大家最喜欢的黑客技术
网络安全源码合集+工具包
所有资料共282G,朋友们如果有需要全套《网络安全入门+黑客进阶学习资源包》,可以扫描下方二维码领取(如遇扫码问题,可以在评论区留言领取哦)~
需要体系化学习资料的朋友,可以加我V获取:vip204888 (备注网络安全)
网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
输入: candidates = [2], target = 1
输出: []
示例 4:
输入: candidates = [1], target = 1
输出: [[1]]
示例 5:
输入: candidates = [1], target = 2
输出: [[1,1]]
提示:
* 1 <= candidates.length <= 30
* 1 <= candidates[i] <= 200
* candidate 中的每个元素都是独一无二的。
* 1 <= target <= 500
💡 思路:
这道题和我们上面的有什么区别呢?
它没有数量要求,可以无限重复,但是有总和的限制。
![组合总和](https://img-blog.csdnimg.cn/img_convert/850fef372288cfe821be2d52e2f0ef9e.png)
这里有两个关键点:
* 元素可以重复使用
* 组合不可重复
我们看看如何通过回溯三要素来carry:
* 返回值&参数
参数里需要`start`标明起点,为什么呢?因为要求组合不重复,所以需要限制下次搜索的起点,是基于本次选择,这样就不会选到本次选择同层左边的数。
* 终止条件
这道题没有限制数的个数,所以我们要根据`pathSum>target`(当前组合不满足)和`pathSum==target`(当前组合满足)来终止递归。
* 单层逻辑
单层仍然从start开始,搜索 candidates。
🖊 代码:
class Solution {
//结果结合
List<List> result;
//结果路径
LinkedList path;
//结果路径值的和
int pathSum;
public List<List<Integer>> combinationSum(int[] candidates, int target) {
result = new ArrayList<>();
path = new LinkedList<>();
pathSum = 0;
backtrack(candidates, target, 0);
return result;
}
public void backtrack(int[] candidates, int target, int start) {
//终止条件
if (pathSum > target) return;
if (pathSum == target) {
result.add(new LinkedList<>(path));
}
for (int i = start; i < candidates.length; i++) {
pathSum += candidates[i];
path.push(candidates[i]);
//注意,i不用加1,表示当前数可以重复读取
backtrack(candidates, target, i);
//回溯
pathSum -= path.pop();
}
}
}
⚡ 剪枝优化
又到了剪枝优化时间,在本层循环,如果发现下一层的pathSum(本层pathSum+candidates[i]),那么就可以结束本层循环,注意要先把candidates拍一下序。
class Solution {
//结果结合
List<List> result;
//结果路径
LinkedList path;
//结果路径值的和
int pathSum;
public List<List<Integer>> combinationSum(int[] candidates, int target) {
result = new ArrayList<>();
path = new LinkedList<>();
pathSum = 0;
//剪枝优化,先排序
Arrays.sort(candidates);
backtrack(candidates, target, 0);
return result;
}
public void backtrack(int[] candidates, int target, int start) {
//终止条件
if (pathSum > target) return;
if (pathSum == target) {
result.add(new LinkedList<>(path));
}
//剪枝优化,判断循环之后的pathSum是否会超过target
for (int i = start; i < candidates.length && pathSum + candidates[i] <= target; i++) {
pathSum += candidates[i];
path.push(candidates[i]);
//注意,i不用加1,表示当前数可以重复读取
backtrack(candidates, target, i);
//回溯
pathSum -= path.pop();
}
}
}
### [LeetCode40. 组合总和 II](https://bbs.csdn.net/topics/618540462)
☕ 题目:40. 组合总和 II (https://leetcode-cn.com/problems/combination-sum-ii/)
❓ 难度:中等
📕 描述:
给定一个数组 candidates 和一个目标数 target ,找出 candidates 中所有可以使数字和为 target 的组合。
candidates 中的每个数字在每个组合中只能使用一次。
注意:解集不能包含重复的组合。
示例 1:
输入: candidates = [10,1,2,7,6,1,5], target = 8,
输出:
[
[1,1,6],
[1,2,5],
[1,7],
[2,6]
]
示例 2:
输入: candidates = [2,5,2,1,2], target = 5,
输出:
[
[1,2,2],
[5]
]
提示:
* 1 <= candidates.length <= 100
* 1 <= candidates[i] <= 50
* 1 <= target <= 30
💡 思路:
这道题和上一道题有啥区别呢?
* `candidates`里每个数字在每个组合里只能使用一次
* `candidates`里的元素是有重复的
所以这道题的关键在于:**集合(数组candidates)有重复元素,但还不能有重复的组合**。
关于这个去重,有什么思路呢?
* 利用`HashSet`的特性去重,但是容易超时
* 还有一种办法,先把数组排序[1,3,1] --> [1,1,3],我们比较一下相邻的元素,重复的就跳过
我们把模拟树画一下:
![模拟树](https://img-blog.csdnimg.cn/img_convert/54aaf9125ad93b9dc3d662aca8178d49.png)
三要素走起:
* 返回值&参数
和上一道基本一致。
* 终止条件
+ pathSum>target和pathSum==target。
+ 我们这次直接剪枝,提前判断下次pathSum是否大于target,所以pathSum>target可以省略
🖊 代码:
class Solution {
//结果集合
List<List> result;
//结果路径
LinkedList path;
//结果路径值总和
int pathSum;
public List<List<Integer>> combinationSum2(int[] candidates, int target) {
//排序condidates,去重前提
Arrays.sort(candidates);
//初始化相关变量
result = new ArrayList<>();
path = new LinkedList<>();
pathSum = 0;
backtrack(candidates, target, 0);
return result;
}
public void backtrack(int[] candidates, int target, int start) {
//终止条件
if (pathSum == target) {
result.add(new LinkedList<>(path));
return;
}
//剪枝操作
for (int i = start; i < candidates.length && candidates[i] + pathSum <= target; i++) {
//同一层使用过的元素跳过
if (i > start && candidates[i] == candidates[i - 1]) {
continue;
}
pathSum += candidates[i];
path.push(candidates[i]);
//每个数字在每个组合中只能用一次,所以i++
backtrack(candidates, target, i + 1);
//回溯
pathSum -= path.pop();
}
}
}
### [LeetCode17. 电话号码的字母组合](https://bbs.csdn.net/topics/618540462)
☕ 题目:17. 电话号码的字母组合(https://leetcode-cn.com/problems/letter-combinations-of-a-phone-number/)
❓ 难度:中等
📕 描述:
给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。答案可以按 任意顺序 返回。
给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。
![17](https://img-blog.csdnimg.cn/img_convert/8b0f94436f5923f93e71570694476671.png)
示例 1:
输入:digits = “23”
输出:[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]
示例 2:
输入:digits = “”
输出:[]
示例 3:
输入:digits = “2”
输出:[“a”,“b”,“c”]
提示:
* 0 <= digits.length <= 4
* digits[i] 是范围 [‘2’, ‘9’] 的一个数字。
💡 思路:
其实扒开表皮,这道题和`77.组合`本质上是一样。只不过序列和组合个数没有明确给出。
* 序列是什么:digits 映射成的字母序列
* 组合个数:digits的大小
先画抽象树:
![电话号码的字母组合](https://img-blog.csdnimg.cn/img_convert/bbfefca77f2cfb5b28837a26ca0fdd0e.png)
🖊 代码:
class Solution {
//结果集合
List result;
//结果
StringBuilder path;
//每个路径个数
int pathNum;
//映射数组,0,1空出来,方便直接映射
String[] numsMap = {" ", " ", “abc”, “def”, “ghi”, “jkl”, “mno”, “pqrs”, “tuv”, “wxyz”};
public List<String> letterCombinations(String digits) {
result = new ArrayList<>();
if (digits == null || digits.length() == 0) {
return result;
}
path = new StringBuilder();
pathNum = 0;
backtrack(digits, pathNum);
return result;
}
public void backtrack(String digits, int pathNum) {
if (pathNum == digits.length()) {
result.add(path.toString());
return;
}
//获取映射字母
String letters = numsMap[digits.charAt(pathNum) - '0'];
for (int i = 0; i < letters.length(); i++) {
path.append(letters.charAt(i));
//注意,pathNum+1,要处理下一层
backtrack(digits, pathNum + 1);
//回溯
path.deleteCharAt(path.length() - 1);
}
}
}
## 分割问题
### [LeetCode131. 分割回文串](https://bbs.csdn.net/topics/618540462)
☕ 题目:131. 分割回文串 (https://leetcode-cn.com/problems/palindrome-partitioning/)
❓ 难度:中等
📕 描述:
给你一个字符串 s,请你将 s 分割成一些子串,使每个子串都是 回文串 。返回 s 所有可能的分割方案。
回文串 是正着读和反着读都一样的字符串。
示例 1:
输入:s = “aab”
输出:[[“a”,“a”,“b”],[“aa”,“b”]]
示例 2:
输入:s = “a”
输出:[[“a”]]
提示:
* 1 <= s.length <= 16
* s 仅由小写英文字母组成
💡 思路:
我们写了一些组合问题,现在又是一类新的问题——`分割`。
但其实,分割问题,也类似组合。
例如对于字符串abcdef:[1]
* 组合问题:选取一个a之后,在bcdef中再去选取第二个,选取b之后在cdef中在选组第三个…。
* 切割问题:切割一个a之后,在bcdef中再去切割第二段,切割b之后在cdef中在切割第三段…….
先画一下抽象树:
![分割回文串抽象树](https://img-blog.csdnimg.cn/img_convert/dd1b3486fbc97fc003effc463059b6d2.png)
回溯三要素:
* 参数
我们需要一个start来标记下一轮递归遍历的起始位置。
* 终止条件
如果start已经超过字符串的长度,那么说明我们path中的组合是回文串。
* 单层逻辑
单层逻辑和之前的逻辑大体类似,不过需要判断一下字符串是否是回文串,这个比较简单。
🖊 代码:
class Solution {
List<List> result;
LinkedList path;
public List<List<String>> partition(String s) {
result = new ArrayList<>();
path = new LinkedList<>();
backtrack(s, 0);
return result;
}
public void backtrack(String s, int start) {
//结束条件
if (start >= s.length()) {
result.add(new ArrayList<>(path));
return;
}
for (int i = start; i < s.length(); i++) {
//如果是回文串
if (isPalidrome(s, start, i)) {
String r = s.substring(start, i+1);
path.addLast(r);
} else {
continue;
}
//起始位置后移
backtrack(s, i + 1);
//回溯
path.removeLast();
}
}
//判断是否回文串
boolean isPalidrome(String s, int start, int end) {
for (int i = start, j = end; i < j; i++, j--) {
if (s.charAt(i) != s.charAt(j)) {
return false;
}
}
return true;
}
}
### [LeetCode93. 复原 IP 地址](https://bbs.csdn.net/topics/618540462)
☕ 题目:93. 复原 IP 地址 (https://leetcode-cn.com/problems/restore-ip-addresses/)
❓ 难度:中等
📕 描述:
给定一个只包含数字的字符串,用以表示一个 IP 地址,返回所有可能从 s 获得的 有效 IP 地址 。你可以按任何顺序返回答案。
有效 IP 地址 正好由四个整数(每个整数位于 0 到 255 之间组成,且不能含有前导 0),整数之间用 ‘.’ 分隔。
例如:“0.1.2.201” 和 “192.168.1.1” 是 有效 IP 地址,但是 “0.011.255.245”、“192.168.1.312” 和 “192.168@1.1” 是 无效 IP 地址。
示例 1:
输入:s = “25525511135”
输出:[“255.255.11.135”,“255.255.111.35”]
示例 2:
输入:s = “0000”
输出:[“0.0.0.0”]
示例 3:
输入:s = “1111”
输出:[“1.1.1.1”]
示例 4:
输入:s = “010010”
输出:[“0.10.0.10”,“0.100.1.0”]
示例 5:
输入:s = “101023”
输出:[“1.0.10.23”,“1.0.102.3”,“10.1.0.23”,“10.10.2.3”,“101.0.2.3”]
提示:
* 0 <= s.length <= 3000
* s 仅由数字组成
💡 思路:
这道题是不是和上一道题类似啊。
我们先把抽象树画一下:
![复原ip地址抽象树](https://img-blog.csdnimg.cn/img_convert/69a422795ce6ef54e0dee297670b7141.png)
分支比较多,偷懒省去了一些分支。
直接上回溯三要素:
* 参数
因为ip为四段构成,所以我们需要一个参数来记录段数,这里用的是剩余的段数`residue`;
分割问题,需要标记`start`。
* 终止条件
终止条件是切割到了终点;
但是这道题又有段数的要求,所以还要加入段数的判断。
* 单层
单层里面,除了回溯之类,我们还要判断当前段是否满足构成ip的要求。
🖊 代码:
class Solution {
List res = new ArrayList<>();
Deque path = new ArrayDeque<>(4);
int len;
public List<String> restoreIpAddresses(String s) {
len = s.length();
if (len > 12 || len < 4) return res;
backtrack(s, 0, 4);
return res;
}
/\*\*
*
* @param s 字符串
* @param start 起始位置
* @param residue 剩余段数
*/
private void backtrack(String s, int start, int residue) {
//符合要求
//字符已经用完,而且为四段
if (start == len && residue == 0) {
res.add(String.join(“.”, path));
return;
}
for (int i = start; i < start + 3; i++) {
if (i >= len) break;
//减枝
if (residue * 3 < len - i) continue;
//只有符合要求的才加入
if (isIpSegment(s, start, i)) {
String currentIpSegment = s.substring(start, i + 1);
path.addLast(currentIpSegment);
backtrack(s, i + 1, residue - 1);
//回溯
path.removeLast();
}
}
}
//判断字串是否符合ip要求
private boolean isIpSegment(String s, int left, int right) {
//首位0情况
if (right - left + 1 > 1 && s.charAt(left) == '0') return false;
//判断对应数字是否满足范围
int num = 0;
for (int i = left; i <= right; i++) {
num = num \* 10 + s.charAt(i) - '0';
}
return num >= 0 && num <= 255;
}
}
## 子集问题
### [LeetCode78. 子集](https://bbs.csdn.net/topics/618540462)
☕ 题目:78. 子集 (https://leetcode-cn.com/problems/subsets/)
❓ 难度:中等
📕 描述:
给你一个整数数组 nums ,数组中的元素 互不相同 。返回该数组所有可能的子集(幂集)。
解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。
示例 1:
输入:nums = [1,2,3]
输出:[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]
示例 2:
输入:nums = [0]
输出:[[],[0]]
提示:
* 1 <= nums.length <= 10
* -10 <= nums[i] <= 10
* nums 中的所有元素 互不相同
💡 思路:
这和我们前面做的 `77.组合`也是类似得。
先画抽象树结构:
![子集](https://img-blog.csdnimg.cn/img_convert/e9a962d224ab6c3bbd07e998bba4e388.png)
还是回溯三要素:
* 参数
组合不重复,所以`start`标记起点
* 终止条件
把数组所有元素用完,就终止递归,也就是start走到了最后一个位置。
* 单层逻辑
就一点需要注意,需要收集所有得组合。
🖊 代码:
class Solution {
List<List> result = new ArrayList<>();
LinkedList path = new LinkedList<>();
public List<List<Integer>> subsets(int[] nums) {
if (nums == null || nums.length == 0) {
return result;
}
backstrck(nums, 0);
return result;
}
public void backstrck(int[] nums, int start) {
//放在最上面,否则漏掉本次
result.add(new ArrayList<>(path));
//终止条件
if (start >=nums.length) {
return;
}
for (int i = start; i <nums.length; i++) {
path.addLast(nums[i]);
backstrck(nums, i + 1);
//回溯
path.removeLast();
}
}
}
### [LeetCode90. 子集 II](https://bbs.csdn.net/topics/618540462)
☕ 题目:90. 子集 II (https://leetcode-cn.com/problems/subsets-ii/)
❓ 难度:中等
📕 描述:
给你一个整数数组 nums ,其中可能包含重复元素,请你返回该数组所有可能的子集(幂集)。
解集 不能 包含重复的子集。返回的解集中,子集可以按 任意顺序 排列。
示例 1:
输入:nums = [1,2,2]
输出:[[],[1],[1,2],[1,2,2],[2],[2,2]]
示例 2:
输入:nums = [0]
输出:[[],[0]]
提示:
* 1 <= nums.length <= 10
* -10 <= nums[i] <= 10
💡 思路:
和上一道题有一点不一样,`nums`里面有重复的元素,而要保持组合的惟一,我们得想一个去重的办法。
前面的`40. 组合总和 II` 还记得吗?那道题里序列里同样有重复的元素。
我们是怎么去重的呢?先排序数组,相邻元素重复就跳过。
![子集II抽象树](https://img-blog.csdnimg.cn/img_convert/a8f8a6ab17fb09848aa920b454d1c612.png)
🖊 代码:
class Solution {
List<List> result = new ArrayList<>();
LinkedList path = new LinkedList<>();
public List<List<Integer>> subsetsWithDup(int[] nums) {
if (nums == null || nums.length == 0) {
result.add(new ArrayList<>());
return result;
}
//先排序数组
Arrays.sort(nums);
backtrack(nums, 0);
return result;
}
public void backtrack(int[] nums, int start) {
result.add(new ArrayList<>(path));
//终止条件
if (start >= nums.length) {
return;
}
for (int i = start; i < nums.length; i++) {
//先判断是否重复
if (i > start && nums[i] == nums[i - 1]) {
continue;
}
path.addLast(nums[i]);
backtrack(nums, i + 1);
//回溯
path.removeLast();
}
}
}
### [LeetCode491. 递增子序列](https://bbs.csdn.net/topics/618540462)
☕ 题目:491. 递增子序列 (https://leetcode-cn.com/problems/increasing-subsequences/)
❓ 难度:中等
📕 描述:
给你一个整数数组 nums ,找出并返回所有该数组中不同的递增子序列,递增子序列中 至少有两个元素 。你可以按 任意顺序 返回答案。
数组中可能含有重复元素,如出现两个整数相等,也可以视作递增序列的一种特殊情况。
示例 1:
输入:nums = [4,6,7,7]
输出:[[4,6],[4,6,7],[4,6,7,7],[4,7],[4,7,7],[6,7],[6,7,7],[7,7]]
示例 2:
输入:nums = [4,4,3,2,1]
输出:[[4,4]]
提示:
* 1 <= nums.length <= 15
* -100 <= nums[i] <= 100
💡 思路:
这道题乍一看,递增?直接套`90.子集II`,当然,肯定是不行的。
注意啊,我们这个整数数组是不能改变次序的,
所以上面我们用排序的方式去重在这里用不上。
那怎么办呢?
我们需要用一个结构来保存每一层用过的元素,来给它去重。
我们可以选择用map来存储用过的元素,来给每一层的循环去重。
![递增子序列-抽象树](https://img-blog.csdnimg.cn/img_convert/00c82110671b8d3cfa3a4e4d3a978e01.png)
回溯三要素:
* 参数
组合不重复,需要start。
* 终止条件
遍历完nums。
* 单层逻辑
1. 去重
用map存储一层里用过的元素,选择元素之前,判断元素是否用过。
2. 递增
每个元素和队尾元素比一下,判断是否满足递增的要求。
🖊 代码:
class Solution {
List<List> result = new ArrayList<>();
LinkedList path = new LinkedList();
public List<List<Integer>> findSubsequences(int[] nums) {
if (nums == null || nums.length == 0) {
result.add(new ArrayList<>());
return result;
}
backtrack(nums, 0);
return result;
}
public void backtrack(int[] nums, int start) {
//使用map辅助去重
Map<Integer, Integer> map = new HashMap<>();
if (path.size() > 1) {
result.add(new ArrayList<>(path));
}
if (start >= nums.length) {
return;
}
for (int i = start; i < nums.length; i++) {
//判断当前元素序列是否递增
if (!path.isEmpty() && path.getLast() > nums[i]) {
continue;
}
//本层循环元素已经用过,去重
if (map.containsKey(nums[i])) {
continue;
}
path.addLast(nums[i]);
map.put(nums[i], i);
backtrack(nums, i + 1);
path.removeLast();
}
}
}
## 排列问题
### [LeetCode46. 全排列](https://bbs.csdn.net/topics/618540462)
☕ 题目:46. 全排列 (https://leetcode-cn.com/problems/permutations/)
❓ 难度:中等
📕 描述:
给定一个不含重复数字的数组 nums ,返回其 所有可能的全排列 。你可以 按任意顺序 返回答案。
示例 1:
输入:nums = [1,2,3]
输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
示例 2:
输入:nums = [0,1]
输出:[[0,1],[1,0]]
示例 3:
输入:nums = [1]
输出:[[1]]
提示:
* 1 <= nums.length <= 6
* -10 <= nums[i] <= 10
* nums 中的所有整数 互不相同
💡 思路:
这里注意,我们在每一层去重。
我们之前用过两种方法去重:`排序去重`、`map去重`。
这用一个新的办法,用一个boolean数组`used`标记元素是否被用过。
先画抽象树:
![全排列](https://img-blog.csdnimg.cn/img_convert/bcb6c0fed513f186ccb72a4ee3104043.png)
回溯三部曲:
* 结束条件
path中取到了等于集合得数量.
* 参数
注意啊,因为这里要从头开始搜索,所以就不用start了;
我们去重用的used数组直接定义全局变量;
* 单层逻辑
需要根据used数组判断当前元素是否用过。
🖊 代码:
class Solution {
List<List> result = new ArrayList<>();
LinkedList path = new LinkedList<>();
boolean[] used;
public List<List<Integer>> permute(int[] nums) {
if (nums == null || nums.length == 0) {
result.add(path);
return result;
}
used = new boolean[nums.length];
backtrack(nums);
return result;
}
public void backtrack(int[] nums) {
if (path.size() == nums.length) {
result.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < nums.length; i++) {
//去重判断
if (used[i]) {
continue;
}
//标记用过
used[i] = true;
path.addLast(nums[i]);
backtrack(nums);
//回溯
used[i] = false;
path.removeLast();
}
}
}
### [LeetCode47. 全排列 II](https://bbs.csdn.net/topics/618540462)
☕ 题目:47. 全排列 II (https://leetcode-cn.com/problems/permutations-ii/)
❓ 难度:中等
📕 描述:
给定一个可包含重复数字的序列 nums ,按任意顺序 返回所有不重复的全排列。
示例 1:
输入:nums = [1,1,2]
输出:
[[1,1,2],
[1,2,1],
[2,1,1]]
示例 2:
输入:nums = [1,2,3]
输出:[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
提示:
* 1 <= nums.length <= 8
* -10 <= nums[i] <= 10
💡 思路:
这道题在上一道题的基础上:`给定一个可包含重复数字的序列 nums`。
又到了我们喜闻乐见的去重时间,这个去重是单层的去重。
这次我们可以使用排序,相邻元素比较的方式去重。
先画抽象树:
![全排列II](https://img-blog.csdnimg.cn/img_convert/a2d4fcf01f63f9a412320f4f20a09722.png)
🖊 代码:
class Solution {
List<List> result = new ArrayList<>();
LinkedList path = new LinkedList<>();
boolean[] used;
public List<List<Integer>> permuteUnique(int[] nums) {
if (nums == null || nums.length == 0) {
result.add(path);
return result;
}
//排序无序集合
Arrays.sort(nums);
used = new boolean[nums.length];
backtrack(nums);
return result;
}
public void backtrack(int[] nums) {
if (path.size() == nums.length) {
result.add(new ArrayList<>(path));
return;
}
for (int i = 0; i < nums.length; i++) {
//判断元素本层是否用过
if (i > 0 && nums[i] == nums[i - 1] && used[i - 1] == false) {
continue;
}
//判断元素本枝干是否用过
if (used[i]) {
continue;
}
//开始处理
//标记同一个枝干用过
used[i] = true;
path.addLast(nums[i]);
backtrack(nums);
//回溯
path.removeLast();
used[i] = false;
}
}
}
## 棋盘问题
### [LeetCode51. N 皇后](https://bbs.csdn.net/topics/618540462)
☕ 题目:51. N 皇后 (https://leetcode-cn.com/problems/n-queens/)
❓ 难度:困难
📕 描述:
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上,并且使皇后彼此之间不能相互攻击。
给你一个整数 n ,返回所有不同的 n 皇后问题 的解决方案。
每一种解法包含一个不同的 n 皇后问题 的棋子放置方案,该方案中 ‘Q’ 和 ‘.’ 分别代表了皇后和空位。
**示例 1:**
![N皇后](https://img-blog.csdnimg.cn/img_convert/613da78d9789b59efa57195ad6dd10be.png)
输入:n = 4
输出:[[“.Q…”,“…Q”,“Q…”,“…Q.”],[“…Q.”,“Q…”,“…Q”,“.Q…”]]
解释:如上图所示,4 皇后问题存在两个不同的解法。
**示例 2:**
输入:n = 1
输出:[[“Q”]]
**提示:**
* `1 <= n <= 9`
* 皇后彼此不能相互攻击,也就是说:任何两个皇后都不能处于同一条横行、纵行或斜线上。
💡 思路:
首先看一下,每个组合又什么限制呢?
* 不能同行
* 不能同列
* 不能在同一条斜线
搜索皇后的位置,同样可以抽象成一棵树。
![N皇后](https://img-blog.csdnimg.cn/img_convert/0907e2778d70a348030a8c5a06e5ae18.png)
矩阵的高就是树的高度,矩阵的宽就是每一个节点的宽度。
我们拿皇后的约束条件来剪枝,只要能搜索到树的叶子节点,那么就说明找到和合适的位置。
回溯三要素上吧!
* 参数
需要一个二维数组表示棋盘;
参数n记录棋盘大小;
用row记录遍历到棋盘的第几层;
* 终止条件
到了最底的一层,说明找到合适的皇后的位置;
* 单层逻辑
需要判断当前选择是否符合N皇后约束条件;
三个条件,行不用管,因为我们是一行一行往下的。
只需要判断左上角斜方向,列方向,右上角斜方向。
![判断N皇后条件](https://img-blog.csdnimg.cn/img_convert/20a8a9e6d7f468d5f8afc463bc1393a6.png)
🖊 代码:
class Solution {
List<List> result = new ArrayList<>();
public List<List<String>> solveNQueens(int n) {
//棋盘
char[][] board = new char[n][n];
//初始化棋盘
for (char[] c : board) {
Arrays.fill(c, '.');
}
backtrack(board, n, 0);
return result;
}
public void backtrack(char[][] board, int n, int row) {
//终止条件,到底了
if (row == n) {
result.add(arrayToList(board));
return;
}
for (int col = 0; col < n; col++) {
//判断是否符合N皇后要求
if (!isValid(board, n, row, col)) continue;
//开始操作
board[row][col] = 'Q';
backtrack(board, n, row + 1);
//回溯
board[row][col] = '.';
}
}
//判断当前位置是否满足N皇后要求
public boolean isValid(char[][] board, int n, int row, int col) {
//行不用判断,每层只有一个
//col列判断
for (int k = 0; k < n; k++) {
if (board[k][col] == 'Q') {
return false;
}
}
//检查主对角线(45度)
for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
if (board[i][j] == 'Q') {
return false;
}
}
//检查副对角线(135度)
for (int i = row - 1, j = col + 1; i >= 0 && j <= n - 1; i--, j++) {
if (board[i][j] == 'Q') {
return false;
}
}
return true;
}
//将棋盘数组转换为字符串列表
public List<String> arrayToList(char[][] board) {
List<String> path = new ArrayList<>();
for (char[] c : board) {
path.add(String.valueOf(c));
}
return path;
}
}
### [LeetCode 37. 解数独](https://bbs.csdn.net/topics/618540462)
☕ 题目:37. 解数独(https://leetcode-cn.com/problems/sudoku-solver/)
❓ 难度:困难
📕 描述:
编写一个程序,通过填充空格来解决数独问题。
数独的解法需 遵循如下规则:
* 数字 1-9 在每一行只能出现一次。
* 数字 1-9 在每一列只能出现一次。
* 数字 1-9 在每一个以粗实线分隔的 3x3 宫内只能出现一次。(请参考示例图)
数独部分空格内已填入了数字,空白格用 ‘.’ 表示。
![img](https://img-blog.csdnimg.cn/img_convert/8278f7e1b798411c329a6aea413253b1.png)
>
> 输入:board = [[“5”,“3”,".",".",“7”,".",".",".","."],
> [“6”,".",".",“1”,“9”,“5”,".",".","."],
> [".",“9”,“8”,".",".",".",".",“6”,"."],
> [“8”,".",".",".",“6”,".",".",".",“3”],
> [“4”,".",".",“8”,".",“3”,".",".",“1”],
> [“7”,".",".",".",“2”,".",".",".",“6”],
> [".",“6”,".",".",".",".",“2”,“8”,"."],
> [".",".",".",“4”,“1”,“9”,".",".",“5”],
> [".",".",".",".",“8”,".",".",“7”,“9”]]
>
>
> 输出:[[“5”,“3”,“4”,“6”,“7”,“8”,“9”,“1”,“2”],
> [“6”,“7”,“2”,“1”,“9”,“5”,“3”,“4”,“8”],
> [“1”,“9”,“8”,“3”,“4”,“2”,“5”,“6”,“7”],
> [“8”,“5”,“9”,“7”,“6”,“1”,“4”,“2”,“3”],
> [“4”,“2”,“6”,“8”,“5”,“3”,“7”,“9”,“1”],
> [“7”,“1”,“3”,“9”,“2”,“4”,“8”,“5”,“6”],
> [“9”,“6”,“1”,“5”,“3”,“7”,“2”,“8”,“4”],
> [“2”,“8”,“7”,“4”,“1”,“9”,“6”,“3”,“5”],
> [“3”,“4”,“5”,“2”,“8”,“6”,“1”,“7”,“9”]]
>
>
> 解释:输入的数独如上图所示,唯一有效的解决方案如下所示:
>
>
> ![img](https://img-blog.csdnimg.cn/img_convert/9d8f78f249df028e619d4d6d50b87021.png)
>
>
>
提示:
* board.length == 9
* board[i].length == 9
* board[i][j] 是一位数字或者 ‘.’
* 题目数据 保证 输入数独仅有一个解
💡 思路:
这道题可以说是N皇后问题的plu版本了。
这道题矩阵的长度和宽度都比N皇后更长更宽。
而且判断重复也更难:
* 同行是否重复
* 同列是否重复
* 9宫格里是否重复
我们先大概画一棵抽象树:
![数独抽象树](https://img-blog.csdnimg.cn/img_convert/2aa59c40acfb61a6c796ac4a64508dc9.png)
这个图画起来太麻烦了,差不多就那个意思,接下来我们三部曲走起[1]。
### 一、网安学习成长路线图
网安所有方向的技术点做的整理,形成各个领域的知识点汇总,它的用处就在于,你可以按照上面的知识点去找对应的学习资源,保证自己学得较为全面。
![在这里插入图片描述](https://img-blog.csdnimg.cn/aa7be04dc8684d7ea43acc0151aebbf1.png)
### 二、网安视频合集
观看零基础学习视频,看视频学习是最快捷也是最有效果的方式,跟着视频中老师的思路,从基础到深入,还是很容易入门的。
![在这里插入图片描述](https://img-blog.csdnimg.cn/f0aeee2eec7a48f4ad7d083932cb095d.png)
### 三、精品网安学习书籍
当我学到一定基础,有自己的理解能力的时候,会去阅读一些前辈整理的书籍或者手写的笔记资料,这些笔记详细记载了他们对一些技术点的理解,这些理解是比较独到,可以学到不一样的思路。
![在这里插入图片描述](https://img-blog.csdnimg.cn/078ea1d4cda342f496f9276a4cda5fcf.png)
### 四、网络安全源码合集+工具包
光学理论是没用的,要学会跟着一起敲,要动手实操,才能将自己的所学运用到实际当中去,这时候可以搞点实战案例来学习。
**需要体系化学习资料的朋友,可以加我V获取:vip204888 (备注网络安全)**
![在这里插入图片描述](https://img-blog.csdnimg.cn/e54c0bac8f3049928b488dc1e5080fc5.png)
### 五、网络安全面试题
最后就是大家最关心的网络安全面试题板块
![在这里插入图片描述](https://img-blog.csdnimg.cn/15c1192cad414044b4dd41f3df44433d.png)![在这里插入图片描述](https://img-blog.csdnimg.cn/b07abbfab1fd4edc800d7db3eabb956e.png)
**网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。**
**[需要这份系统化资料的朋友,可以点击这里获取](https://bbs.csdn.net/topics/618540462)**
**一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!**