滑动窗口_LeetCode_30.串联所有单词的子串:一次 159/183 的 WA 复盘

【Claude】Auto Mode 触发安全分类器拦截的三种错误变体及对应处理 bug报错已解决 深度解析Claude Auto Mode安全分类器拦截的三种变体:内容拒绝、操作中断、累积触发,含完整排查流程与绕过策略。 阅读详情

LeetCode 30 串联所有单词的子串:一次 159/183 的 WA 复盘

一句话结论先放这儿:这题的核心不是"窗口",而是先把词边界对齐,再在每条对齐网格上独立滑窗。

这篇文章按我真实的思考顺序写:先有思路 → 写出第一版 → 被用例打脸 → 定位到一行代码 → 修复 → 换个角度把原理讲透 → 再做两轮优化。每一版代码都保留,方便你看到"坑"和"改进"的差别。


目录


1. 题目

给定字符串 s 和字符串数组 words,words 中所有字符串长度相同。

s 的「串联子串」是指:包含 words 中所有字符串、以任意顺序排列连接起来的子串。

返回所有串联子串在 s 中的起始下标,顺序任意。

示例 1

输入:s = "barfoothefoobarman", words = ["foo","bar"]
输出:[0,9]

示例 2

输入:s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
输出:[]

示例 3

输入:s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
输出:[6,9,12]

约束

项范围
s.length1 ~ 10^4
words.length1 ~ 5000
words[i].length1 ~ 30
字符集小写字母
所有 words[i] 长度相同是

2. 第一反应:暴力

最直接的想法:

  1. 窗口总长度固定为 m * len(m = words.size(),len = words[0].size());
  2. 枚举每个起点 st;
  3. 把窗口切成 m 块,每块长 len,统计词频,和 words 的词频比对。

复杂度:

起点数 O(n) × 块数 O(m) × 每块取子串/哈希 O(len) = O(n·m·len)

代入上限:10^4 × 5000 × 30 = 1.5 × 10^9,必然超时。

思考:暴力给了我们一个正确的"判定标准"——窗口内每个词的计数,必须和 words 里该词的计数完全相等,不多不少。

接下来要做的,只是把这个判定"滑"起来。


3. 关键一步:按 起点 % len 分组

3.1 为什么可以"跳着"枚举起点

任何一个合法的串联子串,它的第 k 个词一定从 起点 + k·len 开始。

也就是说,词与词的边界,被 len 完全固定死了。只要起点确定,整条"切块网格"就确定。

于是:

起点相差 len 的两个窗口,中间的 m-1 块是同一批,只差一头一尾——这才有资格做滑动窗口。

起点相差 1 的两个窗口呢?切块完全错位,没法共享状态。

3.2 分组:把起点按余数分跑道

相位 0: [bar][foo][the][...]     ← 起点 0, 3, 6, ...
相位 1: [arf][oot][he.][...]     ← 起点 1, 4, 7, ...
相位 2: [rfo][oth][e..][...]     ← 起点 2, 5, 8, ...
  • 每个相位内部,块边界是同一套网格,可以在块序列上滑窗;
  • len 个相位,恰好覆盖所有起点,不重不漏。

思考:注意例 1 的答案 9 不是 len 的倍数,但它属于相位 0(9 % 3 == 0),只是相位 0 上的下一个窗口位置。所以"一个相位"不等于"一个答案",相位里还要继续滑。

3.3 组内怎么滑

窗口在字符上是 [left, right + len),在块上是"若干个连续块":

  • 每轮 right += len,加入一个块;
  • 如果窗口块数超过 m,就 left += len,弹出一个块;
  • 每轮检查"当前窗口是否恰好匹配";
  • 用一张 hash2 记录窗口内块的频次,用一个 count 记录"已满足的需求数"。

因为 right 和 left 每次都只动一个块,窗口最多超出一个块,所以收缩用 if 就够了,不需要 while。


4. 第一版代码(然后 WA 了)

思路看起来没问题,我写出了第一版:

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        unordered_map<string, int> hash1;
        for (auto &s: words) hash1[s]++;

        unordered_map<string, int> hash2;   // ← 问题就出在这一行
        int len = words[0].size(), m = words.size();
        vector<int> ret;
        for (int i = 0; i < len; i++) {
            for (int left = i, right = i, count = 0; right + len <= s.size(); right += len) {
                string in = s.substr(right, len);
                if (hash2[in]++ < hash1[in]) count++;
                if (right - left + 1 > len * m) {
                    string out = s.substr(left, len);
                    left += len;
                    if (hash2[out]-- <= hash1[out]) count--;
                }
                if (count == m) ret.push_back(left);
            }
        }
        return ret;
    }
};

提交结果:

159 / 183 个通过的测试用例

反例:

输入:s = "aaaaaaaaaaaaaa", words = ["aa","aa"]
输出:[0,2,4,6,8,10]
预期:[0,1,2,3,4,5,6,7,8,9,10]

偶数全对,奇数全丢。 这个现象非常整齐,整齐到不像随机错误——一定是"某一整类起点"被系统性地漏掉了。


5. 用题目用例把 bug 跑出来

参数:len = 2,m = 2,窗口 4 个字符,hash1 = {aa: 2}。

5.1 相位 0(偶数起点)

hash2 是空的,一切正常:

步骤加入块hash2[aa]count窗口块数动作
right=0aa0 → 111—
right=2aa1 → 222输出 left=0
right=4aa2 → 323 → 弹出 1 块输出 left=2
right=6aa2 → 323 → 弹出 1 块输出 left=4
right=8aa2 → 323 → 弹出 1 块输出 left=6
right=10aa2 → 323 → 弹出 1 块输出 left=8
right=12aa2 → 323 → 弹出 1 块输出 left=10

相位 0 结束,输出 [0,2,4,6,8,10],而且 hash2 最后停在 {aa: 2}。

为什么?因为窗口始终保持 m 个块,相位跑完时窗口里恰好还剩 m 块,计数自然就等于 hash1。

5.2 相位 1(奇数起点)

相位 1 一进来,hash2 还是上一相位留下的 {aa: 2},而 hash1[aa] = 2:

if (hash2[in]++ < hash1[in]) count++;   // 2 < 2 → false
步骤加入块hash2[aa]判断count
right=1aa2 → 32 < 2 假0
right=3aa3 → 43 < 2 假0
right=5aa4 → 5,随后弹出 → 4假0
………永远为假永远是 0

每次加词都被判定为"已经够了",count 一次都不涨,相位 1 一个答案都输出不了。相位 2 及之后同样被污染。

5.3 结论:根因是一行

hash2 定义在 for (int i = 0; i < len; i++) 的外面。

每个相位是独立的子问题,但账本被上一相位用过了,没换新的。

left / right / count 都在循环内重置了,只有 hash2 没有。

5.4 为什么这个 bug 只会漏解、不会多解

把"已满足的需求数"记作:

f(hash2) = Σ_w min(hash2[w], hash1[w])

相位开始时 count = 0,但 hash2 带着上次的残留,记此时的值为 f0。之后每加/删一个块,count 的增量和 f 的增量是完全一致的,所以任意时刻:

count = f(当前) - f0 ≤ m - f0
  • 若 f0 > 0,count 恒小于 m,这个相位一个答案都不会输出(漏解);
  • 若 f0 = 0,这个相位才等价于"干净状态"。

所以这个 bug 只会漏,不会多。这也解释了为什么 159 个用例能过:很可能这批用例里 len = 1 的居多——只有一个相位,根本不存在"上一个相位";另外一些用例答案本身为空,漏了也看不出来。


6. 修复:把 hash2 移进循环

改动只有一行:

-        unordered_map<string, int> hash2;
         int len = words[0].size(), m = words.size();
         vector<int> ret;
         for (int i = 0; i < len; i++) {
+            unordered_map<string, int> hash2;   // 每个相位独立账本
             for (int left = i, right = i, count = 0; right + len <= s.size(); right += len) {

修复后:

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        unordered_map<string, int> hash1;
        for (auto &w : words) hash1[w]++;

        int len = words[0].size(), m = words.size();
        vector<int> ret;
        for (int i = 0; i < len; i++) {
            unordered_map<string, int> hash2;   // 关键:每个相位重置
            for (int left = i, right = i, count = 0; right + len <= s.size(); right += len) {
                string in = s.substr(right, len);
                if (hash2[in]++ < hash1[in]) count++;

                if (right - left + 1 > len * m) {
                    string out = s.substr(left, len);
                    left += len;
                    if (hash2[out]-- <= hash1[out]) count--;
                }
                if (count == m) ret.push_back(left);
            }
        }
        return ret;
    }
};

再跑那个反例:相位 1 从空的 hash2 开始,1,3,5,7,9 全部输出,和相位 0 的 0,2,4,6,8,10 合起来正好是 0 ~ 10。

复盘:这种"分组/分治"的题,凡是跨组共享的状态,都要问一句"它该不该在组开始时清零"。

这题的组是"相位",共享状态是"窗口词频"。


7. 换个角度理解 count

修好之后,我想把 count 到底在数什么彻底想清楚,因为后面所有优化都建立在它上面。

7.1 count 是"多重集交集"的大小

把两边都看成多重集:

  • hash1[w]:需要 w 几次(需求)
  • hash2[w]:窗口里现在有 w 几次(供给)

那么:

count = Σ_w min(hash2[w], hash1[w])

就是"把窗口里的块和需求清单做一一配对,最多能配上多少对"——也就是两个多重集的交集大小。

7.2 为什么不能直接数 Σ hash2

words = ["foo","bar","foo"],即 hash1 = {foo:2, bar:1},m = 3:

窗口内容hash2min 逐项count含义
foo foo foofoo:3, bar:0min(3,2)=2,min(0,1)=02多出来的 foo 没用
foo bar quxfoo:1, bar:1, qux:11 + 1 + 02差一个 foo
bar foo foofoo:2, bar:12 + 13恰好配齐

foo foo foo 的 Σ hash2 = 3,但只需要 2 个 foo,直接数会误判成"完成"。min 的作用就是每个词最多只算 hash1[w] 次,把多余的重复挡在外面。

7.3 加/删为什么用那两行就能维护

min(h2, h1) 对 h2 的斜率很特殊:h2 < h1 时每加 1 涨 1;h2 ≥ h1 时加多少都不涨。

操作条件min 变化代码
加入 wh2[w] < h1[w](正缺)+1if (h2[w]++ < h1[w]) count++
加入 wh2[w] ≥ h1[w](已够)0同上,条件不成立
弹出 wh2[w] ≤ h1[w](弹出的是有用的)−1if (h2[w]-- <= h1[w]) count--
弹出 wh2[w] > h1[w](弹出的是多余的)0同上,条件不成立

注意弹出判断用的是弹出前的旧值(h2[out]-- 是后置自减):h2 == h1 时算"有用",要减;h2 == h1 + 1 时说明这份是多余的,减完仍 ≥ h1,不减 count。

7.4 count == m 为什么就等价于"恰好匹配"

  1. count = m = Σ hash1 ⇒ 每一项都取满 ⇒ 对所有 w,h2[w] ≥ h1[w];
  2. 所以窗口块数 Σ h2 ≥ Σ h1 = m;
  3. 而窗口收缩条件保证块数 ≤ m。

两边一夹:块数恰好 m,且总量相等、每个词都不缺 ⇒ h2 == hash1,一个不多一个不少。

所以"长度 == m·len"不是判定条件,它只负责决定什么时候弹出。count == m 本身已经蕴含了长度正确。


8. 改进一:加 count 守卫,别让垃圾块污染哈希表

修好重置问题之后,代码能 AC,但还有一个隐患:s 里大量块根本不在 words 中。

if (hash2[in]++ < hash1[in]) count++;   // 未知块也会往 hash1、hash2 里各插一个键

unordered_map::operator[] 在键不存在时会插入默认值,于是:

  • hash2 会膨胀到 O(n) 个不同的块键;
  • hash1 被 s 里的词不断污染,键越来越多,查找变慢;
  • 虽然不影响 count 的正确性(min(k, 0) = 0),但纯属浪费内存和时间。

加一个守卫即可:

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        unordered_map<string, int> hash1;
        for (auto &s: words) hash1[s]++;

        int len = words[0].size(), m = words.size();
        vector<int> ret;
        for (int i = 0; i < len; i++) {
            unordered_map<string, int> hash2;
            for (int left = i, right = i, count = 0; right + len <= s.size(); right += len) {
                string in = s.substr(right, len);
                if (hash1.count(in) && hash2[in]++ < hash1[in]) count++;

                if (right - left + 1 > len * m) {
                    string out = s.substr(left, len);
                    left += len;
                    if (hash1.count(out) && hash2[out]-- <= hash1[out]) count--;
                }
                if (count == m) ret.push_back(left);
            }
        }
        return ret;
    }
};

两处都要加守卫,加入和弹出必须对称:未知块既然没被记录,弹出时也不能去减它。

这是自洽的:每个进入窗口的"已知词"一定被记录过,所以弹出时 hash2[out] ≥ 1,不会减成负数;未知块在两边都被跳过,不影响 count。

思考:这个守卫是"正确性不变、性能变好"的典型改动。写的时候要问自己:加入和弹出是否对称? 只加一边,必出负计数。


9. 改进二:find 复用迭代器

接下来是一个很容易被误解的点。

9.1 先纠正一个直觉

有人会问:find 和 count 时间复杂度不是一样吗?为什么说 find 更快?

单次调用确实一样:都是"对参数算一次哈希 O(len) + 走一次桶链(期望 O(1))"。

差别不在单次调用,而在整行调用了多少次:

整行代码对 hash1 的调用对 hash2 的调用对 in 算哈希的次数
hash1.count(in) && hash2[in]++ < hash1[in]count + operator[] = 2 次1 次3 次
find(in) + it->secondfind = 1 次1 次2 次

关键点:

  • it->second 是解引用迭代器,不查表、不算哈希(哈希在 find 时已经算过,迭代器直接指向节点);
  • hash1[in] 是又一次独立调用,标准库不会因为刚调用过 count(in) 就缓存参数的哈希。

所以准确的说法是:

count 和 find 单次同复杂度;差别在于 find 一次调用就同时拿到了"在不在"和"值是多少",而 count 只拿到"在不在",值还得再查一次。

9.2 改法

auto it = hash1.find(in);
if (it != hash1.end() && hash2[in]++ < it->second) count++;

弹出同理:

auto jt = hash1.find(out);
if (jt != hash1.end() && hash2[out]-- <= jt->second) count--;

9.3 但别把它当"复杂度优化"

渐近复杂度完全一样:

你的版本:n 块 × 3 次哈希 = O(n·len)
find 版本:n 块 × 2 次哈希 = O(n·len)

只是命中时少了约 1/3 的哈希计算。本题 n ≤ 1e4、len ≤ 30,总块数才 1e4 量级,这点差异对 AC 毫无影响。

真要抠常数,substr 的堆分配比这几次 map 查找贵得多,改成 string_view 收益更大:

string_view in(s.data() + right, len);   // C++17,零拷贝

9.4 顺手记一个"一次查找"的写法

如果确实想把每块压到"一次查找",可以把需求和窗口量塞进同一个节点:

struct Node { int need = 0, have = 0; };
unordered_map<string, Node> book;
for (auto &w : words) book[w].need++;

加入时:

auto it = book.find(in);
if (it != book.end()) {
    if (it->second.have < it->second.need) ++count;
    ++it->second.have;
}

弹出时:

auto jt = book.find(out);
if (jt != book.end()) {
    if (jt->second.have <= jt->second.need) --count;
    --jt->second.have;
}

每块 1 次哈希 + 1 次查找。代价是每个相位要重建/重置所有 have(O(不同词数),最多 m,总量 O(m·len)),或者给每个词编个 id、用 vector<int> 做 O(1) 数组访问。

对本题来说属于"为了常数写更多代码",面试时没必要,知道有这条路即可。


10. 最终代码

class Solution {
public:
    vector<int> findSubstring(string s, vector<string>& words) {
        unordered_map<string, int> need;
        for (auto &w : words) need[w]++;

        int len = words[0].size(), m = words.size();
        int n = s.size();
        if (1LL * m * len > n) return {};        // 提前剪枝

        vector<int> ans;
        for (int phase = 0; phase < len; phase++) {
            unordered_map<string, int> have;      // 每个相位独立账本

            for (int l = phase, r = phase, valid = 0; r + len <= n; r += len) {
                // 加入一个块
                string in = s.substr(r, len);
                auto it = need.find(in);
                if (it != need.end() && have[in]++ < it->second) valid++;

                // 块数超过 m,弹出一个块
                if (r - l + 1 > len * m) {
                    string out = s.substr(l, len);
                    l += len;
                    auto jt = need.find(out);
                    if (jt != need.end() && have[out]-- <= jt->second) valid--;
                }

                if (valid == m) ans.push_back(l);
            }
        }
        return ans;
    }
};

几处小细节:

  • for (auto &s : words) 里的 s 会遮蔽函数参数 s,改名 w 更清楚;
  • right + len <= s.size() 是 int 和 size_t 混比,先取 int n = s.size();
  • m * len 用 1LL 防溢出(本题最大 150000,其实不会溢出,但习惯成自然);
  • 窗口块数超了就用 if,因为每轮 right 只加一块,最多超一块。

11. 正确性:三个问题

Q1:所有合法起点都被检查到了吗?

任一合法子串的块边界必为 start + k·len,所以它必然属于 start % len 那个相位。len 个相位都跑了,覆盖所有起点。

Q2:窗口是"恰好"匹配吗?

检查点处窗口长度 ≤ m·len,即块数 ≤ m;而 valid == m 意味着每个词都已被满足,块数 ≥ m。两边夹住 ⇒ 块数恰好 m、多重集恰好相等。

Q3:valid 数得准吗?

由 valid = Σ min(have, need) 的不变量,加入/弹出按 7.3 的规则更新,始终维持等式;而 valid == m = Σ need 等价于每个 have[w] ≥ need[w] 且总量相等。


12. 复杂度

时间:O(n · len)

  • 所有相位的块数总和 ≈ n(len 个相位,每个相位约 n / len 块);
  • 每块的主要开销是 substr 拷贝 + 哈希,各 O(len);
  • 总字符量约 n · len,本题最大 3 × 10^5,非常宽裕。

空间:O(m · len)

  • need 存 m 个词,每词长 len;
  • have 最多 m 个键(每个相位重建,不会跨相位累积)。

对比暴力:

方案时间复杂度本题量级
暴力枚举 + 逐块比对O(n·m·len)1.5 × 10^9
分组滑动窗口O(n·len)3 × 10^5

差三个数量级。


13. 坑点清单

#坑后果怎么防
1hash2 没按相位重置状态污染,只漏不多把 hash2 定义进相位循环
2用 set 而不是计数 map重复词直接判错用 unordered_map<string,int>
3count 和 hash2 更新不同步不变量破坏,时对时错加/删都走同一套 min 规则
4收缩用 while 而不是 if可能多弹(本题每轮只超一块)想清楚"每轮最多超几块"
5hash1[in] 不判存在往 hash1 插垃圾键,map 膨胀加 count/find 守卫
6加入加了守卫、弹出忘了hash2 出现负数,count 错乱加/删守卫必须对称
7int 与 size_t 混比警告,极端情况逻辑错先取 int n = s.size()
8没判 m·len > n白跑一轮开头提前返回
9忘记词可能重复答案缺失计数,不计数就错
10substr 到处都是常数偏大需要时换 string_view

14. 横向对比

方案时间空间关键假设典型场景
枚举起点 + 逐块比对O(n·m·len)O(m·len)无对拍用
枚举起点 + 窗口排序O(n·m log m·len)同上无更慢,不推荐
分相位定长滑窗(本文)O(n·len)O(m·len)词等长、恰好用完本题、567、438
不定长双指针(need/have)O(n)(字符级)O(Σ)允许"包含"76 最小覆盖子串
Trie / 回溯 / DP最坏指数O(总词长)词可不等长单词拆分类
AC 自动机O(n + 总词长)O(总词长·字符集)多模式、允许重叠敏感词、出现次数
前缀哈希 / Rabin-KarpO(n)(期望)O(n)需防碰撞len 大、n 大时提常数

15. 还能复用到哪

  1. 定长窗口 + 频次表(len = 1 的退化情形,只跑一个相位):
    • 567 字符串的排列
    • 438 找到字符串中所有字母异位词
    • 本质是同一份代码:把"字母"换成"词"。
  2. need / have 需求计数:
    • 76 最小覆盖子串:窗口不定长、收缩用 while、找"最小"而非"恰好";本文是它的"定长简化版"。
    • 面试题 17.18 最短超串:同样是"覆盖计数"。
  3. 按模分组 / 相位分解(不限于字符串):
    • 把"所有 i ≡ r (mod k) 的位置"作为一个独立子问题,是处理周期性 / 网格对齐问题的通用手法;
    • 例:3137 K 周期字符串的最少操作次数,就是按 i % k 分组统计众数;
    • 也可迁移到"矩阵按行/列/对角线分组"“等间隔采样序列”。
  4. 可增量维护的判定量:把"是否匹配"设计成一个加/删都 O(1) 更新的标量(valid),是滑动窗口题的工程核心。
  5. 字符串 → ID 的映射:unordered_map<string,int> 实际在给词编 ID;换成前缀哈希/双哈希,就是 Rabin-Karp 版本。

16. 背下来的模板

1. 模式串是否等长?
   ├─ 是 → 设 len,窗口总长 = m·len,进入 2
   └─ 否 → 放弃分相位,考虑 Trie / DP / AC

2. 要求"恰好用完"还是"包含即可"?
   ├─ 恰好 → 定长窗口(块数固定 m),valid == m 即答案
   └─ 包含 → 不定长窗口,while 收缩找最小(76 套路)

3. 枚举相位 phase = 0 .. len-1
   4. 组内滑动:r += len 加块,超长则 l += len 弹块
   5. 用 valid = Σ min(have[w], need[w]) 增量维护匹配度
   6. valid == m 时记录 l

7. 自查:hash2 是否每组重置?收缩是否只需一次?加/删是否对称?两端是否都在网格上?
for (int phase = 0; phase < len; phase++) {
    unordered_map<string, int> have;          // 必须每组新建!
    int valid = 0;
    for (int l = phase, r = phase; r + len <= n; r += len) {
        string in = s.substr(r, len);
        auto it = need.find(in);
        if (it != need.end() && have[in]++ < it->second) valid++;

        if (r - l + 1 > len * m) {             // 块数超了,弹一块
            string out = s.substr(l, len);
            l += len;
            auto jt = need.find(out);
            if (jt != need.end() && have[out]-- <= jt->second) valid--;
        }
        if (valid == m) ans.push_back(l);
    }
}

17. 版本演进一览

版本相对上一版改了什么结果教训
V1hash2 放在相位循环外159/183,偶数对奇数全丢分组题的共享状态必须按组清零
V2hash2 移进相位循环AC一行位置,决定对错
V3加 hash1.count 守卫AC,hash1/hash2 不再被垃圾键污染加/删守卫必须对称
V4find 复用迭代器AC,命中时少一次哈希count + [ ] 是两次查找;但只是常数优化
V5(可选)need/have 合并进一个节点每块只查一次表代码变长、要处理重置,收益有限

最后留一句话给下次的自己:

看到"等长模式串 + 恰好用完",先想分相位,再想定长滑窗,最后想用 min 维护匹配度。
动笔前先问:每组开始时,哪些状态必须清零?


如果这篇对你有帮助,欢迎点赞收藏。下一篇可以聊聊 76 最小覆盖子串——把定长窗口换成不定长,need/have 是同一套思想。

【局部规划模块轨迹优化算法】EM_planner最大期望滚动优化算法 认知有限,望大家多多包涵,有什么问题也希望能够与大家多交流,共同成长!本文先对EM_planner最大期望滚动优化算法做个简单的介绍,具体内容后续再更,其他模块可以参考去我其他文章提示:以下是本篇文章正文内容。 阅读详情

相关推荐

Qwen3-VL、Qwen3-Next与Qwen3.5多模态架构深度解剖

多模态大模型的核心不在参数规模,而在于视觉与文本如何协同建模。本文从基础概念切入,解析视觉语言模型中视觉编码器、跨模态注意力、特征对齐与token压缩等关键原理;阐述ViT、CLIP-ViT及动态压缩模块(HDTC)在语义表征、空间感知与计算效率上的技术权衡;强调结构设计如何决定模型在医学影像、工业质检、遥感分析等高要求场景中的真实能力边界;最终聚焦通义千问最新三套VL架构——Qwen3-VL、Qwen3-Next与Qwen3.5——揭示其背后迥异的融合哲学与工程取舍,为选型、微调与推理优化提供底层依据。

weixin_33778544的博客 822

华为OD机试模拟题10:滑动窗口与哈希表解字符串串联子串

字符串匹配是算法面试与机试中的高频考点,尤其在处理子串查找、频次统计和去重场景时,哈希表与双指针的组合往往能大幅优化性能。滑动窗口作为双指针技术的核心延伸,通过维护动态区间内的有效信息,将暴力枚举的重复计算降为线性复杂度,是解决固定长度子串、最小覆盖子串等问题的通用模型。此类技术不仅适用于华为OD机试的压轴题,也广泛出现在各类公司笔试与LeetCode经典题目中。理解窗口分组、匹配计数与边界收缩原理,能够帮助开发者应对大数据量下的超时挑战,提升代码的工程可靠性。文章以一道华为机试模拟题为例,从暴力解法切入,

weixin_30606461的博客 371

UNITY3D万人同屏,Dots万人同屏解决方案_类萌宠宠之战

UNITY3D弹幕游戏开发,万人同屏解决方案

6480

力扣周赛实战:Python算法模板与赛前热身复盘指南

在算法学习与编程面试准备中,很多人会忽视系统化训练的价值。通过数据结构如哈希表、并查集、滑动窗口等基础工具,理解它们的工作原理与适用场景,是解决复杂问题的前提。掌握时间复杂度与复杂度的分析方法,能在竞赛与面试中快速定位解法的边界;而内置模块如 bisect、heapq 的熟练运用,则显著提升编码效率。从技术价值看,周赛提供了高密度反馈的训练场,能帮助开发者锻炼临场调试、时间分配与复盘总结的能力,并将这些软实力自然迁移到实际工程与面试场景。本文以力扣周赛实战为例,结合赛前热身、时间管理、Python提速技巧与

weixin_29196891的博客 261

机械臂抓取前言

机械臂相关的笔记

weixin_64037619的博客 3913

AI人工智能领域多模态大模型的数字孪生应用

本文旨在系统性地介绍多模态大模型在数字孪生领域的最新应用进展,探讨其技术原理、实现方法和应用价值。内容范围涵盖从基础概念到前沿技术,从理论分析到实践案例。文章首先介绍多模态大模型和数字孪生的基本概念,然后深入分析两者的结合点,接着通过具体案例展示应用实践,最后探讨未来发展趋势和挑战。多模态大模型:能够同时处理和融合多种数据模态(如文本、图像、视频、音频等)的大型人工智能模型数字孪生:物理实体或系统的虚拟副本,通过实时数据同步实现虚实交互跨模态融合:将不同数据模态的信息进行有效整合和关联的技术。

AI云原生与云计算技术学院 1329

力扣周赛485场复盘:滑动窗口与动态规划实战解析

滑动窗口和动态规划是算法竞赛中的核心解题技术。滑动窗口通过维护可变区间来高效处理连续子序列问题,其O(n)时间复杂度特性使其成为数组操作的利器;动态规划则通过状态转移方程和记忆化存储,将指数级问题优化为多项式时间复杂度。这两种技术在力扣周赛等高强度编程竞赛中具有极高应用价值,既能解决基础题目如《最大连续1的个数》,也能应对《矩阵中的最长递增路径》等高级问题。本文结合485场周赛真题,详解如何运用滑动窗口处理二进制序列,以及如何通过记忆化DFS优化动态规划实现,并分享二分查找转化NP难问题的工程实践技巧。

weixin_32576389的博客 16

利用makehumancommunity导入人体模型到COMSOL里(需要solidwork)

#makehumancommunity #solidwork #COMSOL

qq_41227634的博客 2164

LeetCode 10/100复盘:最长回文子串、01背包与二分答案边界实战

在算法面试与工程笔试中,动态规划和二分查找常被视为核心基础。动态规划通过拆分子问题记录状态,适合处理回文子串判断;中心扩展法则利用对称性降低空间开销。01背包问题则展示了如何将正负号组合转换为子集和求解,思路值得借鉴。二分答案用于解决最小速度等单调性问题,边界处理是正确性的关键。本文以刷LeetCode热门100题至10/100为线索,详细复盘了最长回文子串、目标和、爱吃香蕉的狒狒三道题,从超时暴力到最优解法的全过程,并总结高错误率细节与复刷策略,适合初学者对标自查。

weixin_30846347的博客 247

SAP ABAP CO核心扩展-为企业定制ZCKM3N物料价格分析增强(CKM3 CKM3N CKM8N)

这篇文章,将为大家讲述物料价格分析扩展增强(ZCKM3N)的方法和原理,并基于CKM3N的视图之一“CV成本组件”,教大家如何一步步实现批量输出多工厂物料的物料价格分析报表。

SAP李斌,本人承诺所有原创文章均不使用任何AI生成技术,请大家放心阅读。 3992

OpenHarmony Stage模型深度解剖:从Ability Kit到沙箱隔离的全链路底层原理

基于微内核架构,提供进程管理、内存管理、IPC通信等基础能力:包含V8引擎、ArkTS运行时、渲染引擎等核心组件:Ability Kit框架,提供应用生命周期管理、组件调度等能力:基于Stage模型的应用程序。

m0_67505153的博客 194

LeetCode周赛无伤AK复盘:从赛前准备到模板代码

算法竞赛中,稳定高效的解题能力源于系统训练与模板积累。掌握二分查找、滑动窗口等基础数据结构和算法原理,能显著提升代码正确率与时间效率,这些技能在工程实践与面试中同样具有重要价值。针对LeetCode周赛这类限时编程挑战,如何通过赛前准备、赛中节奏控制与赛后复盘实现理想表现?以第521场周赛为例,复盘从环境配置到模板代码的完整流程,提供可复用的算法模板与自查清单,帮助开发者将临场发挥转化为稳定输出,逐步接近“无伤AK”的目标。

weixin_42570296的博客 144

【在 WSL2 GUI 中使用 pulseaudio 播放声音】

最近在搞一个Linux项目,由于WSL2中需要用到声音外放,无奈只能潜心研究。后来就使用了一种折中的方式替代,那就是pulseaudio。目前来讲WSL2对硬件外设的支持还是不太友好,关于USB的支持我之前在其他文章中已经论述过了,这里不讨论。1、Windows11别忘记打开声音2、可能有一定延迟,因为是通过网络传输的。3、效果的话只能见仁见智了,如果不能满足要求就安装一个实实在在的Ubuntu吧!

jiexijihe945的博客 4534

[LeetCode周赛复盘] 第 315 场周赛20221016

滑窗

liuliangcan的博客 855

ET2012新版免狗免安装绿色软件

ET2012新版免狗免安祖昂绿色软件。,新界面,新视觉,

霍尼韦尔SoftMaster使用说明

霍尼韦尔SoftMaster使用说明

LeetCode刷题复盘:四道高频题从思路到避坑全解析

在算法面试准备中,LeetCode刷题是绕不开的环节。理解数组、链表、动态规划与滑动窗口等核心数据结构和算法原理,是提升解题效率的关键。前缀和与哈希表的配合能优化子数组求和问题,哨兵节点简化链表操作,状态转移方程决定动态规划解法,而滑动窗口的双指针维护则考验边界处理能力。这些技术不仅用于线上笔试,更是面试现场手写代码的常考能力。通过复盘典型题目中的错误提交与调试过程,尤其是哈希表初始化遗漏、窗口过期状态判断等细节,能帮助开发者建立更扎实的解题框架。围绕一次完整的刷题复盘,可提炼出可复用的思路模板与排查技巧,

weixin_30512965的博客 258

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

LeetCode刷题Day10:单词规律与同构字符串,吃透双向映射

在算法与数据结构的学习中,哈希表是解决映射类问题的核心工具,而双射关系则是这类题目背后的数学本质。许多初学者在使用HashMap时,往往只关注正向映射而忽略反向校验,导致在面对“单词规律”和“同构字符串”这类经典LeetCode题目时反复出错。本文从双射的概念出发,深入拆解单向映射与双向映射的区别,对比双HashMap、Map加Set、数组模拟三种实现路线的优劣,并结合Java代码逐行分析边界条件和常见坑点。掌握这套双向映射的通用解题模板,不仅能轻松攻克LeetCode 290和205,还能为后续字符串映射

weixin_32612263的博客 260

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

LeetCode 79 单词搜索:DFS 回溯模板与剪枝优化全解析

深度优先搜索(DFS)是算法面试中的核心基础,常用于解决二维矩阵中的路径枚举问题。其基本原理是沿一个分支递归到底,遇到障碍后回退并恢复现场,从而穷举所有可行路径。结合回溯算法、剪枝优化和状态标记,可有效降低无效搜索,提升在线判题通过率。这类思路广泛应用于 LeetCode 热门题中的单词搜索、岛屿数量、组合总和等场景。针对第 79 题单词搜索,核心是从每个起点尝试匹配目标单词,通过 visited 标记避免重复走格子,先做字符频率预检与反向搜索能显著提速。掌握这套模板后,可自然迁移到单词搜索 II 等 DF

weixin_31421613的博客 277

LeetCode 1297题解:滑动窗口+哈希表统计子串最大出现次数

字符串处理是算法面试中的高频考点,尤其是涉及子串统计与频率分析的问题。LeetCode 1297要求在所有满足长度限制与字符种类上限的子串中,找出出现次数最多的一个。很多解法会盲目枚举所有长度区间,导致时间复杂度爆炸。事实上,这类问题可以利用滑动窗口与哈希表的经典组合进行优化。滑动窗口能够在一次遍历中维护固定长度的子串特征,哈希表则负责记录每个子串的出现频率。面对多个限制条件,需要识别冗余参数,抓住真正影响结果的核心维度,从而大幅降低计算量。本文从字符串算法的基础概念出发,讨论子串频率统计的常见思路与工程实

weixin_34060299的博客 136

Python刷题心法:从力扣新手到算法高手的实战进阶指南

算法与数据结构是编程的核心基础,其本质是通过高效组织与处理数据来解决复杂问题。理解其原理能显著提升代码性能与问题解决能力,在面试、系统设计和性能优化等场景中具有极高价值。本文聚焦Python语言在算法学习中的应用,深入探讨双指针、滑动窗口、动态规划等核心算法思想,并结合力扣(LeetCode)平台,系统分享从环境配置、心态管理到专题突破、深度复盘的完整刷题方法论。通过剖析Python实现中的常见陷阱与优化技巧,旨在帮助开发者建立坚实的算法知识体系,实现从暴力解法到最优解的思维跃迁,最终在工程实践与求职竞争中

weixin_30655569的博客 456

从双指针到前缀和:力扣数组题高频模板与边界避坑指南

数组是算法中最基础的线性数据结构,也是力扣题库中出现频率最高的题型之一。面对数组题,高效解题往往依赖双指针、滑动窗口、前缀和等经典技巧:双指针利用有序性将O(n²)循环降为O(n),滑动窗口动态维护连续子区间,前缀和则让区间查询从O(n)降为O(1)。在工程实践中,这类技巧不仅是应对算法面试的核心能力,也是提升代码复杂度意识的关键。对于准备刷题或卡壳的开发者,从基础结构切入、理解数据规模与边界条件,往往比盲目追求难题更有效。本文结合高频考点和真实踩坑记录,梳理数组题的常见模板、边界避坑方法与三阶段刷题节奏,

weixin_29587015的博客 204

[LeetCode周赛复盘] 第 329 场周赛20230122

大年初一,和昨晚一样出脑筋急转弯找规律,被自己笨哭。T1 模拟。T2 调库。T3 找规律。T4 序列DP。

liuliangcan的博客 1831

[LeetCode周赛复盘] 第 345 场周赛20230514

干T2写wa了T1 模拟。T2 递推模拟。T3 DP或bfs。T4 图论并查集。

liuliangcan的博客 481

力扣刷题全攻略:八大题型分类与Hot 100高效刷题路线

算法面试考察的是解决问题的思维模型,而非题量积累。面对海量题库,若按题号顺序硬刷,不仅效率低下,还难以应对新题。将题目按解题思维分为数组哈希、双指针、二叉树、动态规划、回溯等八大类,能帮助学习者快速识别题目模式,建立条件反射。热题100作为高频考点合集,配合四轮专题刷题法,可系统提升代码能力与面试表现。三维接雨水等综合题更体现了堆、BFS与边界思维的交叉,是检验进阶水平的试金石。本文梳理了完整的力扣刷题路径与复盘方法,助力读者高效备战算法面试。

weixin_34183910的博客 174

LeetCode周赛无伤AK实战:从哈希表到二分查找的算法精解

算法与数据结构是计算机科学的核心基础,其原理在于通过高效组织与管理数据,优化问题求解过程。掌握经典算法如哈希表、滑动窗口、贪心与二分查找,能极大提升代码效率与程序性能,技术价值体现在应对海量数据处理、实时系统优化等场景。在编程竞赛与面试中,这些算法常被用于解决数组操作、字符串处理与最优化问题。本文以LeetCode周赛实战为例,深入剖析如何运用哈希表处理元素查找,以及通过二分查找求解最小速度问题,结合滑动窗口与贪心策略,详细拆解无罚时通关的解题思路与易错点,为算法学习与竞赛备战提供工程实践参考。

weixin_30715523的博客 380

LeetCode周赛无伤AK攻略:从算法原理到实战技巧

算法竞赛中,时间复杂度和空间复杂度是衡量算法效率的核心指标,它们直接决定了代码在限定资源下的执行能力。理解常见数据结构如数组、哈希表、栈、队列以及动态规划、深度优先搜索等基础算法原理,是解决复杂问题的基石。这些技术通过优化计算过程,在数据处理、系统设计、人工智能等领域具有重要价值。在编程竞赛场景下,选手需在高压环境中快速实现无错误代码,这对代码稳定性与一次性正确率提出了极高要求。本文结合【无伤AK】和【国服排名】等热词,探讨如何通过系统训练与策略优化,在LeetCode周赛中实现零罚时通关,提升竞赛表现。

weixin_30628801的博客 372

LeetCode周赛512复盘:从数组操作到二分查找的算法实战

在算法竞赛和日常开发中,数组操作、二分查找和字符串处理是基础且高频的技术点。数组的双指针遍历是处理有序或两两配对问题的核心技巧,其原理在于通过头尾索引的协同移动,在O(n)时间复杂度内完成搜索或模拟。二分查找则利用数据有序性,将线性查找优化为对数级,是解决“在有序集合中快速定位”问题的利器,技术价值在于大幅提升海量数据下的查询效率。这些技术广泛应用于性能优化、区间统计和资源分配等场景。本文以LeetCode第512场周赛为例,通过“找出数组的串联值”和“统计公平数对的数目”等题目,具体展现了如何运用双指针模

weixin_34406086的博客 312
上一篇: 滑动窗口_LeetCode_438. 找到字符串中所有字母异位词:滑动窗口 + 计数器最详解
下一篇: 二分查找_LeetCode_704. 二分查找:思路、循环不变式、复杂度与复用边界
slippin-away
博客等级 码龄1年 12粉丝 34原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值
⌂ 换网址