第 87 场周赛：比较含退格的字符串、数组中的最长山脉、一手顺子、访问所有节点的最短路径

Q1、[简单] 比较含退格的字符串

1、题目描述

给定 s 和 t 两个字符串，当它们分别被输入到空白的文本编辑器后，如果两者相等，返回 true 。# 代表退格字符。

**注意：**如果对空文本输入退格字符，文本继续为空。

示例 1：

输入：s = "ab#c", t = "ad#c"
输出：true
解释：s 和 t 都会变成 "ac"。

示例 2：

输入：s = "ab##", t = "c#d#"
输出：true
解释：s 和 t 都会变成 ""。

示例 3：

输入：s = "a#c", t = "b"
输出：false
解释：s 会变成 "c"，但 t 仍然是 "b"。

提示：

  • 1 <= s.length, t.length <= 200
  • s 和 t 只含有小写字母以及字符 '#'

进阶：

  • 你可以用 O(n) 的时间复杂度和 O(1) 的空间复杂度解决该问题吗？
2、解题思路

  1. 问题分析：

    • 字符串中的 # 表示退格操作，会删除前一个字符。
    • 需要模拟文本编辑器的行为，处理退格操作后比较两个字符串是否相同。

  2. 算法设计：

    • 使用栈来模拟文本编辑器的行为：
      • 遍历字符串，遇到非 # 字符则压入栈中。
      • 遇到 # 字符则弹出栈顶字符（如果栈不为空）。
    • 最终比较两个栈中的字符是否相同。

  3. 优化：

    • 使用双指针可以在不占用额外空间的情况下解决问题，但栈的解法更直观。
3、代码实现
C++
class Solution {
public:bool backspaceCompare(string s, string t) {stack<char> s1, s2;// 处理字符串 sfor (char c : s) {if (c != '#') {s1.push(c);} else if (!s1.empty()) {s1.pop();}}// 处理字符串 tfor (char c : t) {if (c != '#') {s2.push(c);} else if (!s2.empty()) {s2.pop();}}// 比较两个栈if (s1.size() != s2.size()) {return false;}while (!s1.empty()) {if (s1.top() != s2.top()) {return false;}s1.pop();s2.pop();}return true;}
};
Java
class Solution {public boolean backspaceCompare(String s, String t) {Stack<Character> s1 = new Stack<>();Stack<Character> s2 = new Stack<>();// 处理字符串 sfor (char c : s.toCharArray()) {if (c != '#') {s1.push(c);} else if (!s1.isEmpty()) {s1.pop();}}// 处理字符串 tfor (char c : t.toCharArray()) {if (c != '#') {s2.push(c);} else if (!s2.isEmpty()) {s2.pop();}}// 比较两个栈if (s1.size() != s2.size()) {return false;}while (!s1.isEmpty()) {if (s1.pop() != s2.pop()) {return false;}}return true;}
}
Python
class Solution:def backspaceCompare(self, s: str, t: str) -> bool:def build(s: str) -> list:stack = []for c in s:if c != '#':stack.append(c)elif stack:stack.pop()return stackreturn build(s) == build(t)

在这里插入图片描述

4、复杂度分析

  1. 时间复杂度：

    • 处理字符串 s 和 t 的时间复杂度均为 O(n)，其中 n 是字符串的长度。
    • 比较两个栈的时间复杂度为 O(n)。
    • 总时间复杂度为 O(n)。

  2. 空间复杂度：

    • 使用栈的空间复杂度为 O(n)。

Q2、[中等] 数组中的最长山脉

1、题目描述

把符合下列属性的数组 arr 称为 山脉数组 ：

  • arr.length >= 3
  • 存在下标 i（0 < i < arr.length - 1），满足
    • arr[0] < arr[1] < ... < arr[i - 1] < arr[i]
    • arr[i] > arr[i + 1] > ... > arr[arr.length - 1]

给出一个整数数组 arr，返回最长山脉子数组的长度。如果不存在山脉子数组，返回 0 。

示例 1：

输入：arr = [2,1,4,7,3,2,5]
输出：5
解释：最长的山脉子数组是 [1,4,7,3,2]，长度为 5。

示例 2：

输入：arr = [2,2,2]
输出：0
解释：不存在山脉子数组。

提示：

  • 1 <= arr.length <= 104
  • 0 <= arr[i] <= 104

进阶：

  • 你可以仅用一趟扫描解决此问题吗？
  • 你可以用 O(1) 空间解决此问题吗？
2、解题思路

  1. 问题分析：

    • 山脉数组必须有一个山峰，该山峰是数组中的最大值。
    • 山脉数组的左侧必须严格递增，右侧必须严格递减。

  2. 算法设计：

    • 使用动态规划来记录每个位置左侧严格递增的长度和右侧严格递减的长度。
    • 对于每个位置 i，如果 left[i] 和 right[i] 都大于 0，则说明 i 是山峰，山脉长度为 left[i] + right[i] + 1。
    • 最终返回所有可能的山脉长度中的最大值。

  3. 优化：

    • 使用两个数组 left 和 right 来分别记录每个位置左侧和右侧的严格递增/递减长度。

    • 遍历数组两次来填充 left 和 right，然后遍历一次计算最大山脉长度。

3、代码实现
C++
class Solution {
public:int longestMountain(vector<int>& arr) {int n = arr.size();if (n < 3) {return 0; // 如果数组长度小于 3，直接返回 0}vector<int> left(n, 0); // 记录每个位置左侧严格递增的长度for (int i = 1; i < n; ++i) {if (arr[i - 1] < arr[i]) {left[i] = left[i - 1] + 1;}}vector<int> right(n, 0); // 记录每个位置右侧严格递减的长度for (int i = n - 2; i >= 0; --i) {if (arr[i + 1] < arr[i]) {right[i] = right[i + 1] + 1;}}int ret = 0;for (int i = 0; i < n; ++i) {if (left[i] > 0 && right[i] > 0) {          // 如果 i 是山峰ret = max(ret, left[i] + right[i] + 1); // 计算山脉长度}}return ret;}
};

class Solution {
public:int longestMountain(vector<int>& arr) {int n = arr.size();int ret = 0;int left = 0;while (left + 2 < n) {int right = left + 1;if (arr[left] < arr[left + 1]) {while (right + 1 < n && arr[right] < arr[right + 1]) {++right;}if (right < n - 1 && arr[right] > arr[right + 1]) {while (right < n - 1 && arr[right] > arr[right + 1]) {++right;}ret = max(ret, right - left + 1);} else {++right;}}left = right;}return ret;}
};
Java
class Solution {public int longestMountain(int[] arr) {int n = arr.length;if (n < 3) {return 0; // 如果数组长度小于3，直接返回0}int[] left = new int[n]; // 记录每个位置左侧严格递增的长度for (int i = 1; i < n; ++i) {if (arr[i - 1] < arr[i]) {left[i] = left[i - 1] + 1;}}int[] right = new int[n]; // 记录每个位置右侧严格递减的长度for (int i = n - 2; i >= 0; --i) {if (arr[i + 1] < arr[i]) {right[i] = right[i + 1] + 1;}}int ret = 0;for (int i = 0; i < n; ++i) {if (left[i] > 0 && right[i] > 0) { // 如果i是山峰ret = Math.max(ret, left[i] + right[i] + 1); // 计算山脉长度}}return ret;}
}

在这里插入图片描述

Python
class Solution:def longestMountain(self, arr: List[int]) -> int:n = len(arr)if n < 3:return 0  # 如果数组长度小于3，直接返回0left = [0] * n  # 记录每个位置左侧严格递增的长度for i in range(1, n):if arr[i - 1] < arr[i]:left[i] = left[i - 1] + 1right = [0] * n  # 记录每个位置右侧严格递减的长度for i in range(n - 2, -1, -1):if arr[i + 1] < arr[i]:right[i] = right[i + 1] + 1ret = 0for i in range(n):if left[i] > 0 and right[i] > 0:  # 如果i是山峰ret = max(ret, left[i] + right[i] + 1)  # 计算山脉长度return ret
4、复杂度分析
  1. 时间复杂度：
    • 填充 left 和 right 数组的时间复杂度为 O(n)。
    • 计算最大山脉长度的时间复杂度为 O(n)。
    • 总时间复杂度为 O(n)。
  2. 空间复杂度：
    • 使用两个数组 left 和 right，空间复杂度为 O(n)。

Q3、[中等] 一手顺子

1、题目描述

Alice 手中有一把牌，她想要重新排列这些牌，分成若干组，使每一组的牌数都是 groupSize ，并且由 groupSize 张连续的牌组成。

给你一个整数数组 hand 其中 hand[i] 是写在第 i 张牌上的数值。如果她可能重新排列这些牌，返回 true ；否则，返回 false 。

示例 1：

输入：hand = [1,2,3,6,2,3,4,7,8], groupSize = 3
输出：true
解释：Alice 手中的牌可以被重新排列为 [1,2,3]，[2,3,4]，[6,7,8]。

示例 2：

输入：hand = [1,2,3,4,5], groupSize = 4
输出：false
解释：Alice 手中的牌无法被重新排列成几个大小为 4 的组。

提示：

  • 1 <= hand.length <= 104
  • 0 <= hand[i] <= 109
  • 1 <= groupSize <= hand.length
2、解题思路

  1. 问题分析：

    • 需要将牌分成若干组，每组有 groupSize 张连续的牌。
    • 如果牌的总数不能被 groupSize 整除，直接返回 false。
    • 需要统计每张牌的数量，并按顺序分组。

  2. 算法设计：

    • 先检查牌的总数是否能被 groupSize 整除。
    • 对牌进行排序，并统计每张牌的数量。
    • 遍历排序后的牌，尝试将连续的 groupSize 张牌分成一组，如果无法找到连续的牌则返回 false。

  3. 优化：

    • 使用哈希表统计每张牌的数量，可以快速查询和更新。
    • 排序后可以方便地找到连续的牌。
3、代码实现
C++
class Solution {
public:bool isNStraightHand(vector<int>& hand, int groupSize) {int n = hand.size();// 如果牌的总数不能被 groupSize 整除，直接返回 falseif (n % groupSize != 0) {return false;}sort(hand.begin(), hand.end()); // 排序unordered_map<int, int> cnt;    // 统计每张牌的数量for (auto& num : hand) {cnt[num]++;}for (auto& x : hand) {// 如果当前牌已经被用完，跳过if (cnt[x] == 0) {continue;}// 检查连续的 groupSize 张牌for (int j = 0; j < groupSize; ++j) {int num = x + j;// 如果缺少某张连续的牌，返回 falseif (cnt[num] == 0) {return false;}cnt[num]--; // 用掉一张牌}}return true; // 所有牌都成功分组}
};
Java
class Solution {public boolean isNStraightHand(int[] hand, int groupSize) {int n = hand.length;// 如果牌的总数不能被 groupSize 整除，直接返回 falseif (n % groupSize != 0) {return false;}Arrays.sort(hand); // 排序Map<Integer, Integer> cnt = new HashMap<>(); // 统计每张牌的数量for (int num : hand) {cnt.put(num, cnt.getOrDefault(num, 0) + 1);}for (int x : hand) {// 如果当前牌已经被用完，跳过if (cnt.get(x) == 0) {continue;}// 检查连续的 groupSize 张牌for (int j = 0; j < groupSize; ++j) {int num = x + j;// 如果缺少某张连续的牌，返回 falseif (!cnt.containsKey(num) || cnt.get(num) == 0) {return false;}cnt.put(num, cnt.get(num) - 1); // 用掉一张牌}}return true; // 所有牌都成功分组}
}
Python
class Solution:def isNStraightHand(self, hand: List[int], groupSize: int) -> bool:n = len(hand)if n % groupSize != 0:  # 如果牌的总数不能被 groupSize 整除，直接返回 Falsereturn Falsehand.sort()  # 排序cnt = defaultdict(int)for num in hand:  # 统计每张牌的数量cnt[num] += 1for x in hand:if cnt[x] == 0:  # 如果当前牌已经被用完，跳过continuefor j in range(groupSize):  # 检查连续的 groupSize 张牌num = x + jif cnt[num] == 0:  # 如果缺少某张连续的牌，返回 Falsereturn Falsecnt[num] -= 1  # 用掉一张牌return True  # 所有牌都成功分组

在这里插入图片描述

4、复杂度分析

  1. 时间复杂度：

    • 排序的时间复杂度为 O(nlogn)。
    • 遍历和分组的时间复杂度为 O(nlogn)。
    • 总时间复杂度为 O(nlogn)。

  2. 空间复杂度：

    • 使用哈希表存储牌的数量，空间复杂度为 O(nlogn)。

Q4、[困难] 访问所有节点的最短路径

1、题目描述

存在一个由 n 个节点组成的无向连通图，图中的节点按从 0 到 n - 1 编号。

给你一个数组 graph 表示这个图。其中，graph[i] 是一个列表，由所有与节点 i 直接相连的节点组成。

返回能够访问所有节点的最短路径的长度。你可以在任一节点开始和停止，也可以多次重访节点，并且可以重用边。

示例 1：

img

输入：graph = [[1,2,3],[0],[0],[0]]
输出：4
解释：一种可能的路径为 [1,0,2,0,3]

示例 2：

img

输入：graph = [[1],[0,2,4],[1,3,4],[2],[1,2]]
输出：4
解释：一种可能的路径为 [0,1,4,2,3]

提示：

  • n == graph.length
  • 1 <= n <= 12
  • 0 <= graph[i].length < n
  • graph[i] 不包含 i
  • 如果 graph[a] 包含 b ，那么 graph[b] 也包含 a
  • 输入的图总是连通图
2、解题思路
  1. 问题分析：
    • 这是一个典型的**状态压缩广度优先搜索（BFS）**问题。
    • 需要记录访问过的节点集合，通常用**位掩码（bitmask）**表示，其中第 i 位为 1 表示节点 i 已被访问。
    • 使用 BFS 来探索所有可能的路径，确保找到最短路径。
  2. 算法设计：
    • 初始化：从每个节点出发，初始化队列，记录当前节点、访问掩码和路径长度。
    • BFS 遍历：对于队列中的每个状态，尝试访问相邻节点，并更新访问掩码。
    • 终止条件：当访问掩码表示所有节点都被访问时，返回当前路径长度。
  3. 优化：
    • 使用 seen 数组避免重复访问相同的节点和掩码组合。
    • 优先处理路径长度较短的状态，确保找到最短路径
3、代码实现
C++
class Solution {
public:int shortestPathLength(vector<vector<int>>& graph) {int n = graph.size();queue<tuple<int, int, int>> q; // 队列存储 (节点, 掩码, 路径长度)vector<vector<bool>> seen(n, vector<bool>(1 << n, false)); // 标记是否访问过// 初始化队列，从每个节点出发for (int i = 0; i < n; ++i) {q.emplace(i, 1 << i, 0);seen[i][1 << i] = true;}int ret = 0;while (!q.empty()) {auto [u, mask, dist] = q.front();q.pop();// 如果所有节点都被访问，返回当前路径长度if (mask == (1 << n) - 1) {ret = dist;break;}// 遍历相邻节点for (int v : graph[u]) {int mask_v = mask | (1 << v); // 更新掩码if (!seen[v][mask_v]) {q.emplace(v, mask_v, dist + 1);seen[v][mask_v] = true;}}}return ret;}
};
Java
class Solution {public int shortestPathLength(int[][] graph) {int n = graph.length;Queue<int[]> q = new ArrayDeque<>(); // 队列存储 [节点, 掩码, 路径长度]boolean[][] seen = new boolean[n][1 << n]; // 标记是否访问过// 初始化队列，从每个节点出发for (int i = 0; i < n; ++i) {q.offer(new int[] { i, 1 << i, 0 });seen[i][1 << i] = true;}int ret = 0;while (!q.isEmpty()) {int[] state = q.poll();int u = state[0], mask = state[1], dist = state[2];// 如果所有节点都被访问，返回当前路径长度if (mask == (1 << n) - 1) {ret = dist;break;}// 遍历相邻节点for (int v : graph[u]) {int mask_v = mask | (1 << v); // 更新掩码if (!seen[v][mask_v]) {q.offer(new int[] { v, mask_v, dist + 1 });seen[v][mask_v] = true;}}}return ret;}
}
Python
class Solution:def shortestPathLength(self, graph: List[List[int]]) -> int:n = len(graph)q = deque()  # 队列存储 (节点, 掩码, 路径长度)seen = [[False] * (1 << n) for _ in range(n)]  # 标记是否访问过# 初始化队列，从每个节点出发for i in range(n):q.append((i, 1 << i, 0))seen[i][1 << i] = Trueret = 0while q:u, mask, dist = q.popleft()# 如果所有节点都被访问，返回当前路径长度if mask == (1 << n) - 1:ret = distbreak# 遍历相邻节点for v in graph[u]:mask_v = mask | (1 << v)  # 更新掩码if not seen[v][mask_v]:q.append((v, mask_v, dist + 1))seen[v][mask_v] = Truereturn ret

在这里插入图片描述

4、复杂度分析

  • 时间复杂度：O(n2 ⋅2n)。

  • 空间复杂度：O(n⋅2n)




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

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

相关文章

linux安装阿里DataX实现数据迁移

linux安装阿里DataX实现数据迁移

目录 下载datax工具包(如果下载慢&#xff0c;请尝试其他国内镜像站或其他网站下载相应资源) 解压工具包到当前目录里 接着进入conf配置目录并创建一个myjob.json&#xff08;临时测试json&#xff09;&#xff0c;myjob.json内容如下&#xff0c;用于模拟test库tab1表数据同…
阅读更多...
C++ 引用介绍

C++ 引用介绍

很好&#xff01;既然你有 C 的基础&#xff0c;那么理解 C 的「引用&#xff08;reference&#xff09;」会容易很多。我们来一步步讲清楚这个概念。 &#x1f31f; 一句话总结&#xff1a; C 引用&#xff08;reference&#xff09;就是已存在变量的“别名”&#xff0c;它不…
阅读更多...
学习笔记086——@PostConstruct注解和InitializingBean接口的使用

学习笔记086——@PostConstruct注解和InitializingBean接口的使用

文章目录 1、PostConstruct注解1.1 介绍1.2 用法1.3 场景 2、InitializingBean接口2.1 介绍2.2 用法 1、PostConstruct注解 1.1 介绍 PostConstruct 是 Java EE/Jakarta EE 中的一个注解&#xff0c;用于标记一个方法在依赖注入完成后执行初始化操作。它通常与 Spring 框架一…
阅读更多...
考研系列—408真题操作系统篇（2015-2019）

考研系列—408真题操作系统篇（2015-2019）

目录 # 2015年 1.死锁处理 (1)预防死锁 (2)避免死锁 (3)死锁检测和解除 2.请求分页系统的页面置换策略、页面置换策略 3.页、页框、页表，基本分页系统 # 2016年 1.异常、中断 2.页置换算法 3.进程的互斥操作 4.SPOOLing技术(从软件方面实现设备共享) 5.一定要牢记…
阅读更多...
argocd部署cli工具并添加k8s集群

argocd部署cli工具并添加k8s集群

先决条件: 1.已经有k8s集群,(网上一万种部署方式,这里我使用的是kubekey部署的),也埋了个坑,后面说明. 2.已经部署好argocd,并验证web已经可以访问.参见 k8s部署argocd-CSDN博客 部署客户端工具, 这里我是从web页面上直接下载的对应版本的cli工具. 打开已经部署好的argoc…
阅读更多...
打卡day52

打卡day52

简单cnn 借助调参指南进一步提高精度 基础CNN模型代码 import tensorflow as tf from tensorflow.keras import layers, models from tensorflow.keras.datasets import cifar10 from tensorflow.keras.utils import to_categorical# 加载数据 (train_images, train_labels),…
阅读更多...
OpenGL ES绘制3D图形以及设置视口

OpenGL ES绘制3D图形以及设置视口

文章目录 关于 glDrawElements基本概念使用场景mode 绘制模式type 索引数据类型indices 索引缓冲区工作原理绘制正方体实例 视口透视投影&#xff08;Perspective Projection&#xff09;正交投影&#xff08;Orthographic Projection&#xff09;正交投影和透视投影对比 关于 …
阅读更多...
【SAS求解多元回归方程】REG多元回归分析-多元一次回归

【SAS求解多元回归方程】REG多元回归分析-多元一次回归

多元一次回归是一种统计方法&#xff0c;用于分析多个自变量&#xff08;解释变量&#xff09;与一个因变量&#xff08;响应变量&#xff09;之间的线性关系。 目录 【示例】 基本语法 SAS代码 参数估计 方差分析 回归统计量 y的拟合诊断 y的回归变量值 【示例】 设Y…
阅读更多...
卡通幼儿园教育通用可爱PPT模版分享

卡通幼儿园教育通用可爱PPT模版分享

幼儿园教育通用PPT模版&#xff0c;教育教学PPT模版&#xff0c;卡通教育PPT模版&#xff0c;可爱卡通教学课件PPT模版&#xff0c;小清新动物卡通通用PPT模版&#xff0c;教学说课通用PPT模版&#xff0c;开学季PPT模版&#xff0c;国学颂歌PPT模版&#xff0c;可爱简约风PPT模…
阅读更多...
力扣HOT100之技巧：75. 颜色分类

力扣HOT100之技巧：75. 颜色分类

这道题实际上就是让我们不用sort()函数来实现对原数组的排序&#xff0c;这里我直接使用快速排序对原数组进行排序了&#xff0c;也是复习一下基于快慢指针的快速排序写法。面试手撕快排的思路参考这个视频。 用时击败100%&#xff0c;还行。下面直接贴代码。 class Solution …
阅读更多...
离线部署openstack 2024.1 keystone

离线部署openstack 2024.1 keystone

控制节点身份服务 离线下载 apt-get install --download-only keystone python3-openstackclient apache2 libapache2-mod-wsgi-py3mkdir /controller/keystone mv /var/cache/apt/archives/*.deb /controller/keystone/ dpkg -i /controller/keystone/*.deb在一个控制节点操…
阅读更多...
帆软 BI 从入门到实战全攻略(一):安装激活与添加数据

帆软 BI 从入门到实战全攻略(一):安装激活与添加数据

一、帆软 BI 产品概述​ 在当今大数据时代&#xff0c;数据分析与可视化成为企业洞察业务、驱动决策的关键利器。帆软软件有限公司作为中国专业的大数据 BI 和分析平台提供商&#xff0c;自 2006 年成立以来&#xff0c;凭借其在商业智能和数据分析领域的深耕细作&#xff0c;…
阅读更多...
网络协议通俗易懂详解指南

网络协议通俗易懂详解指南

目录 1. 什么是网络协议？ 1.1 协议的本质 1.2 为什么需要协议？ 1.3 协议分层的概念 2. TCP协议详解 - 可靠的信使 📦 2.1 TCP是什么？ 2.2 TCP的核心特性 🔗 面向连接 🛡️ 可靠传输 📊 流量控制 2.3 TCP三次握手 - 建立连接 2.4 TCP四次挥手 - 断开连接…
阅读更多...
量子加速器切入 AI 底层架构！能源焦虑时代，ORCA 正在改写数据中心的计算逻辑

量子加速器切入 AI 底层架构！能源焦虑时代，ORCA 正在改写数据中心的计算逻辑

内容来源&#xff1a;量子前哨&#xff08;ID&#xff1a;Qforepost&#xff09; 文丨浪味仙 排版丨浪味仙 行业动向&#xff1a;2000字丨5分钟阅读 人工智能的飞速发展&#xff0c;令计算需求呈现爆炸式增长&#xff0c;也催生出专为 AI 设计的新型计算基础设施形态——AI…
阅读更多...
＜ 买了个麻烦 (二) 618 京东云--轻量服务器 ＞ “可以为您申请全额退订呢。“ 工单记录：可以“全额退款“

＜ 买了个麻烦 (二) 618 京东云--轻量服务器 ＞ “可以为您申请全额退订呢。“ 工单记录：可以“全额退款“

事情进展是这样的&#xff1a; 海外接听 一分钟 1-2 元&#xff0c;具体多少要问联通。 这几天接电话&#xff0c;有点儿心烦&#xff0c;看见来自 010-86310548 以为是 ICP 备案&#xff0c;结果接起来全是 VPS &#xff08;轻量应用服务器&#xff09;这个工单&#xff0c;就…
阅读更多...
接口限频算法：漏桶算法、令牌桶算法、滑动窗口算法

接口限频算法：漏桶算法、令牌桶算法、滑动窗口算法

文章目录 限频三大算法对比与选型建议一、漏桶算法&#xff08;Leaky Bucket Algorithm&#xff09;1.核心原理2.实现3.为什么要限制漏桶容量4.优缺点分析 二、令牌桶算法&#xff08;Token Bucket Algorithm&#xff09;1.核心原理2.实现&#xff08;1&#xff09;单机实现&am…
阅读更多...
HTML5 盒子模型

HTML5 盒子模型

1. 盒子模型的概念 2. 边框&#xff08;border&#xff09; 边框颜色&#xff08;border-color&#xff09; 边框粗细&#xff08;border-width&#xff09; 边框样式&#xff08;border-style&#xff09; border简写&#xff08;border&#xff1a;&#xff09; 3. 外边距&am…
阅读更多...
【Linux】Linux高级I/O

【Linux】Linux高级I/O

参考博客&#xff1a;https://blog.csdn.net/sjsjnsjnn/article/details/128345976 一、五种IO模型 阻塞式I/O非阻塞式I/OI/O复用&#xff08;多路转接&#xff09;信号驱动式I/O异步I/O I/O我们并不陌生&#xff0c;简单的说就是输入输出&#xff1b;对于一个输入操作通常包…
阅读更多...
关于界面存在AB测试后UI刷新空白的问题

关于界面存在AB测试后UI刷新空白的问题

问题描述&#xff1a; 在同一页面存在AB面&#xff0c;A和B同时都有一个rv&#xff0c;然后A面的rv填充不了数据&#xff0c;B面的可以。 问题解决&#xff1a; header_task布局里的include_new_gift_sign里有一个和外层一样id的recyclerview include的标签的作用是。在infl…
阅读更多...
Go 协程（Goroutine）入门与基础使用

Go 协程（Goroutine）入门与基础使用

一、什么是协程&#xff08;Goroutine&#xff09;&#xff1f; 简单来说&#xff0c;协程是由 Go 语言运行时管理的轻量级线程。相比系统线程&#xff0c;它的调度开销极小&#xff0c;内存占用非常少&#xff08;默认只需 2KB 栈空间&#xff09;。 你可以在一个程序中轻松…
阅读更多...
最新文章

Copyright @ 2022~2023