leetcode标签_AI编程社区

leetcode

DeepSeek LeetCode 514. 自由之路 public int findRotateSteps(String ring, String key) 一个动态规划问题

这道题是LeetCode 514 - 自由之路，一个动态规划问题。我来提供解决方案和详细解释。

稚辉君.MCA.P9.JAVA
2026-03-15 09:00:09

 110

 2

#leetcode #动态规划 #数据结构 +2
DeepSeek LeetCode 2503.矩阵查询可获得的最大分数 Go实现

这个实现能够高效地处理题目要求，利用了 Go 的 container/heap 包和排序功能。· 时间复杂度：O(mn log(mn) + k log k)· 每个单元格入堆一次：O(mn log(mn))// 扩展所有值小于当前查询的单元格。1. 最小堆：存储 (值, 行, 列)，按网格值排序。3. BFS扩展：只扩展值小于当前查询的单元格。· 查询排序：O(k log k)4. 访问标记：每个

 稚辉君.MCA.P9.JAVA
2026-05-20 00:20:00

 33

#leetcode #矩阵 #golang +2
DeepSeek LeetCode 2509.查询树中环的长度 public int[] cycleLengthQueries(int n, int[][] queries)

计算路径长度：(depth[a]-depth[lca]) + (depth[b]-depth[lca])时间复杂度： O(q × log n)，其中 q 是查询数量，n 是树的高度。这道题的核心是找到两个节点在完全二叉树中的路径长度，然后计算环的长度。2. 两个节点之间的路径长度 = 深度差 + 2 × LCA深度差。1. 完全二叉树的节点编号规律：节点 i 的父节点是 i/2。3. 环的长度 =

稚辉君.MCA.P9.JAVA
2026-05-21 00:34:18

 114

#java #算法 #后端 +2
DeepSeek LeetCode 2488. 统计中位数为 K 的子数组 public int countSubarrays(int[] nums, int k)

但更简单的统一方法是：将比 k 大的数记为 +1，比 k 小的数记为 -1，等于 k 的记为 0。那么对于包含 k 的子数组，左部分和 + 右部分和 = 0（奇数长度）或 = 1（偶数长度，k 在左中位）。实际上 LeetCode 2488 的定义：子数组长度为奇数时，中位数是中间元素；长度偶数时，中位数定义为中间靠左那个。但要注意，题目统计的是。这道题要求统计所有子数组中，中位数等于 k 的子数

 稚辉君.MCA.P9.JAVA
2026-05-21 00:33:02

 41

#leetcode #数据结构 #java +2
DeepSeek LeetCode 2488. 统计中位数为 K 的子数组 TypeScript实现

O(n)，空间复杂度：O(n)

稚辉君.MCA.P9.JAVA
2026-05-21 00:33:49

 31

#typescript #数据结构 #leetcode +2
DeepSeek LeetCode 2551. 将珠子放入背包中 Python3实现

总得分 = weights[0] + weights[-1] + 所有选中的 weights[i] + weights[i+1]（其中 i 为切割点）。· 需要选择恰好 k-1 个切割点，总得分 = 固定部分 + 所选 pairSum 之和。· 差值 = (最大 k-1 个之和) - (最小 k-1 个之和)。· 最大化总得分 → 选最大的 k-1 个 pairSum。# 取最小的 k-1 个和最

 稚辉君.MCA.P9.JAVA
2026-05-23 00:09:47

 52

 1

#python #后端 #算法 +2
DeepSeek LeetCode 2589. 完成所有任务的最少时间 Java实现

目标：安排所有任务的运行时间点，使得所有任务都完成，并且总运行时间点数量最少（即最少需要多少个整数时间点）。// 从后往前分配未占用的时间点（贪心：尽量靠后放）输入: tasks = [[2,3,1],[4,5,1],[1,5,2]]输入: tasks = [[1,3,2],[2,5,3],[5,6,2]]2. 从后往前分配：优先占用区间靠后的时间，为前面的任务留出更多可用时间。2. 对于每个任务

 稚辉君.MCA.P9.JAVA
2026-05-25 00:01:51

 582

 21

#数据结构 #java #算法 +2
DeepSeek LeetCode 2663.字典序最小的的美丽字符串 Go实现

因为任何长度 ≥4 的回文必然包含长度为 2 或 3 的回文。3. 贪心策略：从右向左找到第一个可增加的字符，后面填充最小可行字符。// 填充 i 之后的字符为最小可行字符。· 当 i = 0 时，只需检查与前 2 位（不存在）// 检查是否与前面的字符形成回文。// 检查字符 c 放在位置 pos 是否合法。// 填充后续位置为最小字典序。2. 核心检查：只需避免长度为 2 和 3 的回文。·

稚辉君.MCA.P9.JAVA
2026-05-26 00:11:02

 92

 1

#golang #数据结构 #leetcode +2
DeepSeek LeetCode 2842. 统计一个字符串的 k 子序列美丽值最大的数目 TypeScript实现

/ 预期: 0 (字母不足)console.log(countKSubsequencesWithMaxBeauty("aabbccdd", 4));// Step 9: 计算贡献值 (targetFreqValue ^ needFromEqual)// Step 8: 计算组合数 C(equalToTarget, needFromEqual)// 8. 计算组合数 C(equalCount, ne

稚辉君.MCA.P9.JAVA
2026-05-30 10:43:51

 31

#数据结构 #leetcode #算法 +2
DeepSeek LeetCode 2842. 统计一个字符串的 k 子序列美丽值最大的数目 Java实现

上面的实现有个问题：对于频率大于 threshold 的字母，每个字母的每个出现位置都可以被选择。// 计算每个threshold字母的贡献: threshold的needFromEqual次方。// 但我们需要乘以它们的频率乘积，因为每个字母的任意一个出现位置都可以被选。// 乘以所有大于threshold字母的频率（它们必须被选）// 实际上题目要求的是子序列的个数，不是字母的组合数。// 对

 稚辉君.MCA.P9.JAVA
2026-05-30 10:36:44

 91

 1

#算法 #数据结构 #leetcode +2
DeepSeek LeetCode 2842. 统计一个字符串的 k 子序列美丽值最大的数目 JavaScript实现

/ 8. 计算组合数 C(equalCount, needFromEqual)// 9. 计算贡献：targetFreq 的 needFromEqual 次方。// 5. 统计大于targetFreq和等于targetFreq的个数。// 3. 如果字母种类不足k个，无法组成k长度的子序列。// 11. 乘以所有大于targetFreq的频率。// 计算组合数 C(equal, need)

稚辉君.MCA.P9.JAVA
2026-05-30 10:39:57

 102

 2

#javascript #前端 #数据结构 +2
DeepSeek LeetCode 2858. 可以到达每一个节点的最少边反转次数 C语言实现

若原边方向为 parent -> child（权重 +1），则从 child 出发需要多反转 1 次才能回到 parent。// 权重：1 表示原边 u->v，-1 表示原边 v->u。· 若原边方向为 child -> parent（权重 -1），则从 child 出发可少反转 1 次。// 如果权重是 -1，说明原边方向是 v->u，从 u 出发需要反转。// 输入：n = 4, edges

稚辉君.MCA.P9.JAVA
2026-05-31 19:32:26

 108

 1

#c语言 #leetcode #后端 +2
DeepSeek LeetCode 2897. 对数组执行操作使平方和最大 Go实现

2. 重复 k 次，每次从高位到低位贪心地为该数分配一个 1（如果该位还有剩余），从而构造出当前能得到的最大数。fmt.Println(maxSum(nums, k)) // 输出: 100 (36 + 64)// 统计每个位上 1 的个数（最多 30 位，因为 1e9 < 2^30）· 时间复杂度：O(n·B + k·B)，其中 B = 30，常数极小。3. 累加这些数的平方和，并取模 1_00

稚辉君.MCA.P9.JAVA
2026-06-01 00:04:47

 95

 1

#golang #算法 #后端 +2
DeepSeek LeetCode 2945. 找到最大非递减数组的长度 Python3实现

print(sol.findMaximumLength([5,2,2]))# 输出 2分成 [5] [2,2] 或 [5,2] [2] 但后者非递减？记 t[j] = prefix[j] + last[j-1]，我们在已计算的 t 数组中找最靠右的 j 满足 t[j] <= prefix[i+1]。3. dp[i] = dp[j-1] + 1，且 last[i] = prefix[i+1] - p

稚辉君.MCA.P9.JAVA
2026-06-03 00:02:26

 111

 1

#python #后端 #算法 +2
DeepSeek LeetCode 2968. 执行操作使频率分数最大 Java实现

/ 右侧代价：sum(mid+1, right) - (right - mid) * nums[mid]// 左侧代价：(mid - left) * nums[mid] - sum(left, mid-1)· 右侧部分：sum(mid+1, right) - (right - mid) * nums[mid]· 左侧部分：(mid - left) * nums[mid] - sum(left, m

稚辉君.MCA.P9.JAVA
2026-06-04 08:16:04

 93

#java #leetcode #数据结构 +2
DeepSeek LeetCode 2963. 统计好分割方案的数目 Java实现

i=1, currEnd = max(1, lastPos[1]=1) = 1, i == currEnd → 切分点 +1。· i=3, currEnd = max(3, lastPos[2]=3) = 3, i == currEnd → 切分点 +1。· i=5, currEnd = max(5, lastPos[3]=5) = 5, i == currEnd → 切分点 +1。换句话说，对于

 稚辉君.MCA.P9.JAVA
2026-06-04 08:15:20

 93

 1

#leetcode #数据结构 #算法 +2
DeepSeek LeetCode 2968. 执行操作使频率分数最大 TypeScript实现

/ 计算右侧代价：sum(mid+1, right) - (right - mid) * nums[mid]// 解释：可以把所有数变成 2，代价 = |1-2| + |2-2| + |4-2| = 1 + 0 + 2 = 3 ≤ 5。// 计算左侧代价：(mid - left) * nums[mid] - sum(left, mid-1)排序后，目标值相同的元素在连续区间内，方便滑动窗口处理。

稚辉君.MCA.P9.JAVA
2026-06-04 08:16:15

 93

 1

#typescript #leetcode #数据结构 +2
DeepSeek LeetCode 3123. 最短路径中的边 C++实现

dist0[u] + w + dist1[v] == shortest，或。· 得到每个节点到起点的最短距离 dist0 和到终点的最短距离 dist1。// 建图：邻接表存储 (邻居, 权重, 边的索引)· 全局最短距离 shortest = dist0[n-1]// 检查该边是否在至少一条最短路径上。// 小顶堆：存储 (距离, 节点)// 从 n-1 出发的最短距离。· 时间复杂度：O((n

稚辉君.MCA.P9.JAVA
2026-06-10 07:24:30

 38

#leetcode #c++#数据结构 +2
大模型完整底层逻辑（从考研数学/力扣到自研创新全覆盖）

这篇文章从数学底层逻辑出发，抽丝剥茧地解析了大模型的本质。文章指出大模型本质上是一个由考研数学和力扣算法构成的系统：高数负责训练收敛（梯度下降、极值求解），线代处理网络结构（矩阵运算、注意力机制），力扣算法实现工程优化（显存管理、推理加速）。全文通过8层拆解，将大模型的每个组件与基础数学知识对应，揭示了模型训练、微调、轻量化等操作背后的数学原理，帮助研究者建立从理论到实践的完整认知体系。文章特别强

 坚持学习前端日记
2026-07-10 20:53:25

 202

 6

#leetcode #算法 #职场和发展
考研数学、力扣算法与大模型底层研究、SCI公式、模型自研的核心关联

【摘要】本文揭示了考研数学与力扣算法在大模型研发中的核心关联。文章指出，大模型底层公式完全源自考研数学：高数支撑梯度下降与反向传播，线代构建Transformer注意力机制，概率统计指导损失函数与采样机制。同时，力扣算法中的动态规划、树结构、复杂度优化等思想直接对应模型解码、特征提取和轻量化设计。作者强调，研究者只需将论文公式反向映射至已有数学知识体系，即可快速掌握大模型原理。博士的核心竞争力正在

 坚持学习前端日记
2026-07-10 20:51:17

 520

 8

#算法 #考研 #leetcode
DeepSeek LeetCode 3559. 给边赋权值的方案数 II Python3实现

根据题目要求，对于树中任意两个节点 u 和 v，路径长度为 d（边数），使路径总代价为奇数的赋值方案数为 2^(d-1)。组合数公式：C(d,1) + C(d,3) + C(d,5) + ... = 2^(d-1)因此答案为 2^(d-1)。当 d = 0 时（即 u = v），方案数为 0。总体 O((n + q) log n) O(n log n)预处理 O(n log n) O(n log

稚辉君.MCA.P9.JAVA
2026-07-14 08:41:19

 158

 5

#python #算法 #leetcode +2
DeepSeek LeetCode 3553. 包含要求路径的最小带权子图 II JavaScript实现

对于每个查询 (src1, src2, dest)，包含两条路径的最小连通子图就是这两条路径的并集。* @param {number[][]} queries - 查询列表 [src1, src2, dest]* @param {number[][]} edges - 边列表 [u, v, w]// sum[k][v] = v 到其 2^k 级祖先的路径权重和。// 获取节点 v 到其 k 级祖先

 稚辉君.MCA.P9.JAVA
2026-07-14 08:40:31

 161

 9

#python #leetcode #数据结构 +2
DeepSeek LeetCode 3579. 字符串转换需要的最小操作数 Java实现

贪心匹配：处理一个子串时，遇到不匹配的字符对 (a, b)，优先寻找之前是否出现过相反的不匹配对 (b, a)。// pending[a][b] 表示等待匹配的 (a, b) 数量。// 情况2：先反转子串 word1[j..i-1]，再处理（反转本身消耗1次操作）· DP定义：dp[i] 表示将 word1[0..i-1] 转换为 word2[0..i-1] 的最小操作数。· 空间复杂度：O(n

稚辉君.MCA.P9.JAVA
2026-07-16 08:11:59

 162

 5

#java #数据结构 #算法 +2
DeepSeek LeetCode 3609. 到达目标点的最小移动次数 Java实现

逆向操作的确定性：正向移动是加上 max(x,y)，逆向就是看当前的 (tx, ty) 可能是从哪个前驱状态变来的。当 tx > ty 时，最后一步只可能是两种操作之一：要么是 tx 翻倍，要么是 tx 加上 ty。· 贪心判断：如果 tx > ty*2，说明 tx 远大于 ty，此时 tx 只能是通过翻倍得到的（否则如果只是加了一次 ty，不可能变得这么大），所以直接让 tx 减半。// 只有当

 稚辉君.MCA.P9.JAVA
2026-07-18 08:29:45

 185

 7

#java #算法 #leetcode +2
DeepSeek LeetCode 3605. 数组的最小稳定性因子 Java实现

修改后，直接跳跃 upper + 1 个位置，因为中间位置已经不可能再形成长度超过 upper 的稳定子数组了（它们都包含了被修改的位置）。// 从左往右找第一个 gcd >= 2 的段落，它对应的左端点就是 leftMin[i]// 如果 leftMin[i] == n，说明不存在以 i 为右端点的稳定子数组。// leftMin[i] 表示以 i 为右端点，GCD >= 2 的最长子数组的左端

 稚辉君.MCA.P9.JAVA
2026-07-18 08:29:11

 243

 3

#java #后端 #leetcode +2
DeepSeek LeetCode 3636. 查询超过阈值频率最高元素 C++实现

/ 中间完整块的众数。// 左零散部分 [l, (lb+1)*size - 1]// 辅助函数：统计元素 x 在区间 [l, r] 内的出现次数。// 候选众数：中间块的众数 + 左右零散部分的所有元素。分块 O(n√n) O(√n log n) O(n + √n²) = O(n)2. 预处理块间众数：pmx[i][j] 表示从块 i 到块 j 的众数。// 2. 预处理块间众数 pmx[i][j

稚辉君.MCA.P9.JAVA
2026-07-20 07:22:43

 317

#c++#leetcode #后端 +2
DeepSeek LeetCode 3636. 查询超过阈值频率最高元素 Rust实现

/ 左零散部分 [l, (lb+1)*size - 1]// 辅助函数：统计元素 x 在区间 [l, r] 内的出现次数。// 候选众数：中间块的众数 + 左右零散部分的所有元素。分块 O(n√n) O(√n log n) O(n + √n²) = O(n)2. 预处理块间众数：pmx[i][j] 表示从块 i 到块 j 的众数。// 2. 预处理块间众数 pmx[i][j]// 1. 预处理每个

 稚辉君.MCA.P9.JAVA
2026-07-20 07:22:32

 298

 6

#python #数据结构 #后端 +2
DeepSeek LeetCode 3636. 查询超过阈值频率最高元素 Java实现

更高效的解法是分块预处理：把数组分成大小约为 sqrt(n) 的块，预处理出 pmx[i][j] 表示第 i 块到第 j 块的众数。查询时，将区间分为“中间完整块 + 左右零散部分”，候选众数只可能是中间块的预处理的众数以及左右零散部分出现过的元素。最直接的方法是预处理每个元素出现的位置，然后对每个查询，在候选元素中二分统计区间频率，复杂度在题目的约束下是可行的 (n ≤ 10^4, querie

稚辉君.MCA.P9.JAVA
2026-07-20 07:22:06

 195

 6

#leetcode #java #后端 +2
DeepSeek LeetCode 3686. 稳定子序列的数量 Python3实现

复杂度：时间复杂度 O(n)，空间复杂度 O(1)，可处理 nums.length <= 10^5 的输入。更新顺序：先更新 dp[p][1]，再更新 dp[p][0]，确保后者不会污染前者。将当前元素追加到所有以 p 结尾且长度为1的子序列后面，形成长度为2。# 更新长度为2: 追加到原来长度为1的同奇偶子序列后面。· 追加到相反奇偶性结尾的子序列后面（因为奇偶性改变，连续长度重置为1）# c:

稚辉君.MCA.P9.JAVA
2026-07-23 07:28:35

 66

#python #后端 #数据结构 +2
DeepSeek LeetCode 3686. 稳定子序列的数量 Java实现

注意更新顺序：必须先更新dp[p][1]再更新dp[p][0]，确保dp[p][0]使用的是旧值，不会把本轮刚生成的“长度为1”的子序列（来自dp[p][0]旧值）错误地也计入长度2的统计。即dp[p][1] += dp[p][0]（关键：这里必须用更新前的dp[p][0]值）。即dp[p][0] += dp[p^1][0] + dp[p^1][1]。// 关键：先更新 dp[x][1]，使用旧值

 稚辉君.MCA.P9.JAVA
2026-07-23 07:28:13

 78

 2

#java #后端 #数据结构 +2
DeepSeek LeetCode 3695. 交换元素后的最大交替和 Java实现

使用并查集（Union-Find）将所有可以互相交换的下标连接起来，形成若干独立的连通块。这个问题的核心解法是：通过并查集确定哪些下标可以自由交换，然后对每个连通块内部的元素进行贪心分配。3. 计算贡献：对每个连通块，将元素排序后，小的 oddCount 个（奇数位数量）做减法，其余做加法，累加所有块的贡献即为答案。// 2. 按连通块分组，并统计每个块中奇数下标的数量。// 小的给奇数位（减）

稚辉君.MCA.P9.JAVA
2026-07-24 08:43:17

 196

 6

#java #算法 #数据结构 +2
DeepSeek LeetCode 3699. 锯齿形数组的总数 I Java实现

要形成新的上升（到 x），前一步必须是下降且结尾值 < x：newUp[x] = sum(down[0] + ... + down[x-1])。· 要形成新的下降（到 x），前一步必须是上升且结尾值 > x：newDown[x] = sum(up[x+1] + ... + up[m-1])。· 优化：用前缀和快速计算 newUp，用后缀和快速计算 newDown，避免遍历求和，将复杂度从 O(n·

稚辉君.MCA.P9.JAVA
2026-07-24 08:44:44

 69

 1

#java #算法 #数据结构 +2
DeepSeek LeetCode 3699. 锯齿形数组的总数 I Rust实现

用 up[x] 表示以值 x 结尾且最后一步为上升的方案数，down[x] 同理为下降。· 利用前缀和与后缀和将转移优化到 O(m) 每轮，整体 O(n \cdot m)。// 初始长度为1：每个值都可作为起点，up和down各为1。· 时间复杂度：O(n \cdot m)，其中 m = r - l + 1。// 上升：前一步为下降且结尾值 < x。// 下降：前一步为上升且结尾值 > x。· 当

 稚辉君.MCA.P9.JAVA
2026-07-24 08:44:32

 87

 2

#rust #算法 #数据结构 +2
DeepSeek LeetCode 3710. 最大划分因子 TypeScript实现

/ -1: 未染色, 0/1: 两组。2. 箭头函数：const dfs = (u: number, c: number): boolean => { ... }3. 数组初始化：Array.from({ length: n }, () => Array(n).fill(0))· 二分查找执行 O(log M) 次，每次判定遍历所有点对 O(N²)// 1. 计算所有点对之间的曼哈顿距离。

稚辉君.MCA.P9.JAVA
2026-07-25 00:33:45

 16

#typescript #leetcode #数据结构 +2
DeepSeek LeetCode 3700. 锯齿形数组的总数 II Rust实现

时间复杂度：O((2m)^3 \log n)，其中 m = r-l+1 \le 75，矩阵大小 150，快速幂约 30 次乘法。3. 初始向量：长度为 1 时，每个值都单独成数组，up 和 down 都为 1。· T[m+i][j] = 1（当 j > i）：下降状态累加上升的较大值。// 构建转移矩阵 T (size x size)// 初始向量 v (长度为1时，所有位置都为1)// 矩阵乘法

 稚辉君.MCA.P9.JAVA
2026-07-25 00:30:55

 194

 5

#rust #算法 #数据结构 +2
DeepSeek LeetCode 3710. 最大划分因子 Python3实现

color = [-1] * n# -1: 未染色, 0: 组A, 1: 组B。print(Solution().maxPartitionFactor(points))# 输出: 1。· 给定阈值 d，判断能否将所有点分为两组，使得同一组内任意两点的曼哈顿距离 ≥ d。· 时间复杂度：O(N² log M)，N ≤ 500，M 为最大曼哈顿距离。优化版空间复杂度：O(N)，适合点数较大的情况（但仍

 稚辉君.MCA.P9.JAVA
2026-07-25 00:33:16

 79

 1

#python #后端 #leetcode +2
DeepSeek LeetCode 3700. 锯齿形数组的总数 II Java实现

3700 (II)：3 ≤ n ≤ 10⁹，1 ≤ l < r ≤ 75 → n 极大，需用矩阵快速幂加速。· newDown[x] = sum(up[x+1..m-1]) — 前一步上升且值 > x。· newUp[x] = sum(down[0..x-1]) — 前一步下降且值 < x。示例 1：n=3, l=4, r=5 → 输出 2（[4,5,4] 和 [5,4,5]）· 时间：O(m³

稚辉君.MCA.P9.JAVA
2026-07-25 00:31:13

 184

 7

#java #数据结构 #后端 +2
DeepSeek LeetCode 3725. 统计每一行选择互质整数的方案数 Golang实现

4. 容斥求恰好GCD=1：从大到小遍历 d，exact[d] = mul[d] - sum(exact[2d], exact[3d], ...)。· 时间复杂度：O(m * n * τ + V * log V)，其中 V=150，τ 为每个数的因子数（平均约12个），完全可接受。3. 计算倍数方案数：mul[d] = ∏ cnt[row][d]，即每行选出的数都是 d 的倍数。2. 统计每行倍数

 稚辉君.MCA.P9.JAVA
2026-07-26 08:24:56

 62

 2

#算法 #数据结构 #后端 +2
DeepSeek LeetCode 3725. 统计每一行选择互质整数的方案数 Rust实现

4. 容斥求恰好GCD：从大到小遍历d，exact[d] = mul[d] - sum(exact[2d], exact[3d], ...)。答案即 exact[1]。由于矩阵元素最大只有150，我们可以先统计“最大公约数是 d 的倍数”的方案数，再用容斥倒推得到“恰好为1”的方案数。3. 计算倍数方案数：mul[d] = ∏ cnt[row][d]，即所有选中数都是d的倍数的方案数。2. 统计每

 稚辉君.MCA.P9.JAVA
2026-07-26 08:24:44

 60

 1

#rust #leetcode #算法 +2
DeepSeek LeetCode 3725. 统计每一行选择互质整数的方案数 Python3实现

从大到小遍历 d，用 ways 减去所有 exact_gcd[multiple]（multiple 是 d 的倍数），剩下的就是 gcd 恰好为 d 的方案数。3. 为什么从大到小：因为计算 exact_gcd[d] 需要用到 exact_gcd[2d]、exact_gcd[3d] 等更大的数，所以必须逆序计算。· ∏ row_divisor_cnt[i][d] 实际上统计的是 gcd 为 d、2

稚辉君.MCA.P9.JAVA
2026-07-26 08:24:32

 90

#python #leetcode #算法 +2
DeepSeek LeetCode 3729. 统计有序数组中可被 K 整除的子数组数量 JavaScript实现

/ 该长度有 (m - len + 1) 个子数组，但在 step1 中统计了 m - len + 1 次。· len * val % k === 0 等价于 len 是 k / gcd(k, val) 的倍数。// 解释：和为偶数的不同子数组：[1,1], [1,1,1,1], 长度为2的段有2个但相同只算1个。· val = 0 时，gcd(k, 0) = k，step = 1，所有长度都要去

 稚辉君.MCA.P9.JAVA
2026-07-27 07:24:40

 294

 6

#javascript #数据结构 #算法 +2
DeepSeek LeetCode 3739. 统计主要元素子数组数目 II Java实现

设前缀和数组 pre，pre[i] 表示 a[0..i-1] 的和（pre[0]=0）。子数组 (l, r] 的和为 pre[r] - pre[l]，要求 pre[r] - pre[l] > 0，即 pre[l] < pre[r]。// 将范围 [-n, n] 映射到 [1, 2n+1]· r=3: pre=1，前面 < 1 的有 -1, 0, 0 → 3。· r=1: pre= -1，前面 <

稚辉君.MCA.P9.JAVA
2026-07-27 07:26:02

 183

 1

#java #leetcode #后端 +2
DeepSeek LeetCode 3734. 大于目标字符串的最小字典序回文排列 Java实现

因此问题转化为：用 s 中一半的字符（各取一半）构造一个长度为 n/2 的字符串，使其对应的完整回文串严格大于 target。· 若不行，从右向左找到第一个可以增大的位置，填入比 target 对应位置稍大的字符，该位置之后的字符按字典序最小填充（即从小到大填入剩余字符）。// 在 pos 位置填入比 target[pos] 大的最小字符。// pos 之后的位置填入剩余字符的最小字典序。// 4

稚辉君.MCA.P9.JAVA
2026-07-27 07:24:58

 184

 4

#java #后端 #数据结构 +2
DeepSeek LeetCode 3729. 统计有序数组中可被 K 整除的子数组数量 Python3实现

对于一段连续相同元素，只有当子数组长度 h 满足 (h * v) % k == 0 时才会被重复统计。对于全相同元素数组，虽然理论上界为 O(n²)，但实际运行中由于 step 通常较大，性能往往接近 O(n)。2. 减去重复计数：遍历数组，对每一段连续相同元素（长度为 m，值为 v），减去其中被重复统计的子数组数量。1. 统计全部（含重复）：用前缀和 + 哈希表统计所有和能被 k 整除的子数组数

 稚辉君.MCA.P9.JAVA
2026-07-27 07:24:26

 345

 4

#python #后端 #数据结构 +2
Codex 工程化落地指南 01：产品形态与工程化使用模式

《Codex工程化使用指南：从代码生成到智能开发工作流》摘要本教程系统介绍了如何将OpenAI Codex从单纯的代码补全工具升级为工程化开发助手。核心观点在于：Codex是能操作完整开发环境的智能编码Agent，而非简单的代码生成器。主要内容包括：产品形态对比：CLI适合工程任务，IDE侧重局部开发，桌面应用管理多任务，云端适合独立作业本地vs云端任务选择标准：依据依赖关系、环境要求等关

 码东
2026-07-21 10:51:50

 401

 2

#leetcode
多语言分布式任务调度与性能优化实践：Python、Java、Go、C++高效实战方案

在大型互联网系统中，分布式任务调度是核心组件，可协调多节点任务执行，提高系统吞吐量和可靠性。不同语言在任务调度、并行执行和性能优化上各有特点。本文结合 Python、Java、Go 和 C++，展示高性能分布式任务调度和优化实战。

2501_94114632
2026-01-05 18:09:59

 416

 11

#rabbitmq #leetcode
0x3f 第23天黑马web （前端三件套，maven，web入门、mysql）黑马反射注解 hot100普通数组

核心思路，每个学生按学号坐好位置，肯定有一个人的位置是错的最后检查一遍，谁的位置上做错了人，那个位置的数就是缺失的第一个正数如果所有人位置都是对的，那就是n+1是缺失的m3？影分身法：判断每个人的位置和学号的方法就是if i == nums[i]-1（-1是因为i是从0开始 nums[0]在i=0位置）但是如果有两个nums[i]相等，比如1,1,2，那么会导致逻辑崩盘因此我们引入了影分身法具体就

 多米Domi011
2026-01-06 22:08:25

 465

 4

#maven #mysql #java +3