【C++】【STL】stack_OJ题

🔥 H.莓飛: 个人主页
✨ 心不畏死,踏屍前行。
📦 代码仓库:cocatrice_csdn_code
📖 博主简介:

概览
- 844 从右往左双指针扫,空间压到零字节
- 155 数据栈旁边挂一条等高的最小值栈
- 739 单调栈里存下标,出栈那一刻写答案
- 496 先把 nums2 跑一遍,答案落进哈希表
- 84 两头加高度零的哨兵,弹出时算面积
- 946 按 pushed 逐个压,能弹就弹到底
- 394 数字栈配字符栈,一层括号展开一次
- 71 按斜杠切段,段进栈,两点弹一段
- std::stack 的默认后端是 deque
核心知识
一、全篇概述
八道题按栈在里面承担的角色分成两组,前面四道用栈缓存还没配上对的元素,后面四道用栈记住进入这一层之前的样子。前一组的分支落在比较条件上,谁比谁大、什么时候该弹、弹出来之后答案写到哪一格;后一组的分支落在进入与退出的时机上,什么时候压、压进去的是下标还是值、退出的时候该把谁拼回去。分组的依据是栈干了什么活,跟题号的先后与题目的难度都没有关系。
第一组四道题的共同形状是等到某个时刻再回头结算,844 等到读到一个退格才回头删掉前一个字符,155 等到取最小值时才回头看历史,739 等到出现更高的温度才把压在栈里那几天的答案补齐,496 等到 nums2 里冒出一个更大的数才把栈里比它小的数一次性结清。这四道题的答案在扫描过程中一个个填进去,填完之后再没有人回头改。
第二组四道题用栈保存的是层次,84 把还没确定右边界的柱子按高度递增压在栈里,946 用一条栈模拟那个只进得去出不来的通道,394 把每一层的重复次数与已经拼好的前缀分别压进两条栈,71 把还没被两点消掉的目录名按顺序压在栈里。这四道题的栈顶永远对应最近一次还没闭合的那一层,弹栈的动作就是这一层结束的信号。
还有一层区别落在栈里存的是值还是位置上。739 与 84 的栈里存的是下标,因为答案要的是距离与宽度,值本身可以从下标反查出来;496 的栈里存的是值,因为要拿这个值去哈希表里当键;394 的两条栈存的类型都不一样,一条装整数一条装字符串;71 的栈里装的是整段目录名。存值还是存下标这件事看着是随手决定的,实际上决定了出栈时能不能算出答案,739 存值就写不出相隔天数,84 存值就算不出宽度。
这一批八道题的主解一律拿 std::vector 当栈用,压栈是 push_back、看栈顶是 back、出栈是 pop_back,三行封装与 std::stack 的 push/top/pop 一一对应。选它的理由落在内存与可读性上:元素在内存里连着放,调试时整条栈一眼能看完,代码也只多出三个别名,压栈速度并不占优。三个后端在五百万个 int 上的读数把账摆得很清楚,内存增量上 vector 是 19728 KB、每元素 4.04 字节,deque 是 20684 KB、每元素 4.24 字节,list 是 156300 KB、每元素 32.01 字节;压栈耗时上前两名倒了过来,deque 后端 17.115 毫秒、vector 后端 31.961 毫秒、list 后端 126.857 毫秒。vector 多出来的那一截落在扩容上,从 1 个一路翻倍到 8388608 个,每翻一次倍就把已经压进去的元素整体搬到新块里,累计搬过的 int 有 838 万个;deque 只往后加段,从不回头搬已压好的元素。
八道题的答案类型也值得先看清:844 与 946 返回的是一个布尔值,155 返回的是四类操作的结果,739 与 496 返回的是一条与输入等长的数组,84 返回一个整数,394 与 71 返回一条新串。返回数组的两道题都在扫描过程中把答案写进一个预先开好的数组里,返回串的两道题都是边扫边拼,返回整数的 84 把最大值维护在一个变量里。返回值的形状不同,栈的寿命也就不同:前四道题的栈用完即弃,后四道题的栈要一直活到扫描结束才清空。

图 1 八道题按栈的作用分成两组,一组算计数,一组拼结构
二、边界值
八道题的输入形状差得远,出错的位置却挤在六处,每一处都在随机数据里几乎不会出现,只能照着形状单独准备。下面六段按题号的先后排,每一段说清这一处边界在这八道题里具体长什么样,以及回显里那几行写死的用例是怎么造出来的。
空输入这一处横跨全部八道题,两条空串、空数组、空栈、空路径各有各的正确返回。844 的两条空串判等要返回 true,739 的空数组要返回一个空数组而不是返回一个长度为一的零,84 的空数组面积是 0,946 的两条空序列算合法,71 的空串按题面的约定返回根路径一个斜杠,394 一条没有括号的普通串要原样返回。这几处如果不单写用例,随机生成器几乎不会给出长度为 0 的输入。
单元素这一处会打掉一半的循环写法,739 只有一个温度时答案是 0 而不是空数组,946 只有一个压栈值时两条序列必须一模一样才算合法,84 只有一根柱子时最大面积就是这根柱子的高度,496 的 nums2 只有一个元素时所有答案都是负一。单元素这一处的共同点是循环进得去、返回退得出来,凡是把首元素的特判写在循环体里的写法,都会在长度为一的输入上多跑一轮。
全相同值这一处专门抓比较符号写没写反,739 的 50 50 50 50 全等输入下答案全是零,因为题面要求严格大于才算更高的温度;84 的 3 3 3 三个等高柱子最大面积是九,它来自三根柱子的并集而不是单根;946 的 7 7 7 因为值相同,每条弹出序列都合法;155 连压五个相同的五之后 getMin 仍然是五。把小于等于写成小于,这一处立刻就会崩,而在随机数据里相等相邻的概率只有几十分之一。
栈空之后还要不要弹这一处是这八道题最集中的坑,844 的 ####a 退格比字符多,弹到空栈之后再来一个退格就得原地跳过;71 的 /a/b/c/.../.../... 上跳的次数比已有的层数多,弹到根之后剩下的两点全部作废;946 弹栈之前要先看栈顶等不等于待弹出的值,不等时不能硬弹;155 把栈清空之后再压一个新的值,最小值必须跟着更新。回显里这四条都单独立了用例,844 那条打印的是 true,71 那条打印的是根路径。
嵌套层数与递归深度这一处只出现在 394 与 946 里,394 的括号可以套任意多深,递归写法每一层嵌套占一格函数栈帧,深度一百层的字符串在双栈写法上是 0.062 毫秒、在递归写法上是 0.076 毫秒,两边都能出结果,深度到十万层时递归那一边直接段错误退出,回显里那一行是 Segmentation fault 与退出码 139,而双栈写法 4.684 毫秒就算完了。
计数与类型这一处藏得最深,84 里柱子的最大高度一亿、柱子数二十万,两者的乘积两万亿早就超出了 int 的范围,必须用 long long 承接;496 的哈希表键是数组里的值而不是下标,值域一大就要考虑 unordered_map 的桶数;739 的答案存的是相隔天数,计数器与下标的类型必须一致,混用 int 与 size_t 时减法会拐成天文数字。这一处不会让程序崩,只会让答案错得很离谱,回显里 84 那道题二十万根柱子跑出来的答案是 582134,这个数如果被 int 截断就会变成一个负数。
六处边界在驱动里的写法是同一套:每条用例单独起一个作用域,造好输入、调两个实现、比一遍、打印一行带 edge 前缀的结果。这样写的好处是任何一条崩了,回显里最后一行的前缀就能定位到是哪一处;坏处是八道题乘上十几条之后驱动会长到两三百行,比解法本身还长。这一批的驱动加起来一千一百多行,八道题的解法本身不到三百行,比例看着夸张,但正是这几百行让每一个数都能当场重跑一遍。
三、题目总览
| 题号 | 题目 | 关键动作 | 时间 |
|---|---|---|---|
| 844 | 比较含退格的字符串 | 两串各配一个退格计数,从右往左比 | O(n + m) |
| 155 | 最小栈 | 最小值栈与数据栈等高,同步压同步弹 | 各操作 O(1) |
| 739 | 每日温度 | 栈里存下标,遇到更高的温度就出栈填答案 | O(n) |
| 496 | 下一个更大元素 I | 一趟单调栈把 nums2 的答案落进哈希表,再查 nums1 | O(m + n) |
| 84 | 柱状图中最大的矩形 | 两头加高度零的哨兵,弹出时左右边界一起定 | O(n) |
| 946 | 验证栈序列 | 按 pushed 逐个压,栈顶对上 popped 就弹 | O(n) |
| 394 | 字符串解码 | 数字栈配字符栈,遇到右括号展开一层 | O(输出长度) |
| 71 | 简化路径 | 按斜杠切段,普通名压栈,两点弹一段 | O(段数) |
八道题的时间复杂度都落在 O(n) 这一档上,差别只在每一格数据被访问几次。844 的两个指针一路往左走,每个字符最多被看两遍;155 的四类操作全是常数时间,代价换在空间上,每一个元素要占两份;739 与 496 的每个元素进栈一次出栈一次,平摊下来是两趟;84 的每根柱子同样是进一次出一次,但弹出时要算宽度与面积,常数比 739 大;946 的压栈与弹栈次数都等于元素个数;394 的时间跟着输出长度走而不是输入长度,一条三字符的输入可以展开成几十万个字符;71 的时间跟着斜杠切出来的段数走。
把八行横着看,第三列写的是这道题真正做的动作,而不是它的解法名字。739 与 496 都叫单调栈,前者要的是下标之差、出栈就写答案,后者要的是值、出栈时写的是另一张表;84 也叫单调栈,但它在两头加了哨兵,弹出时不需要再判空;946 的栈里存的是原始序列,跟单调与否没有关系。名字相同不代表代码可以照抄,这四道题里没有任何两份弹栈的循环长得一样,能复用的只有「不满足条件就弹」这一个骨架。
实例代码
八道题各占一个 .cpp 文件,主解法、对照写法、随机比对与计时驱动写在同一份文件里。八个程序用同一行编译命令,按 C++11 标准编译,开两组告警,十个程序编下来零告警。
text
g++ -std=c++11 -O2 -Wall -Wextra p01_backspace.cpp -o p01
编译器是 g++ 4.8.5,能支持的标准到 C++11 为止,写的时候用不了 auto 返回值推导、用不了结构化绑定、也没有 std::make_unique 这类 C++14 才有的东西,所以容器一律手写模板参数,栈一律写成 std::vector 的三行封装。两组告警全程开着,越界、漏返回、有符号与无符号混着比这些毛病都是告警先喊出来的,-Wall 与 -Wextra 一起开的时候,比较一个 int 与一个 size_t 就会提示 sign-compare。
目录里除了八道题还留了三个实验:容器尺寸与三种后端的内存开销、两个编译错误的现场、十万层嵌套下双栈与递归的对照。这三个不是新题目,是写这篇时顺带量的东西,后面几节的数据都从它们而来。
text
cpp15/
├── common.h NextRand、NextInt、NowUs 与计时用的 g_sink
├── exp01/p01_backspace.cpp 844 比较含退格的字符串
├── exp02/p02_min_stack.cpp 155 最小栈
├── exp03/p03_daily_temps.cpp 739 每日温度
├── exp04/p04_next_greater.cpp 496 下一个更大元素 I
├── exp05/p05_histogram.cpp 84 柱状图中最大的矩形
├── exp06/p06_validate_stack.cpp 946 验证栈序列
├── exp07/p07_decode_string.cpp 394 字符串解码
├── exp08/p08_simplify_path.cpp 71 简化路径
├── exp09/p09_stack_cost.cpp 容器尺寸与三种后端的内存开销
├── exp09/err_noiter.cpp err_noclear.cpp 两个编译错误
└── exp10/p10_deep_nest.cpp 十万层嵌套,双栈与递归的对照
驱动统一成一套写法,八个程序的 main 函数只换题目内容,流程一样:先跑几条写死的样例并打印,再跑边界用例,接着随机造两千组输入跟对照写法逐组比对,然后量一次耗时。随机数据用同一个线性同余发生器造,种子写死成 20261115,形式是种子乘 1103515245 再加 12345,取高位之后按题目需要映射到字符、温度或路径段,八道题的随机组数都是两千组,回显里全部是零组不一致。
对照写法按题目形状各写各的,844 的对照是先把两条串各自重建一遍再比,739 与 496 的对照是从每一格往右逐格扫,84 的对照是枚举左边界再往右扩,946 的对照是递归枚举每一条压弹路径,394 的对照是递归下降,71 的对照是把路径当一条串反复 erase 改写,155 的对照是取最小值时从头扫一遍。这些对照写法都不跟主解共用任何一步,两边跑出来的结果逐组一致,才有理由相信主解没有在某个分支上写错。
判等的方式也跟着返回值的形状走,八道题各配一个比较器。返回布尔值的两道题直接比 true 与 false,返回数组的两道题逐元素比一遍并把整条数组打印出来,返回整数的 84 比大小,返回串的 394 与 71 比长度再比内容,长度超过四百字符的那些只打印前四十个字符加省略号。这套判等写成同一个助手函数,八道题各自传进去一个比较器,回显里每一条 sample 与 edge 都是这个助手打出来的,random 那两行只打不一致的组数。
计时用 std::chrono::steady_clock,取纳秒再折算成微秒,每道题跑五轮取最小值。虚机上偶尔会被别的进程抢占,一次抢占就能把平均值拉长一截,最小值受它的影响最小。计时区间不含造数据的时间,造数据在进计时之前做完,这样比出来的数只反映解法本身的开销。编译器把某些循环整个折成一次乘法这件事碰到过两次,155 的取最小值与 946 的弹栈都是纯读操作,第一版回显打出来是 0.000 毫秒,后来加了一个 volatile long 累加器把结果兜住,才有现在这几个数。
第一题 比较含退格的字符串(844)
题目给两条字符串 s 与 t,里面除了小写字母还有退格符 #,一个退格把紧挨在它左边的那一个字符删掉,删完之后如果还能继续删就一直删。要求判断两条串处理完退格之后是否相等,例如 s 是 ab#c、t 是 ad#c,两边处理后都剩下 ac,答案是相等。
第一个坑是退格作用在左边最近的一个字符上,而不是把它所在的那一格删掉。串里出现连续两个退格时,第一个退格删掉前一个字母,第二个退格再删掉它左边剩下的那一个,ab## 与 c#d# 处理后都是空串,所以这两条判等。把退格当成「跳过下标 i 加一那一格」来写的版本,遇到连续退格只会删掉一个字符,后面补上来的又对不上,样例二就会判错。
第二个坑是退格多于字符时结果会变成空串,而空栈上再来一个退格必须原地跳过。####a 这一条里前四个退格把栈弹空了四次,第五个字符 a 才压进去,最后剩下 a;ab##### 这一条把 ab 连同后面五个退格一起弹光,剩下空串。凡是把弹栈写成栈空也照样 pop 的版本,这里就会把栈的下标拐成负数,回显里跑出来的是段错误或者一个长度巨大的串。
第三个坑在空间上,把两条串各自重建一遍的写法要用 O(n + m) 的空间,而这道题的进阶要求是 O(1)。倒着扫的写法用两个下标分别从两条串的末尾往左走,再各配一个计数器记录「已经见过但还没被消掉的退格数」。遇到字母时先看计数器是不是大于零,大于零就把这个字母也算作被删掉,计数器减一;遇到退格就把计数器加一。这样一整趟下来不需要额外的串,两个计数器与两个下标就是全部的状态。

图 2 s 是 ab#c、t 是 ad#c,逐字符压栈与退格的过程
cpp
// 文件:/home/cocatrice/cpp15/exp01/p01_backspace.cpp
static bool TwoPtr(const std::string& s, const std::string& t)
{
int i = (int)s.size() - 1;
int j = (int)t.size() - 1;
int skipS = 0;
int skipT = 0;
while (i >= 0 || j >= 0)
{
while (i >= 0)
{
if (s[(size_t)i] == '#') { ++skipS; --i; }
else if (skipS > 0) { --skipS; --i; }
else { break; }
}
while (j >= 0)
{
if (t[(size_t)j] == '#') { ++skipT; --j; }
else if (skipT > 0) { --skipT; --j; }
else { break; }
}
if (i < 0 && j < 0) { return true; }
if (i < 0 || j < 0) { return false; }
if (s[(size_t)i] != t[(size_t)j]) { return false; }
--i;
--j;
}
return true;
}
下面拿 ab#c 与 ad#c 这一对串走一遍,两边的末位都是 c。两个下标都停在各自的最后一个字符 c 上,skip 两边都是零,c 与 c 相等,各自往左退一格。s 这一边停到 # 上,skipS 变成一、下标再往左;t 那一边停到 d 上,skipT 还是零,于是 d 被 skipS 抵掉、下标继续往左。两边接着走到 b 与 a 上,b 被 skipT 抵掉,a 与 a 相等,各自再退一格,s 的下标越过零变成负一,t 的下标也越过零,循环第一次判空两边都到齐,返回 true。回显里这一条打印的是 sample 1 s=ab#c t=ad#c -> true。
a#c 与 b 那一条走的是另一条出口。s 处理完是 c,t 处理完是 b,两个下标在第一次比较时就发现字符不等,当场返回 false,回显里打印 sample 3 s=a#c t=b -> false。a##c 与 #a#c 这一对更有意思,s 的前两个字符 a 与 # 互相消掉,t 的第一个 # 先把位置空出来、再遇到 a 把它消掉,两边最后都剩下 c,回显里打印 sample 4 s=a##c t=#a#c -> true,这一条把「退格落在串首」与「退格落在字母后面」两种情形区分开了。
边界用例一共六条,回显里逐条都给了结果:退格把串删空的那条 ###/空串 是 true,两条都空是 true,退格多于字符的 ####a/a 是 true,末尾连续退格的 ab#####/空串 是 true,退格落在开头的 #ab/ab 是 true,只差一个退格的 a/a# 是 false。最后那一条是关键,它证明弹栈弹到空之后不再往负一号下标走,两边都停在空上,长度一样才判等,长度不一样直接 false。
时间是 O(n + m),两个下标各往前走一遍,最坏情况下每个字符被看两次。空间是 O(1),只有两个下标与两个计数器。实测二十万字符的两条串,双指针写法 0.658 毫秒,重建串再比的写法 1.368 毫秒,回显写的是 bench 200000 chars: two-pointer 0.658 ms | stack 1.368 ms。空间那一行写的是 two-pointer 0 byte | stack 200000 bytes,重建之后的串长各是 159780 字符。两千组随机串比对下来零组不一致,随机串里 40% 是 a、40% 是 b、20% 是退格,长度取 0 到 14 之间。
第二题 最小栈(155)
题目要求设计一个栈,在普通的 push、pop、top 之外再支持一个 getMin,四个操作都要常数时间。难点全在 getMin 上,因为弹出一个元素之后,最小值可能回到之前某一层的那个值,栈又只能从顶上看,历史里的最小值必须提前存好。
原题链接:leetcode 155. 最小栈
第一个坑是只留一个最小值变量,压栈时更新它并不费力。压栈时更新它很容易,弹出时没法回退,压了 -2、0、-3 之后最小值是 -3,弹掉 -3 之后最小值应当回到 -2,而那个 -2 早就被覆盖掉了。回显里第三条样例走的就是这个顺序,弹出之后 getMin 打出来是 -2 而不是 0,凡是只留一个变量的写法都会在这里打出一个错的值。
第二个坑是想省空间而把两条栈弄成不等高。最小值栈只在遇到更小的值时才压,弹出时又只在栈顶等于当前最小值时才弹,两个动作必须成对且条件一致,错一处就会在后面的查询里读到一条已经空掉的栈。我把两条栈写成等高之后,压栈那一行只需要一个判断,弹出那一行没有任何判断,代码短了,代价是每个元素占两份空间。

图 3 数据栈与最小值栈等高,压栈同步、弹栈同步
cpp
// 文件:/home/cocatrice/cpp15/exp02/p02_min_stack.cpp
class MinStackSync
{
public:
void push(int x)
{
data_.push_back(x);
if (mins_.empty() || x < mins_.back()) { mins_.push_back(x); }
else { mins_.push_back(mins_.back()); }
}
void pop()
{
data_.pop_back();
mins_.pop_back();
}
int top() const { return data_.back(); }
int getMin() const { return mins_.back(); }
private:
std::vector<int> data_;
std::vector<int> mins_;
};
拿样例 push(-2)、push(0)、push(-3)、getMin、pop、top、getMin 走一遍。压 -2 时最小值栈是空的,直接压进去一个 -2;压 0 时零比栈顶的 -2 大,于是把 -2 再抄一份压进去,两条栈都变成两个元素;压 -3 时负数更小,最小值栈压进 -3;getMin 读最小值栈的栈顶,得到 -3;pop 把两条栈一起弹掉一个,最小值栈的栈顶回到 -2;top 读数据栈的栈顶,得到 0;再 getMin 得到 -2。回显里这三行依次是 sample getMin -> -3、sample top -> 0、sample getMin -> -2。
边界用例里最值得看的是极值那一条,先压 INT_MAX、再压 INT_MIN、再压 0,getMin 得到 -2147483648,弹掉两个之后 getMin 回到 2147483647。这一条把「最小值用 0 或者 -1 当哨兵」的写法筛掉了,任何拿正数当初始最小值的版本都会在全是正数的栈上给出错答案。另外四条分别是单调递增压 1 到 8 之后 getMin 是一、top 是八,单调递减压 8 到 1 之后 getMin 是一,连压五个五之后 getMin 是五,压 7 弹掉再压 9 之后 getMin 是九,回显里这五条全部 ok,合计零处不一致。
时间是四个操作都是 O(1),压栈时多一次比较、弹栈时多一次 pop_back,都不随栈深变化。空间是每个元素两份 int,回显里写的是 space per elem: sync 8 bytes | scan 4 bytes。实测二十万次压栈加二十万次弹栈,同步栈 1.263 毫秒、取最小值时扫一遍的写法 0.755 毫秒,后者反而快,因为它只维护一条栈、压弹时少写一半内存;再看查询这一侧,两万个元素上连续取两万次最小值,同步栈 0.040 毫秒、扫一遍 241.899 毫秒,回显写的是 bench 20000 getMin on 20000 elems: sync 0.040 ms | scan 241.899 ms。查询这一侧差了六千倍,同步栈换回来的正是这一侧的时间。
两千组随机操作比对下来零处不一致,每一组随机做一到六十步,压栈占 55%、弹栈占 20%、查询占 25%,栈空时强制压栈。回显里写的是 random 2000 groups / 61374 ops: 0 mismatch,六万多次操作里两种写法给出的 top 与 getMin 完全一样。
第三题 每日温度(739)
题目给一个温度数组,要求对每一天算出还要等几天才会出现更高的温度,等不到就写 0。例如 73 74 75 71 69 72 76 73 对应的答案是 1 1 4 2 1 1 0 0,第一天 73 隔一天就等到 74,第三天 75 要等到第六天的 76,最后两天后面再也没有更高的温度。
原题链接:leetcode 739. 每日温度
第一个坑是拿温度本身当栈里存的东西,而不是把当天的下标存进去。答案是相隔的天数,必须在出栈那一刻用当前下标减去被弹出那一天的下标,所以栈里存的应当是天数下标,温度从下标反查。存温度的写法在出栈时只剩一个数值,除非再额外存一份下标,否则算不出距离。
第二个坑落在比较的等号方向上,差一个符号结论就全反。题面要求严格更高的温度,50 与 50 之间不算更高,所以弹栈的条件要写成当前温度大于栈顶那天的温度。把大于等于写进去,50 50 50 50 这条用例会给出 1 1 1 0,正确答案是 0 0 0 0,回显里第四条边界用例正是这一条。
第三个坑是循环结束时栈里还剩下的那些天。没有等到更高温度的日子答案必须是 0,而答案数组初始化成 0 之后就不用再管它们了,只要不把残留的下标写成别的值。有些写法在收尾时把栈里剩下的下标都填成数组长度减下标,那样最后一天会得到 0 而不是它该有的 0,前几天的值又会偏大。

图 4 单调栈里存下标,遇到更高的温度就把栈顶那些天一次结清
cpp
// 文件:/home/cocatrice/cpp15/exp03/p03_daily_temps.cpp
static std::vector<int> DailyTemperatures(const std::vector<int>& T)
{
std::vector<int> ans(T.size(), 0);
std::vector<int> st;
for (size_t i = 0; i < T.size(); ++i)
{
while (!st.empty() && T[i] > T[(size_t)st.back()])
{
size_t j = (size_t)st.back();
st.pop_back();
ans[j] = (int)(i - j);
}
st.push_back((int)i);
}
return ans;
}
下面拿上面那八个温度走一遍,逐天看栈里压着哪些下标。第一天 73 压进栈,栈里是 0;第二天 74 比 73 高,下标 0 被弹出、答案是 1 减 0 等于 1,74 再压进去;第三天 75 比 74 高,下标 1 被弹出、答案是 1,75 压进去;第四天 71 比 75 低,直接压进去;第五天 69 同样压进去;第六天 72 比栈顶的 69 高,弹掉下标 4 得到答案 1,接着比栈顶的 71,72 仍然更高,弹掉下标 3 得到答案 3,再比栈顶的 75,72 比不过,停止;第七天 76 把栈里剩下的 75 与 72 一起弹掉,下标 2 得到答案 4、下标 5 得到答案 1;第八天 73 压进去,扫完。回显里这一条打印的是 sample temps 1 1 4 2 1 1 0 0。
边界用例五条:空数组返回空数组,回显里是 edge 空数组 \[\];单元素 55 返回 0;严格递减的 90 80 70 60 50 返回五个零,因为后面的温度一天比一天低,栈会一直长到五;全相等的 50 50 50 50 也返回四个零,这一条把等号的方向钉住;严格递增的 30 40 50 60 返回 1 1 1 0,最后一天留在栈里没有弹出去。这五条用例与暴力写法逐条比对,合计零处不一致。
时间是 O(n),每一天进栈一次、出栈一次,弹栈的总次数不超过 n,所以内层那个 while 平摊下来是常数。空间是 O(n),栈最深的时候正好装下整个数组的下标。实测二十万个温度、值域 1 到 100,单调栈 2.507 毫秒、逐格往右扫的暴力写法 63.777 毫秒,回显写的是 bench 200000 temps (值域 100): stack 2.507 ms | brute 63.777 ms。换成严格递减的两万个温度,单调栈 0.064 毫秒、暴力 59.940 毫秒,倍数拉到九百多倍,因为递减序列里每一格都要往右扫到数组末尾才放弃。两千组随机温度、合计四万多个元素比对下来零组不一致。
第四题 下一个更大元素 I(496)
题目给两个数组,nums1 是 nums2 的子集,要求对 nums1 里的每一个值,找出它在 nums2 里右边第一个比它大的值,找不到就写 -1。例如 nums1 是 4 1 2、nums2 是 1 3 4 2,答案是 -1 3 -1,4 在 nums2 里右边只有 2,比它小,1 的右边第一个更大的是 3,2 的右边没有更大的值。
第一个坑是拿 nums1 的每个值去 nums2 里线性找位置。找到位置之后再往右扫一遍,规模一大就是三层循环,回显里二十万规模的暴力写法跑到 197.664 毫秒,主解只要 16.352 毫秒。题目把 nums2 的长度给到一千以内,看着能过,但把这道题当模板去做更大规模的题时就会卡住。
第二个坑是没有利用「nums2 里每个值都不一样」这个条件。值唯一意味着可以把值与它右边第一个更大的值做成一张表,nums1 查表就行,一趟扫描能把 nums2 里所有元素的答案全部算完。表用 std::unordered_map 或者一个足够大的数组都能实现,用数组的话键就是值本身,值域一大就得先做离散化。
第三个坑落在表里没有的那些键上,它们要返回负一。nums2 里最大的那个值没有右边更大的元素,它压根不会进表,nums1 里有它时查表要落到 -1 分支上。把查表写成 mpx 的版本会把一个默认值零插进表里,答案就变成一个 0 而不是 -1,回显里 sample 1 的第一个答案正是 -1。

图 5 nums2 走一趟单调栈,答案跟着落进哈希表,再拿 nums1 去查
cpp
// 文件:/home/cocatrice/cpp15/exp04/p04_next_greater.cpp
static std::vector<int> NextGreater(const std::vector<int>& nums1, const std::vector<int>& nums2)
{
std::unordered_map<int, int> mp;
std::vector<int> st;
for (size_t i = 0; i < nums2.size(); ++i)
{
while (!st.empty() && nums2[i] > st.back())
{
mp[st.back()] = nums2[i];
st.pop_back();
}
st.push_back(nums2[i]);
}
std::vector<int> ans;
ans.reserve(nums1.size());
for (size_t i = 0; i < nums1.size(); ++i)
{
std::unordered_map<int, int>::iterator it = mp.find(nums1[i]);
ans.push_back(it == mp.end() ? -1 : it->second);
}
return ans;
}
拿 nums2 的 1 3 4 2 走一遍。1 压进栈;3 比栈顶的 1 大,把 1 弹出并在表里记一笔 1 对应的答案 3,3 再压进去;4 比 3 大,弹出 3、表里记 3 对应 4,4 压进去;2 比 4 小,压进去。扫完之后栈里剩下 4 与 2,这两个值在 nums2 里右边都没有更大的元素,表里不会有它们的键。接着拿 nums1 的 4 1 2 去查,4 查不到落到 -1,1 查到 3,2 查不到落到 -1,答案是 -1 3 -1,回显里打印 sample 1 -1 3 -1。
第二条样例 nums1 是 2 4、nums2 是 1 2 3 4,答案是 3 -1。这一条里 2 的右边第一个更大的是 3 而不是 4,因为 3 更靠左,回显里打印 sample 2 3 -1。边界用例五条:nums1 为空返回空数组;nums2 只有一个元素时答案是 -1;递减的 3 2 1 三项全部 -1;递增的 1 2 3 答案是 2 3 -1;nums1 与 nums2 完全相同时,1 2 对 1 2 的答案是 2 -1。这五条与暴力写法逐条比对,合计零处不一致。
时间是 O(m + n),nums2 的每个值进栈一次出栈一次,nums1 的每个值查表一次,哈希表的单次查找平摊下来是常数。空间是 O(n),栈最多长到 n,表最多 n 项。实测 nums2 二十万、nums1 两万,单调栈加哈希表 16.352 毫秒,暴力 197.664 毫秒,回显写的是 bench nums2=200000 nums1=20000: map 16.352 ms | brute 197.664 ms。两千组随机排列比对下来零组不一致,每一组先造一个 1 到 12 的随机排列当 nums2,再随机挑一半元素当 nums1。
第五题 柱状图中最大的矩形(84)
题目给一排宽度为一的柱子,高度写在数组里,要求找出这些柱子能拼成的最大矩形面积。例如 2 1 5 6 2 3 的答案是 10,它由中间两根高度为 5 与 6 的柱子拼出一个宽二高五的矩形,比单独取那根高六的柱子还要大。
第一个坑是枚举左右边界,两端一确定就得重算一次区间最小值。任取一段区间,这段区间能拼出的矩形高度等于区间里的最小高度,所以面积是区间最小高度乘区间长度,枚举两端要 O(n^2) 段。回显里两万根柱子上暴力写法跑了 169.667 毫秒,主解 0.273 毫秒,规模再翻十倍时暴力那一侧已经不是能等待的量级。
第二个坑落在弹出时宽度怎么算这件事上,公式里的减一不能省。栈里按高度递增压着下标,一旦遇到比栈顶矮的柱子,栈顶那根柱子的右边界就是当前下标,左边界是它下面那个还没弹出的下标。宽度等于当前下标减去新栈顶下标再减一,因为新栈顶那根柱子本身比它矮,不能算进这段区间。栈里只剩一个元素时新栈顶不存在,宽度直接等于当前下标,这个分支正是加哨兵要消掉的东西。
第三个坑在收尾那一步,扫完之后栈里还压着一批没定右边界的柱子。扫描结束时栈里还压着一批没有遇到右边界的柱子,它们的右边界要按数组末尾算,写起来要么在循环外面再跑一段弹栈,要么在数组末尾补一根高度为零的柱子。两头都补之后,弹出时的宽度公式统一成当前下标减新栈顶下标再减一,左边界那一侧也能保证栈里永远至少有一根柱子,代码里一处判空的 if 都不需要。

图 6 heights 是 2 1 5 6 2 3,弹出时左右边界一起定,最大面积 10
cpp
// 文件:/home/cocatrice/cpp15/exp05/p05_histogram.cpp
static int LargestRectangleArea(const std::vector<int>& heights)
{
std::vector<int> h;
h.reserve(heights.size() + 2);
h.push_back(0);
for (size_t i = 0; i < heights.size(); ++i) { h.push_back(heights[i]); }
h.push_back(0);
int best = 0;
std::vector<int> st;
st.reserve(h.size());
for (size_t i = 0; i < h.size(); ++i)
{
while (!st.empty() && h[(size_t)st.back()] > h[i])
{
int top = st.back();
st.pop_back();
int left = st.back();
int area = h[(size_t)top] * (int)(i - (size_t)left - 1);
if (area > best) { best = area; }
}
st.push_back((int)i);
}
return best;
}
拿 2 1 5 6 2 3 走一遍,补完哨兵之后数组是 0 2 1 5 6 2 3 0。下标 0 的零压进栈;下标 1 的高度二比零高,压进去;下标 2 的高度一比栈顶的二矮,弹出下标 1,左边界是栈顶的下标 0,宽度等于 2 减 0 再减 1 等于 1,面积是二乘一等于二;再比栈顶的零,一比零高,停止,下标 2 压进去;下标 3 与 4 依次压进去,栈里是 0 2 3 4,高度递增;下标 5 的高度二比栈顶的六矮,弹出下标 4,左边界是下标 3,宽度 5 减 3 再减 1 等于 1,面积六;再比栈顶的五,二仍然矮,弹出下标 3,左边界是下标 2,宽度 5 减 2 再减 1 等于 2,面积是五乘二等于十,回显里这一条打印 sample heights 10。
继续往下走,下标 5 压进去,下标 6 的高度三比二高,压进去;下标 7 的哨兵零把栈里剩下的全部弹空,下标 6 那根宽度一面积三,下标 5 那根左边界是下标 2、宽度 7 减 2 再减 1 等于 4、面积八,下标 2 那根左边界是下标 0、宽度 7 减 0 再减 1 等于 6、面积六。最大值停在十,与手算的那一遍完全一致。
边界用例七条:空数组返回零,因为两根哨兵互相比不出来;只有一根高度五的柱子返回五;高度为零返回零;3 3 3 返回九,三根一样的柱子拼出一条宽三高四的矩形;递增的 1 2 3 4 5 返回九,它来自高度一横跨五根;递减的 5 4 3 2 1 也返回九;两端为零的 0 9 9 0 返回十八。这七条与对照写法逐条比对,合计零处不一致。
时间是 O(n),每根柱子进栈一次出栈一次,弹出时算面积是常数时间。空间是 O(n),栈最多装下全部下标,加上两根哨兵。实测两万根柱子、值域一千,哨兵栈 0.273 毫秒、枚举区间的暴力写法 169.667 毫秒,回显写的是 bench 20000 bars: sentinel-stack 0.273 ms | brute 169.667 ms。二十万根柱子的主解单独跑 2.660 毫秒,答案是 582134,回显写的是 bench 200000 bars 主解单独: 2.660 ms (answer=582134)。两千组随机高度、合计六万多根柱子比对下来零组不一致。
第六题 验证栈序列(946)
题目给两个数组,pushed 是入栈顺序,popped 是出栈顺序,两个数组里的值互不相同,要求判断 popped 能不能由 pushed 经过若干次压栈与弹栈得到。例如 pushed 是 1 到 5、popped 是 4 5 3 2 1,答案是成立的;popped 换成 4 3 5 1 2 就不成立,因为弹出 5 之后栈里只剩 1 与 2,1 压在上面,不可能先弹 1 再弹 2。
原题链接:leetcode 946. 验证栈序列
第一个坑是想从两个序列直接推出结论,比如先算逆序对、或者看某一段是不是区间。出栈序列的合法性与栈深、与每段弹出的时机都有关系,光看两个序列的排列形状推不出来,只有照着压弹的过程走一遍才能确定。
第二个坑是弹栈的时机,压完一个要连着弹到弹不动为止。压栈之后要一直弹到弹不动为止,而不是每压一个只弹一次。子序列 2 1 4 3 里,压 1 压 2 之后要连着弹两次才轮到 2 与 1 出栈,写成每轮只弹一次的版本会漏掉一次弹出,后面全错。
第三个坑落在循环结束之后的判断上,判据是弹出指针走完整条序列。压栈序列扫完之后栈里可能还剩着元素,只要 popped 还没走完就说明这条序列不合法,判断条件要写成弹出的指针走完了整条 popped。写成栈空了返回 true 的版本,遇到 1 2 对 1 2 这种输入会在第一个元素弹出后立刻返回 true,后面的 2 根本没被检查过。

图 7 按 pushed 逐个压入,栈顶等于待弹出值就弹,最后返回 true
cpp
// 文件:/home/cocatrice/cpp15/exp06/p06_validate_stack.cpp
static bool ValidateVector(const std::vector<int>& pushed, const std::vector<int>& popped)
{
if (pushed.size() != popped.size()) { return false; }
std::vector<int> st;
st.reserve(pushed.size());
size_t k = 0;
for (size_t i = 0; i < pushed.size(); ++i)
{
st.push_back(pushed[i]);
while (!st.empty() && k < popped.size() && st.back() == popped[k])
{
st.pop_back();
++k;
}
}
return k == popped.size();
}
拿 pushed 的 1 到 5 与 popped 的 4 5 3 2 1 走一遍。压 1,栈顶是 1 而待弹出的是 4,不弹;压 2 压 3 同理;压 4 时栈顶对上待弹出的 4,弹掉,k 往后指到 5;下一轮压 5,栈顶的 5 又对上 k,弹掉,k 指到 3;此时栈里是 1 2 3,栈顶的 3 对上 k,弹掉,接着 2 与 1 依次对上,k 一路走到序列末尾。循环结束时 k 等于 popped 的长度,返回 true,回显里这一条打印 sample pushed 1...5 popped 4,5,3,2,1 -> true。
换成 4 3 5 1 2 这一条,前面几步一样,压到 4 弹 4,压 5 弹 5,接着弹 3,栈里剩下 1 与 2,k 指向 1。压栈序列已经用完,栈顶是 2 而待弹出的是 1,弹不动,循环结束,k 停在第 4 个位置上,返回 false,回显里打印 sample pushed 1...5 popped 4,3,5,1,2 -> false。两条样例的差别只在最后两次弹出谁先谁后,答案是 false 的那条恰好是这道题最容易被漏掉的分支。
边界用例六条:两条都空返回 true;单元素 1 对 1 返回 true;长度不等的 1 2 3 对 1 2 返回 false;全相同值的 7 7 7 对 7 7 7 返回 true;顺序进顺序出的 1 2 3 4 返回 true;两两成对的 2 1 4 3 返回 true。六条合计零处不一致,其中长度不等那一条走的是入口的短路,连循环都没进。
力扣上还有一道 LCR 148 验证图书取出顺序,题面从数字序列换成了书架取书,进出的先后关系与这道题一模一样,同一份代码连数组都不用改就能交上去。这一类题的模型只有一处:给定进与出的两条顺序,判断中途那条栈能不能摆出这种先后;换成括号匹配、换成列车调度、换成函数调用返回的顺序,判据都落在同一处比较上。
时间是 O(n),每个元素进栈一次出栈一次。空间是 O(n),最坏情况下 pushed 全部压进去才开始弹,栈长到 n。实测二十万结点、出栈序列取完全逆序,vector 当栈 0.793 毫秒、std::list 当栈 6.486 毫秒,回显写的是 bench 200000 nodes: vector-stack 0.793 ms | list-stack 6.486 ms,差出来的八倍全在结点分配与指针跳转上。两千组随机排列比对下来零组不一致,每一组同时跑 vector 版、list 版与递归枚举版三份实现,三份的答案两两相同,回显写的是 random 2000 groups: 0 mismatch (vector / list / brute 三方)。
第七题 字符串解码(394)
题目给一条编码过的字符串,形如数字加方括号包住一段内容,表示把这段内容重复那么多次,方括号可以嵌套,数字可以是多位数,括号外面还可以混着普通字符。要求把这条串展开,例如 3a2bc 展开成 aaabcbc,3a2\[c] 展开成 accaccacc。
原题链接:leetcode 394. 字符串解码
第一个坑是数字可能不止一位,读到的每一位都要累进同一个倍数里。读到 3 与读到 12 要走同一条路径,数字必须逐位累加,写成「读到一位数字就当成倍数」的版本在 10a 上会展开成十个 a 后面再跟一个 a。
第二个坑是括号里的内容要跟着倍数走,而括号外面的前缀不能重算。3a2\[c] 这一条里内层的 2c 展开成 cc,外层的 3 要把它拼成 acc 再重复三次,如果每次展开都从空串开始拼,外层就会把前面已经拼好的 a 丢掉。做法是遇到左括号时把「当前这一层已经拼好的前缀」与「这一层的倍数」一起压进栈,遇到右括号时把栈顶的前缀取回来,接上当前层展开的内容。
第三个坑是右括号到来时两条栈的取用顺序,取反了会把倍数与前缀拼错。弹栈时要先取倍数再取前缀,两条栈的弹出顺序必须一致,压的时候是数字栈在前、字符栈在后,弹的时候就得反过来先取数字再取字符。两条栈如果一条压在前一条压在后而弹出时弄反了,展开的倍数会拿成上一次循环残留的值,回显里那条深层嵌套的输入会展开成完全不同的长度。

图 8 数字栈与字符栈成对,遇到右括号就展开一层再拼回前缀
cpp
// 文件:/home/cocatrice/cpp15/exp07/p07_decode_string.cpp
static std::string DecodeTwoStack(const std::string& s)
{
std::vector<int> numSt;
std::vector<std::string> strSt;
std::string cur;
int num = 0;
for (size_t i = 0; i < s.size(); ++i)
{
char c = s[i];
if (c >= '0' && c <= '9') { num = num * 10 + (c - '0'); }
else if (c == '[')
{
numSt.push_back(num);
strSt.push_back(cur);
num = 0;
cur.clear();
}
else if (c == ']')
{
int k = numSt.back();
numSt.pop_back();
std::string prev = strSt.back();
strSt.pop_back();
for (int t = 0; t < k; ++t) { prev += cur; }
cur.swap(prev);
}
else { cur += c; }
}
return cur;
}
下面拿 3a2\[c] 这一条走一遍,它是两层嵌套里最短的一例。读到 3,num 变成三;读到左括号,把三压进数字栈、把空前缀压进字符栈,num 归零、cur 清空;读到 a,cur 变成 a;读到 2,num 变成二;再读到左括号,把二与 a 分别压进两条栈,num 归零、cur 清空;读到 c,cur 变成 c;读到右括号,弹出倍数二与前缀 a,把 c 重复两次得到 cc,接在 a 后面得到 acc;再读到右括号,弹出倍数三与空前缀,把 acc 重复三次得到 accaccacc。回显里这一条打印 sample 3a2\[c] in=3a2\[c] out len=9 out=accaccacc。
三条样例分别覆盖了不同的形状,2abc3cdef 展开成 abcabccdcdcdef,因为 ef 在两层括号外面,它不参与任何重复;abc3cdxyz 展开成 abccdcdcdxyz,前缀 abc 与后缀 xyz 原样保留,中间那段重复三次。两条都是 14 与 12 个字符,回显里逐条给了长度与内容。边界用例六条:没有括号的 abc 原样返回;单个字母 a 返回 a;两位数 10a 返回十个 a;深层嵌套 22\[2\[2\[a]]] 返回十六个 a;三位数 100ab 返回两百个字符;括号里套字母的 2y3\[abx] 返回 yabababxyabababx 共十六个字符。这六条与递归写法逐条比对,合计零处不一致。
时间是 O(输出长度),每个字符被拼进结果一次,展开的倍数越大总时间越长,一条三字符的输入可以展开出几十万个字符,所以复杂度按输出长度算而不按输入长度算。空间是 O(输出长度 + 嵌套层数),两条栈各存一份每一层的前缀与倍数。实测展开后十九万九千多字符的那条输入,双栈 0.179 毫秒、递归下降 0.137 毫秒,回显写的是 bench 输出 199998 字符: two-stack 0.179 ms | recursion 0.137 ms;嵌套两千层的那条输入,双栈 0.077 毫秒、递归 0.084 毫秒,回显写的是 bench 嵌套 2000 层: two-stack 0.077 ms | recursion 0.084 ms。两千组随机编码串、合计四万多字符输入与十四万字符输出比对下来零组不一致。
第八题 简化路径(71)
题目给一条 Unix 风格的绝对路径,要求把它简化成规范形式:连续的斜杠合成一个,一个点表示当前目录可以删掉,两个点表示回到上一级目录,遇到根之上就不再往上走,最后的结果必须以斜杠开头并且不以斜杠结尾。例如 /a/./b/.../.../c/ 简化成 /c。
原题链接:leetcode 71. 简化路径
第一个坑是把路径当成一条串反复改写,每改一处都要搬一次尾巴。每删掉一处 /./ 或 /.../ 都要用 erase 搬一次尾巴,删的处数一多就是 O(n^2)。回显里一万字符的路径用 stack 是 0.218 毫秒,用反复 erase 的写法是 14.854 毫秒,倍数接近七十倍,规模再大一档差距会更明显。
第二个坑是四类段各自的处理,空段与一个点跳过、两点弹栈、其余压栈。空段来自连续的斜杠,直接跳过;一个点的段跳过;两个点的段弹掉栈顶的一个目录名,栈空时原地不动;其余段都是普通名字,压进栈。四个分支的顺序不能颠倒,先把两个点判成普通名字会让 /.../ 被当成一个名叫两点的目录留下来。
第三个坑落在返回值上,栈空时要给出根路径而不是一条空串。栈空时结果是根路径一个斜杠,而不是空串;栈非空时每个目录名前面补一个斜杠拼起来,末尾不能再补。回显里 /.../ 这一条走的就是栈空的分支,返回根路径;//// 这一条里四段全是空段,同样返回根路径。

图 9 按斜杠切段,普通名压栈,两点弹一段,空段与一个点跳过
cpp
// 文件:/home/cocatrice/cpp15/exp08/p08_simplify_path.cpp
static std::string SimplifyPath(const std::string& path)
{
std::vector<std::string> st;
size_t i = 0;
while (i < path.size())
{
while (i < path.size() && path[i] == '/') { ++i; }
size_t j = i;
while (j < path.size() && path[j] != '/') { ++j; }
std::string seg = path.substr(i, j - i);
i = j;
if (seg.empty() || seg == ".") { continue; }
if (seg == "..") { if (!st.empty()) { st.pop_back(); } }
else { st.push_back(seg); }
}
if (st.empty()) { return "/"; }
std::string out;
for (size_t k = 0; k < st.size(); ++k)
{
out += "/";
out += st[k];
}
return out;
}
拿 /a/./b/.../.../c/ 走一遍。先跳过开头的斜杠,切出段 a,a 是普通名字,压进栈;跳过两个斜杠之间的空段,切出一个点,跳过;切出 b,压进栈,栈里是 a b;切出两个点,弹掉栈顶的 b,栈里是 a;再切出两个点,弹掉 a,栈变空;切出 c,压进栈。最后栈里只剩 c,拼成 /c,回显里这一条打印 sample 4 in=/a/./b/.../.../c/ out=/c。
五条样例覆盖的形状依次是:末尾带斜杠的 /home/ 简化成 /home;上跳到根的 /.../ 简化成根路径;中间有连续斜杠的 /home//foo/ 简化成 /home/foo;先上跳再上跳的 /a/./b/.../.../c/ 简化成 /c;混着连续斜杠与点的 /a/.../.../b/.../c//.// 简化成 /c。边界用例七条:根路径一个斜杠返回一个斜杠;四个斜杠返回一个斜杠;三个点的 /... 返回 /...,它是一段普通名字;上跳出根的 /a/... 返回根路径;上跳多于层数的 /a/b/c/.../.../... 返回根路径;只有点的 /. 返回根路径;空串返回根路径。这七条与对照写法逐条比对,合计零处不一致。
时间是 O(段数),每一段被切出来一次,普通名字压栈、两点弹栈都是常数时间,拼接的时候每个目录名被读一遍。空间是 O(段数),栈里最多装下全部目录名。实测一万字符的路径,栈写法 0.218 毫秒、反复 erase 的写法 14.854 毫秒,回显写的是 bench 10000 字符: stack 0.218 ms | erase 14.854 ms;二十万字符的路径主解单独跑 4.331 毫秒,输出五万一千多个字符,回显写的是 bench 200000 字符 主解单独: 4.331 ms (out=51010 字符)。两千组随机路径比对下来零组不一致,每一组随机造一到十段,段名在字母、一个点、两个点、三个点之间随机取,斜杠随机一到两个。
这 8 道题的实测耗时
八道题的量法完全一致,同一台两核虚机、同一个编译器、同一组编译参数,每道题跑五轮取最小值,计时区间不含造数据,也在计时之前就把容器 reserve 到位。下面这张表里第一列是题号与题目,第二列是这道题取到的规模,第三列是主解法的耗时,第四列是这道题配的对照写法在同一份输入上的耗时。
| 题目 | 数据规模 | 耗时 | 对照写法 |
|---|---|---|---|
| 844 比较含退格的字符串 | 二十万字符 | 0.658 毫秒 | 重建串再比 1.368 毫秒 |
| 155 最小栈 | 二十万次压栈加弹栈 | 1.263 毫秒 | 取最小值扫一遍 0.755 毫秒 |
| 739 每日温度 | 二十万温度 | 2.507 毫秒 | 逐格往右扫 63.777 毫秒 |
| 496 下一个更大元素 I | nums2 二十万、nums1 两万 | 16.352 毫秒 | 逐格往右扫 197.664 毫秒 |
| 84 柱状图中最大的矩形 | 两万根柱子 | 0.273 毫秒 | 枚举区间 169.667 毫秒 |
| 946 验证栈序列 | 二十万结点 | 0.793 毫秒 | list 后端 6.486 毫秒 |
| 394 字符串解码 | 输出二十万字符 | 0.179 毫秒 | 递归下降 0.137 毫秒 |
| 71 简化路径 | 一万字符 | 0.218 毫秒 | 反复 erase 14.854 毫秒 |
八行里有六行是主解法更快,两行反过来。155 那一行最容易被误读,同步栈在压栈与弹栈上都要多写一份最小值,二十万次压弹比只维护一条栈慢了一半;把查询这一侧的实测搬过来看就是另一个结论,两万个元素上连续取两万次最小值,同步栈 0.040 毫秒、扫一遍 241.899 毫秒,查询次数一多,压弹上多花的零点五毫秒根本不值一提。394 那一行是两种写法几乎平手,递归下降每层只是一次函数调用与一次字符串拼接,跟双栈的一次压栈加一次弹栈开销相当,规模上到十万层时递归那一边直接段错误退出,双栈那一边照常出结果。
差距最大的几行都落在复杂度上而不是常数上。84 的两万根柱子,哨兵栈 0.273 毫秒、枚举区间 169.667 毫秒,差六百多倍,因为枚举那一边是平方级;739 的二十万温度差二十五倍,496 的二十万规模差十二倍,71 的一万字符差六十八倍,这三行的对照都退化成平方级,规模翻一倍时间翻四倍,主解翻一倍只翻一倍。真正落到常数层面的对比只有 844 与 946 两行,前者差两倍出头,后者差八倍,差的都是每个元素上多出来的那一次内存分配。
八道题的数据规模并不一样,第三列不能横着比。84 只取了两万根柱子,它的主解在二十万根上单独跑是 2.660 毫秒,比表里这一格大一个数量级;394 的规模写的是输出长度而不是输入长度,同样一条输入换成 1 替代 9 当倍数,输出就短四十倍;71 的一万字符里有相当一部分是空段与点段,真正压进栈的目录名不到十分之一。表里这八个数只能在同一行内部左右比对,跨行比出来的快慢没有意义。
这两行的差法也说明了常数项的量级,与复杂度那一侧差着一个台阶。844 的两种实现都只扫一遍,差出来的两倍来自重建那一边多开了两个二十万字符的串;946 的两种实现算法完全一样,差的八倍全部来自 list 每压一个结点的一次分配与一次释放。把这两个数放在 739 与 84 的几十倍、几百倍旁边看,常数项的量级在个位数倍,复杂度差的量级在两位数到三位数倍,判断一段代码慢在哪一侧时,这个比值比绝对耗时好用。
测量的环境是一台两核 1837 MB 的 CentOS 7 虚机,内核 3.10,编译器 g++ 4.8.5,优化开到 -O2,计时用的是 std::chrono::steady_clock,分辨率到纳秒。每道题跑五轮取最小值而不是平均值,虚机上偶尔会被别的进程抢占,一次抢占就能把平均值拉长一截,最小值受它的影响最小。二十万这一档的单轮耗时都在毫秒级,五轮加起来几十毫秒,八个程序全跑一遍不到一秒,任何一个数对不上都可以当场再量一次,回显里每个数都跟着一行打印结果。

图 10 八道题的主解与对照解法耗时
踩坑点
-
std::stack 既不提供迭代器也不提供 clear,两个错误各写了一份最小复现:编译 err_noiter.cpp 报 error: 'iterator' is not a member of 'std::stack',编译 err_noclear.cpp 报 error: 'class std::stack' has no member named 'clear';要清空只能写成循环 pop,或者直接把底层容器换掉。
-
sizeof(std::stack) 是 80 字节,与 sizeof(std::deque) 一模一样,因为 stack 本身不存数据,它只是一个套在 deque 外面的适配器;换成 stack<int, std::vector > 是 24 字节,换成 list 后端是 16 字节,尺寸完全跟着底层容器走。
-
五百万个 int 压在默认的 deque 后端上占 20684 KB、每元素 4.24 字节,换 vector 后端占 19728 KB、每元素 4.04 字节,换 list 后端占 156300 KB、每元素 32.01 字节;压栈耗时依次是 17.115、31.961、126.857 毫秒,list 每压一个元素就要一次结点分配,代价是另外两个后端的四倍到七倍。
-
纯读的循环会被编译器整个折掉,155 的 getMin 第一版计时打出来是 0.000 毫秒,因为循环里的返回值没人用,编译器把它删干净了;加一个 volatile long 累加器把每次结果兜住之后才有 0.040 毫秒这个数,946 的弹栈计时也踩过同一个坑。
-
844 弹到空栈之后还可能再来退格,这一次必须原地跳过而不是继续往下弹,把 pop 写成不判空的版本会让下标拐成负数,跑起来要么读到一段垃圾内存,要么直接段错误。
-
739 的比较符号差一个等号结论就全反,50 50 50 50 这条输入在严格大于下答案是四个零,在大于等于下答案是 1 1 1 0,回显里那条 edge 用例专门用来钉住这个等号。
-
496 查表不能用 mpx,下标运算符在键不存在时会顺便插一个默认值零进去,答案于是变成 0 而题目要的是负一;用 find 拿到迭代器再判 end,才能把没有答案的那些值落到负一分支上。
-
84 的宽度公式是当前下标减去新栈顶下标再减一,那个减一不能省,因为新栈顶那根柱子比被弹出的矮,它自己不在这段区间里;面积用 int 承接时高度乘宽度会溢出,题面允许的高度是十万、宽度也是十万,乘积一亿刚好放得下,值域再大就得换 long long。
-
946 的收尾判据是弹出指针走完整条 popped,不是栈空了就算成功;写成栈空返回 true 的版本,1 2 对 1 2 会在弹出第一个元素后提前返回,后面那个 2 根本没被检查过。
-
394 的递归写法在十万层嵌套上直接段错误,回显里那一行是 Segmentation fault 与退出码 139,输入只有三十万字符却把默认八兆的调用栈撑爆了;双栈写法把层次放在堆上,同样的输入 4.684 毫秒出结果。
-
71 把路径当串反复 erase 的写法在一万字符上是 14.854 毫秒,按段切段压栈的写法是 0.218 毫秒,差出来的时间全在每次删完一处之后搬尾巴上,规模再大一档会差到几十倍。
-
随机数据造不出空输入、单元素、全相同这三类形状,两千组随机里出现长度为零的概率接近零,所以边界用例必须照着形状逐条写死;回显里以 edge 开头的行与以 random 开头的行是分开放的,前者管极端形状,后者管一般形状。
-
计时别用 clock() 与 time(),前者量的是 CPU 时间,把等待与调度都排除在外,后者分辨率只有一秒;steady_clock 拿的是单调时钟,五轮取最小之后,虚机上的抖动才不会把结论带偏。
-
三个实验的位置要记住:容器尺寸与三种后端的内存开销在 exp09/p09_stack_cost.cpp,两个编译错误在 exp09 目录下的 err_noiter.cpp 与 err_noclear.cpp,十万层嵌套的对照在 exp10/p10_deep_nest.cpp,正文里那几个数都是从这三个程序回显里抄下来的。
-
每一题的计时都跑在同一个进程里,主解与对照交替跑五轮,顺序固定成先主解后对照,避免缓存冷热把先跑的那一侧拉长;如果把两个实现分开跑在不同进程里,二十万规模下的差距会有一部分来自页表与缓存状态,而不是算法本身。
-
造随机数据的线性同余发生器只取 15 位,NextRand 的返回值最大 32767,所以 NextInt(1, 1000000000) 这种写法实际给出的是 1 到 32768 之间的值;84 那道题的二十万根柱子在这种值域下最大面积是 582134,换一个取满 30 位的发生器,面积就要溢出 int。

图 11 八道题的复杂度与易错点汇总
本篇总结(模拟面试问题)
问:什么样的题目适合把单调栈搬出来?
核心要点:判据是「每一个元素都在等它右边第一个满足某个条件的元素」,而且这个条件可以用大小关系表述。739 的每一天在等一个比它更暖的日子,496 的每一个值在等右边第一个比它大的值,84 的每一根柱子在等左右两边第一根比它矮的柱子,三者的共同点是一旦后面的元素比栈顶好,栈顶那个元素此后再也不会被后来的元素超过,可以直接弹掉结算。写代码之前先把「栈里存什么、什么时候弹、弹出时算出来什么」这三件事写清楚,剩下的就是五行循环。
问:84 两头加高度零的哨兵,究竟消掉了哪两处特判?
核心要点:消掉的是左边界与右边界各一处。没有左边哨兵时,弹出的柱子下面可能已经没有元素了,宽度要单独写成当前下标;加了左边那根零之后,零永远不会被弹出,栈里永远至少有一个元素,宽度公式统一成当前下标减去新栈顶下标再减一。没有右边哨兵时,扫描结束之后栈里还压着一批柱子,得在循环外面再补一段弹栈;加了右边那根零之后,最后一轮会把所有柱子全部弹干净,循环体里一处收尾代码都不需要。两处特判换成两根高度为零的柱子,代价是数组要多两个位置。
问:155 为什么要把最小值栈做成等高,能不能只留一个最小值变量?
核心要点:只留一个变量在弹出时没法回退。压了负二、零、负三之后最小值是负三,弹掉负三之后最小值应当回到负二,而负二早被覆盖掉了。等高的最小值栈把每一层的最小值都存了一份,弹出时两条栈一起弹,栈顶自然回到上一层的最小值。代价是每个元素占两份空间,实测每元素八字节对四字节;想省空间也可以让最小值栈只在遇到更小的值时压,代价是弹出时多一个「栈顶是否等于当前最小值」的判断,两条栈从此不再等高,判空与判等的条件必须成对写对。
问:394 的双栈与递归各付什么代价,十万层嵌套为什么递归会崩?
核心要点:双栈的代价是两条容器加上每一层的一份前缀拷贝,好处是层次全部落在堆上,深度只受内存限制;递归的代价是每一层占一格函数栈帧,好处是代码短、不用自己管前缀。默认的线程栈是八兆,394 的递归函数每一层要保存一个 std::string 与一个 int,一百层是几万字节,两千层就占掉可观的一块,十万层直接越过八兆边界,进程收到 SIGSEGV 退出码 139。实测里一千层时两者都是零点零几毫秒,差别小到看不出来,规模上到十万层时递归那一边根本没跑完。
问:71 为什么按段切段压栈比在串上反复改写快?
核心要点:差别在每次修完之后要不要搬尾巴。把路径当一条串处理时,每删掉一处双斜杠、一处点段、一处两点段,后面的字符都要整体往前挪,删的处数一多就是平方级;一万字符的路径上两种写法差六十八倍,规模翻一倍差距会翻四倍。按斜杠切段之后,每一段只被读一次,普通名字压进栈、两点弹一段,最后按栈里的顺序拼一遍,整条路径从头到尾只被扫过一次,宽度与深度都是线性的。
问:std::stack 默认后端是 deque,什么情况下该显式换成 vector 或 list?
核心要点:默认的 deque 在两端都能压弹,代价是分块存储与跨块的条件判断,本批八道题只在尾部压弹,用不到另一端的能力。换成 vector 之后每元素四字节出头、尾部压弹没有跨块分支,实测五百万个 int 上压栈比 deque 快接近一倍,缺点是扩容时要整块搬家、迭代器会失效。换成 list 之后每次压栈一次结点分配,五百万个元素占一百五十多兆、每元素三十二字节,只有在元素本身很大、搬家的代价高过分配时才值得。写算法题时一律拿 vector 当栈用,剪枝掉跨块与分配这两项开销。
问:946 的模拟为什么能判出所有非法的出栈序列?
核心要点:因为它照着真实栈的每一条可能路径走了一遍。压栈的顺序是固定的,可选的只有「现在压下一个」与「现在弹栈顶」这两种动作,模拟写法按 pushed 的顺序压、压完就尽可能弹,弹不动了再压下一个,这恰好是唯一一种能尽可能早地满足 popped 前缀的策略;如果连这种策略都满足不了 popped,说明那条序列在任何时刻都走不出来,贪心的这一步可以证明不会错过可行解。回显里两千组随机排列同时跑 vector 版、list 版与递归枚举版三份实现,三份答案两两相同。
问:每道题都写暴力对照与边界用例,值不值得?
核心要点:复杂度只说明规模上去之后怎么长,说明不了常数、边界与实现有没有写错。暴力对照是另一条完全不同的实现路径,739 的逐格往右扫与单调栈没有任何共用代码,两条路跑出来的答案逐组一致,才有理由相信主解没有在某个分支上写错;边界用例管的是随机数据里几乎不会出现的形状,空串、空数组、单元素、退格多于字符、上跳出根这些情况不单写就永远随机不到,而它们恰好是最容易越界的地方。两千组随机加十几条写死的边界,加起来不到两百行驱动,换回来的是八道题里零组不一致这个结论。
参考
- leetcode 844. 比较含退格的字符串
- leetcode 155. 最小栈
- leetcode 739. 每日温度
- leetcode 496. 下一个更大元素 I
- leetcode 84. 柱状图中最大的矩形
- leetcode 946. 验证栈序列
- leetcode LCR 148. 验证图书取出顺序
- leetcode 394. 字符串解码
- leetcode 71. 简化路径
- std::stack - cppreference
- stack - C++ Reference
- std::vector - cppreference
- std::deque - cppreference
- std::unordered_map - cppreference
- libstdc++ 手册