代码随想录 回溯算法-组合

目录

77.组合 

216.组合总和||| 

17.电话号码的字母组合

39.组合总和 

40.组合总和||

77.组合 

77. 组合

中等

给定两个整数 n 和 k，返回范围 [1, n] 中所有可能的 k 个数的组合。

你可以按 任何顺序 返回答案。

示例 1：

输入：n = 4, k = 2
输出：
[[2,4],[3,4],[2,3],[1,2],[1,3],[1,4],
]

示例 2：

输入：n = 1, k = 1
输出：[[1]]

提示：

  • 1 <= n <= 20
  • 1 <= k <= n

 通过这张图可以对递归的过程有清晰的认识。

class Solution {  // 存储所有可能组合的结果列表  List<List<Integer>> result = new ArrayList<>();  // 存储当前正在构建的组合路径  List<Integer> path = new ArrayList<>();  // 主方法，接收两个参数n和k，返回从n个数中选取k个数的所有组合  public List<List<Integer>> combine(int n, int k) {  // 从第1个数开始回溯  backtracking(n, k, 1);  // 返回所有组合的结果  return result;  }  // 回溯方法，接收三个参数：n表示可选数字的上限，k表示需要选择的数字个数，begin表示从哪个数字开始选择  public void backtracking(int n, int k, int begin) {  // 如果当前路径上的数字个数等于k，则找到了一个有效组合  if (path.size() == k) {  // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  result.add(new ArrayList<>(path));  return;  }  // 遍历从begin开始到n的所有数字  for (int i = begin; i <= n; i++) {  // 将当前数字添加到路径中  path.add(i);  // 递归调用，继续选择下一个数字，起始数字为当前数字的下一个（避免重复）  backtracking(n, k, i + 1);  // 回溯，移除路径中最后添加的数字，尝试其他可能性  path.removeLast();  }  }  
}

剪枝操作：

来举一个例子，n = 4，k = 4的话，那么第一层for循环的时候，从元素2开始的遍历都没有意义了。 在第二层for循环，从元素3开始的遍历都没有意义了。

图中每一个节点（图中为矩形），就代表本层的一个for循环，那么每一层的for循环从第二个数开始遍历的话，都没有意义，都是无效遍历。

所以，可以剪枝的地方就在递归中每一层的for循环所选择的起始位置。

如果for循环选择的起始位置之后的元素个数 已经不足 我们需要的元素个数了，那么就没有必要搜索了。

class Solution {  // 存储所有可能组合的结果列表  List<List<Integer>> result = new ArrayList<>();  // 存储当前正在构建的组合路径  List<Integer> path = new ArrayList<>();  // 主方法，接收两个参数n和k，返回从n个数中选取k个数的所有组合  public List<List<Integer>> combine(int n, int k) {  // 从第1个数开始回溯  backtracking(n, k, 1);  // 返回所有组合的结果  return result;  }  // 回溯方法，接收三个参数：n表示可选数字的上限，k表示需要选择的数字个数，begin表示从哪个数字开始选择  public void backtracking(int n, int k, int begin) {  // 如果当前路径上的数字个数等于k，则找到了一个有效组合  if (path.size() == k) {  // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  result.add(new ArrayList<>(path));  return;  }  // 遍历从begin开始到极限情况下的数字//这里执行了剪枝操作for (int i = begin; i <= n - (k - path.size()) + 1; i++) {  // 将当前数字添加到路径中  path.add(i);  // 递归调用，继续选择下一个数字，起始数字为当前数字的下一个（避免重复）  backtracking(n, k, i + 1);  // 回溯，移除路径中最后添加的数字，尝试其他可能性  path.removeLast();  }  }  
}

优化过程如下：

  1. 已经选择的元素个数：path.size();

  2. 还需要的元素个数为: k - path.size();

  3. 在集合n中至多要从该起始位置 : n - (k - path.size()) + 1，开始遍历

为什么有个+1呢，因为包括起始位置，我们要是一个左闭的集合。

举个例子，n = 4，k = 3， 目前已经选取的元素为0（path.size为0），n - (k - 0) + 1 即 4 - ( 3 - 0) + 1 = 2。

从2开始搜索都是合理的，可以是组合[2, 3, 4]。

这里想不懂的话，建议也举一个例子，就知道是不是要+1了。

216.组合总和||| 

216. 组合总和 III

中等

找出所有相加之和为 n 的 k 个数的组合，且满足下列条件：

  • 只使用数字1到9
  • 每个数字 最多使用一次 

返回 所有可能的有效组合的列表 。该列表不能包含相同的组合两次，组合可以以任何顺序返回。

示例 1:

输入: k = 3, n = 7
输出: [[1,2,4]]
解释:
1 + 2 + 4 = 7
没有其他符合的组合了。

示例 2:

输入: k = 3, n = 9
输出: [[1,2,6], [1,3,5], [2,3,4]]
解释:
1 + 2 + 6 = 9
1 + 3 + 5 = 9
2 + 3 + 4 = 9
没有其他符合的组合了。

示例 3:

输入: k = 4, n = 1
输出: []
解释: 不存在有效的组合。
在[1,9]范围内使用4个不同的数字，我们可以得到的最小和是1+2+3+4 = 10，因为10 > 1，没有有效的组合。

提示:

  • 2 <= k <= 9
  • 1 <= n <= 60

// Solution类，用于实现组合数的生成  
class Solution {  // 存储所有可能组合的结果列表  List<List<Integer>> result = new ArrayList<>();  // 存储当前正在构建的组合路径  List<Integer> path = new ArrayList<>();  // 存储当前组合路径的和  int sum = 0;  // 主方法，接收两个参数k和n，返回和为n且长度为k的所有组合  public List<List<Integer>> combinationSum3(int k, int n) {  // 从1开始回溯  backtracking(k, n, 1);  // 返回所有组合的结果  return result;  }  // 回溯方法，接收三个参数：k表示需要选择的数字个数，n表示目标和，begin表示从哪个数字开始选择  public void backtracking(int k, int n, int begin) {  // 如果当前路径的和等于n且路径的长度等于k，则找到了一个有效组合  if (sum == n && path.size() == k) {  // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  result.add(new ArrayList<>(path));  return;  }  // 如果路径的长度已经达到k或者当前路径的和已经大于n，则终止递归  if (path.size() == k || sum > n) {  return;  }  // 从begin开始遍历到9 - (k - path.size()) + 1，确保剩余的数字能够组成长度为k的组合  for (int i = begin; i <= 9 - (k - path.size()) + 1; i++) {  // 将当前数字添加到路径中  path.add(i);  // 更新当前路径的和  sum += i;  // 递归调用，继续选择下一个数字，起始数字为当前数字的下一个  backtracking(k, n, i + 1);  // 回溯，移除路径中最后添加的数字，尝试其他可能性  path.removeLast();  // 回溯，更新当前路径的和  sum -= i;  }  }  
}

 剪枝操作：

// Solution类，用于实现组合数的生成  
class Solution {  // 存储所有可能组合的结果列表  List<List<Integer>> result = new ArrayList<>();  // 存储当前正在构建的组合路径  List<Integer> path = new ArrayList<>();  // 存储当前组合路径的和  int sum = 0;  // 主方法，接收两个参数k和n，返回和为n且长度为k的所有组合  public List<List<Integer>> combinationSum3(int k, int n) {  // 从1开始回溯  backtracking(k, n, 1);  // 返回所有组合的结果  return result;  }  // 回溯方法，接收三个参数：k表示需要选择的数字个数，n表示目标和，begin表示从哪个数字开始选择  public void backtracking(int k, int n, int begin) {  // 如果当前路径的和等于n且路径的长度等于k，则找到了一个有效组合  if (sum == n && path.size() == k) {  // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  result.add(new ArrayList<>(path));  return;  }  // 如果路径的长度已经达到k或者当前路径的和已经大于n，则终止递归  if (path.size() == k || sum > n) {  return;  }  // 从begin开始遍历到9 - (k - path.size()) + 1，确保剩余的数字能够组成长度为k的组合//这里采用剪枝操作  for (int i = begin; i <= 9 - (k - path.size()) + 1; i++) {//已选元素总和如果已经大于n了，那么往后遍历就没有意义了if(sum + i > n){break;}  // 将当前数字添加到路径中  path.add(i);  // 更新当前路径的和  sum += i;  // 递归调用，继续选择下一个数字，起始数字为当前数字的下一个  backtracking(k, n, i + 1);  // 回溯，移除路径中最后添加的数字，尝试其他可能性  path.removeLast();  // 回溯，更新当前路径的和  sum -= i;  }  }  
}

17.电话号码的字母组合

17. 电话号码的字母组合

中等

给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。

示例 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'] 的一个数字。

// Solution类，用于实现电话号码字母映射问题的解决方案  
class Solution {  // 数字对应的字母映射数组  String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};  // 存储所有可能字母组合的结果列表  List<String> result = new ArrayList<>();  // StringBuilder对象，用于构建当前组合的字符串  StringBuilder builder = new StringBuilder();  // 主方法，接收一个包含数字 2-9 的字符串，返回所有可能的字母组合  public List<String> letterCombinations(String digits) {  // 如果输入的数字字符串为空，则直接返回空的结果列表  if (digits.length() == 0) {  return result;  }  // 从第一个数字开始回溯  backtracking(digits, 0);  // 返回所有可能的字母组合  return result;  }  // 回溯方法，递归地构建所有可能的字母组合  public void backtracking(String digits, int num) {  // 如果当前构建的字符串长度等于输入的数字字符串长度，说明已经构建完一个完整的组合  if (builder.length() == digits.length()) {  // 将当前构建的字符串添加到结果列表中  result.add(builder.toString());  return;  }  // 获取当前数字对应的字母字符串  String str = numString[digits.charAt(num) - '0'];  // 遍历当前数字对应的所有字母  for (int i = 0; i < str.length(); i++) {  // 将当前字母添加到构建字符串中  builder.append(str.charAt(i));  // 递归处理下一个数字  backtracking(digits, num + 1);  // 回溯，移除刚刚添加的字母，尝试下一个字母  builder.deleteCharAt(builder.length() - 1);  }  }  
}

39.组合总和 

39. 组合总和

中等

给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。

candidates 中的 同一个 数字可以 无限制重复被选取 。如果至少一个数字的被选数量不同，则两种组合是不同的。 

对于给定的输入，保证和为 target 的不同组合数少于 150 个。

示例 1：

输入：candidates = [2,3,6,7], target = 7
输出：[[2,2,3],[7]]
解释：
2 和 3 可以形成一组候选，2 + 2 + 3 = 7 。注意 2 可以使用多次。
7 也是一个候选， 7 = 7 。
仅有这两种组合。

示例 2：

输入: candidates = [2,3,5], target = 8
输出: [[2,2,2,2],[2,3,3],[3,5]]

示例 3：

输入: candidates = [2], target = 1
输出: []

提示：

  • 1 <= candidates.length <= 30
  • 2 <= candidates[i] <= 40
  • candidates 的所有元素 互不相同
  • 1 <= target <= 40

// Solution类，用于解决组合和问题  
class Solution {  // 用于存储所有可能组合的结果列表  List<List<Integer>> result = new ArrayList<>();  // 用于存储当前正在构建的组合路径  List<Integer> path = new ArrayList<>();  // 用于存储当前组合路径的数字和  int sum = 0;  // 组合和问题的主方法，接收一个整数数组candidates和目标值target  public List<List<Integer>> combinationSum(int[] candidates, int target) {  // 从数组的第一个元素开始回溯  backtracking(candidates, target, 0);  // 返回所有可能的组合结果  return result;  }  // 回溯方法，用于递归地生成所有可能的组合  public void backtracking(int[] candidates, int target, int begin) {  // 如果当前路径的数字和等于目标值target，则找到了一个有效组合  if (sum == target) {  // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  result.add(new ArrayList<>(path));  return;  }  // 如果当前路径的数字和大于目标值target，则剪枝，不再继续递归  if (sum > target) {  return;  }  // 遍历数组candidates，从begin开始，避免重复使用同一个数字  for (int i = begin; i < candidates.length; i++) {  // 将当前数字添加到路径中  path.add(candidates[i]);  // 更新当前路径的数字和  sum += candidates[i];  // 递归调用，继续选择下一个数字，起始位置可以从当前位置开始，允许重复使用数字  backtracking(candidates, target, i); // 注意这里不是i+1，因为可以重复使用同一个数字  // 回溯，移除路径中最后添加的数字，尝试其他可能性  path.removeLast();  // 回溯，更新当前路径的数字和  sum -= candidates[i];  }  }  
}

 剪枝操作：

// Solution类，用于解决组合和问题  
class Solution {  // 用于存储所有可能组合的结果列表  List<List<Integer>> result = new ArrayList<>();  // 用于存储当前正在构建的组合路径  List<Integer> path = new ArrayList<>();  // 用于存储当前组合路径的数字和  int sum = 0;  // 组合和问题的主方法，接收一个整数数组candidates和目标值target  public List<List<Integer>> combinationSum(int[] candidates, int target) {  // 从数组的第一个元素开始回溯  backtracking(candidates, target, 0);  // 返回所有可能的组合结果  return result;  }  // 回溯方法，用于递归地生成所有可能的组合  public void backtracking(int[] candidates, int target, int begin) {  // 如果当前路径的数字和等于目标值target，则找到了一个有效组合  if (sum == target) {  // 将当前路径添加到结果列表中（注意这里需要添加path的副本，因为path在后续会被修改）  result.add(new ArrayList<>(path));  return;  }  // 如果当前路径的数字和大于目标值target，则剪枝，不再继续递归  if (sum > target) {  return;  }  // 遍历数组candidates，从begin开始，避免重复使用同一个数字  for (int i = begin; i < candidates.length; i++) {//已选元素总和如果已经大于target了，那么往后遍历就没有意义了if(sum + candidates[i] > target){continue;}  // 将当前数字添加到路径中  path.add(candidates[i]);  // 更新当前路径的数字和  sum += candidates[i];  // 递归调用，继续选择下一个数字，起始位置可以从当前位置开始，允许重复使用数字  backtracking(candidates, target, i); // 注意这里不是i+1，因为可以重复使用同一个数字  // 回溯，移除路径中最后添加的数字，尝试其他可能性  path.removeLast();  // 回溯，更新当前路径的数字和  sum -= candidates[i];  }  }  
}

40.组合总和||

40. 组合总和 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

 

这里我们放弃use数组的用法 ，重点读：

同一树枝上相同两个重复元素可以重复取1，即不同层可用重复元素

同一树层上两个重复元素不可以重复选取1，即同层不可用重复元素

那么我们就只需要去掉同层间的重复元素

如下，当i > begin的时候，如果一个元素和它的前一个元素相等的情况下，那么前一个元素一定被使用过了，需要跳过当前元素

// Solution类，用于解决组合和问题的第二种实现  
class Solution {  // 存储所有可能组合的结果列表  List<List<Integer>> result = new ArrayList<>();  // 存储当前正在构建的组合路径  List<Integer> path = new ArrayList<>();  // 存储当前组合路径的数字和  int sum = 0;  // 组合和问题的主方法，接收一个整数数组candidates和目标值target  public List<List<Integer>> combinationSum2(int[] candidates, int target) {  // 对候选数字数组进行排序，这有助于剪枝和提高效率  Arrays.sort(candidates);  // 开始回溯搜索  backtracking(candidates, target, 0);  // 返回所有可能的组合结果  return result;  }  // 回溯方法，用于递归地生成所有可能的组合  public void backtracking(int[] candidates, int target, int begin) {  // 如果当前路径的数字和等于目标值target，则找到了一个有效组合  if (sum == target) {  // 将当前路径添加到结果列表中（注意需要添加path的副本）  result.add(new ArrayList<>(path));  return;  }  // 如果当前路径的数字和大于目标值target，则剪枝，不再继续递归  if (sum > target) {  return;  }  // 遍历数组candidates，从begin开始  for (int i = begin; i < candidates.length; i++) {  // 如果当前数字加上sum已经大于target，则剪枝，不再继续探索  if (sum + candidates[i] > target) {  break;  }  // 跳过同一树层使用过的相同元素 //i > begin说明假如存在相同元素，那么它一定在该数层中使用过了if (i > begin && candidates[i] == candidates[i - 1]) {  continue;  }  // 将当前数字添加到路径中  path.add(candidates[i]);  // 更新当前路径的数字和  sum += candidates[i];  // 递归调用，继续选择下一个数字，起始位置为i + 1（避免重复使用同一个数字）  backtracking(candidates, target, i + 1);  // 回溯，移除路径中最后添加的数字，尝试其他可能性  path.removeLast();  // 回溯，更新当前路径的数字和  sum -= candidates[i];  }  }  
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/724370.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

【论文精读】大语言模型融合知识图谱的问答系统研究

【论文精读】大语言模型融合知识图谱的问答系统研究

&#x1f497;&#x1f497;&#x1f497;欢迎来到我的博客&#xff0c;你将找到有关如何使用技术解决问题的文章&#xff0c;也会找到某个技术的学习路线。无论你是何种职业&#xff0c;我都希望我的博客对你有所帮助。最后不要忘记订阅我的博客以获取最新文章&#xff0c;也欢…
阅读更多...
一文看懂 | 机器视觉前景

一文看懂 | 机器视觉前景

机器视觉概述&#xff1a;机器视觉是人工智能发展中的一个重要分支&#xff0c;其主要目标是用机器替代人眼进行测量和判断。 机器视觉系统通过图像摄取装置将目标转换成图像信号&#xff0c;然后传送给专用的图像处理系统&#xff0c;最终得到目标的形态信息。 全球机器视觉…
阅读更多...
链路负载均衡之策略路由

链路负载均衡之策略路由

一、策略路由的概念 一般来说&#xff0c;防火墙是根据目的地址查看路由&#xff0c;这种情况下只能根据报文的目的地址为用户提供服务&#xff0c;没办法更加灵活对内网用户进行区分&#xff0c;让不同用户流量走不同的链路转发&#xff0c;如根据源地址、应用协议等区分流量…
阅读更多...
照片 200K 的尺寸是多大？如何调整照片到200k？

照片 200K 的尺寸是多大？如何调整照片到200k？

在数字时代&#xff0c;我们经常需要在互联网上上传和分享照片。在上传照片时&#xff0c;我们常常会遇到文件大小的限制&#xff0c;通常以“K”&#xff08;千字节&#xff09;为单位。如果您需要上传的照片大小为 200K&#xff0c;那么它的实际尺寸是多大呢&#xff1f;本文…
阅读更多...
栈【stack】 栈的【STL】运用 【单调栈】 【单调栈】的详细解释【图文讲解】 洛谷P5788 【模板】单调栈 【单调队列】

栈【stack】 栈的【STL】运用 【单调栈】 【单调栈】的详细解释【图文讲解】 洛谷P5788 【模板】单调栈 【单调队列】

文章目录 栈的定义栈的STL运用 单调栈 & 单调队列单调栈的详细解释【图文讲解】例题&#xff1a;洛谷P5788 【模板】单调栈code↓洛谷P5788 【模板】单调栈 AC 栈的定义 栈的修改与访问是按照后进先出的原则进行的 栈通常被称为是后进先出&#xff08;last in first out&…
阅读更多...
centos ps命令

centos ps命令

1. ps &#xff1a; Process Status的缩写&#xff0c;用于查询系统的进程状态 2. 常用参数&#xff1a;-ef 返回系统中所有用户的所有进程的完整列表 -A 显示所有进程&#xff08;同-e&#xff09; -a 显示当前终端的所有进程 -u 显示进程的用户信息 -o 以用户…
阅读更多...
33、一致性哈希算法分区

33、一致性哈希算法分区

33、一致性哈希算法分区 一、背景二、介绍三、步骤1、算法构建一致性哈希环2、Redis服务器IP节点映射3、key落到服务器的落键规则 四、优点1、一致性哈希算法的容错性2、一致性哈希算法的扩展性 五、缺点1、一致性哈希算法的数据倾斜问题2、拓展 六、总结 一、背景 一致性哈希…
阅读更多...
sylar高性能服务器-日志(P57-P60)内容记录

sylar高性能服务器-日志(P57-P60)内容记录

文章目录 P57-P60&#xff1a;序列化模块Varint&#xff08;编码&#xff09;Zigzag&#xff08;压缩&#xff09;class ByteArrayNode&#xff08;链表结构&#xff09;成员变量构造函数写入读取setPositionaddCapacity 测试 P57-P60&#xff1a;序列化模块 ​ 序列化模块通常…
阅读更多...
某酷ckey140逆向(之前下架了重新上传补发)

某酷ckey140逆向(之前下架了重新上传补发)

声明: 本文章中所有内容仅供学习交流使用&#xff0c;不用于其他任何目的&#xff0c;不提供完整代码&#xff0c;抓包内容、敏感网址、数据接口等均已做脱敏处理&#xff0c;严禁用于商业用途和非法用途&#xff0c;否则由此产生的一切后果均与作者无关&#xff01;wx a15018…
阅读更多...
Python - Pycharm 配置 autopep8 并设置快捷键

Python - Pycharm 配置 autopep8 并设置快捷键

什么是 PEP8 官方&#xff1a;PEP 8 – Style Guide for Python Code | peps.python.org PEP8 是 Python 官方推出的一套编码的规范&#xff0c;只要代码不符合它的规范&#xff0c;就会有相应的提示&#xff0c;还可以让代码自动的格式化 Pycharm 自带的代码格式化 ​ 但这…
阅读更多...
2024年Android笔试题总，如何系统全面性学习Android语言

2024年Android笔试题总，如何系统全面性学习Android语言

开头 让我们一起来看看&#xff0c;字节跳动的第三面&#xff0c;面试官都问了什么&#xff1f;&#xff08;第一二面的题目及答案已整理&#xff0c;需要的可以在文末领取&#xff09; 从七月中旬开始&#xff0c;我前前后后差不多一共投递了八十份简历&#xff0c;到目前为…
阅读更多...
章鱼网络进展月报 | 2024.2.1-2.29

章鱼网络进展月报 | 2024.2.1-2.29

章鱼网络大事摘要 1、Omnity 完成了核心组件的原型开发&#xff0c;正在测试&#xff0c;未来将首先支持 Runes 资产跨链。 2、$NEAR Restaking 质押总量超过400万美元。 3、章鱼网络受邀参加 ETHDenver 2024&#xff0c;并且与 ICP 共同组织活动&#xff0c;介绍 Omnity 的…
阅读更多...
【C语言】linux内核netif_receive_skb

【C语言】linux内核netif_receive_skb

一、中文注释 /*** netif_receive_skb - 从网络处理接收缓冲区* skb: 要处理的缓冲区** netif_receive_skb() 是主要的数据接收处理函数。* 它总是成功的。由于拥塞控制或协议层的原因&#xff0c;缓冲区可能在处理过程中被丢弃。** 这个函数只能在软中断&#xff08;softirq&…
阅读更多...
guava的使用

guava的使用

对数组操作前判断是否会越界&#xff1a; List<String> s new ArrayList<>();System.out.println(Preconditions.checkElementIndex(2,s.size(),"下标长度超过了")); 是否为空 String s null;System.out.println(Preconditions.checkNotNull(s)); 判空…
阅读更多...
Android使用Sensor.TYPE_STEP_COUNTER计步器传感器进行步数统计

Android使用Sensor.TYPE_STEP_COUNTER计步器传感器进行步数统计

1、首先&#xff0c;申请权限 必须声明 ACTIVITY_RECOGNITION 权限&#xff0c;以便您的应用在运行 Android 10 (API 级别 29) 或更高版本的设备上使用此传感器。 Manifest.xml也记得声明 if (Build.VERSION.SDK_INT > Build.VERSION_CODES.P) {Log.d(TAG, "[权限]&quo…
阅读更多...
Docker的安装跟基础使用一篇文章包会

Docker的安装跟基础使用一篇文章包会

目录 国内源安装新版本 1、清理环境 2、配置docker yum源 3、安装启动 4、启动Docker服务 5、修改docker数据存放位置 6、配置加速器 现在我们已经完成了docker的安装和初始配置。以下为基本测试使用 自带源安装的版本太低 docker官方源安装的话速度太慢了 所以本篇文…
阅读更多...
iOS 自动化测试踩坑(一): 技术方案、环境配置与落地实践

iOS 自动化测试踩坑(一): 技术方案、环境配置与落地实践

移动端的自动化测试&#xff0c;最常见的是 Android 自动化测试&#xff0c;我个人觉得 Android 的测试优先级会更高&#xff0c;也更开放&#xff0c;更容易测试&#xff1b;而 iOS 相较于 Android 要安全稳定的多&#xff0c;但也是一个必须测试的方向&#xff0c;这个系列文…
阅读更多...
STM32（18）I2C

STM32（18）I2C

串口通信缺点 一个设备就需要一个串口&#xff0c;单片机可能没有那么多串口外设 总线/非总线 主机&#xff1a;负责管理总线&#xff0c;可控制波特率、数据的通信方向 波特率&#xff1a;由主机产生波特率信号 数据的传输 每个从机都有7位地址&#xff0c;最后移位是读&a…
阅读更多...
力扣--动态规划516.最长回文子序列

力扣--动态规划516.最长回文子序列

思路分析&#xff1a; 创建一个二维动态规划表dp&#xff0c;其中dp[i][j]表示在子串s[i...j]中的最长回文子序列的长度。初始化基本情况&#xff1a;对角线上的元素dp[i][i]都为1&#xff0c;因为单个字符本身就是长度为1的回文子序列。从字符串末尾向前遍历&#xff0c;填充…
阅读更多...
IPsec VPN协议框架

IPsec VPN协议框架

IPsec是IETF&#xff08;Internet Engineering Task Force&#xff09;制定的一组开放的网络安全协议。它并不是一个单独的协议&#xff0c;而是一系列为IP网络提供安全性的协议和服务的集合&#xff0c;包括认证头AH&#xff08;Authentication Header&#xff09;和封装安全载…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023