单调栈学习笔记
单调栈基础
单调栈根据所维护的单调性可以分为四种：
- 严格递增栈。必须出栈至栈空或栈顶小于当前元素后，才入栈当前元素。
- 严格递减栈。必须出栈至栈空或栈顶大于当前元素后，才入栈当前元素。
- 非严格递增栈。必须出栈至栈空或栈顶小于等于当前元素后，才入栈当前元素。
- 非严格递减栈。必须出栈至栈空或栈顶大于等于当前元素后，才入栈当前元素。
单调栈基本性质
一些基本性质：
- 维护单调性的方式是：无论破坏多少个栈内的，也要让新元素进来。
- 如果是正着扫序列，则越靠近栈顶的元素，下标越大，距离当前指针越近。
接下来来看单调栈的两个实例。
NGE
NGE 基础
当用到单调栈的时候，95% 都是在解决这个问题。
给定一个数组 \(a\)，对每个 \(i\)，求出 \(i\) 的下一个最近的比 \(a_i\) 大的数的下标 \(f(i)\)，如果不存在则 \(-1\)。
这个问题被称为 Next Greater Element 问题，即 NGE 问题。类似地，我们还有 NLE（Next Less Element），NNGE（Next Not Greater Element），NNLE（Next Not Less Element）问题。这四个问题分别对应四种不同的单调栈，对于 NGE 问题，我们应该选择非严格递减栈：必须出栈至栈空或栈顶大于等于当前元素后，才入栈当前元素。
于是，从左到右扫，每个数都会被入栈一次。如果 \(a_i\) 是 \(a_j\) 进栈时被弹出的，说明 \(a_i < a_j\)，那么 \(f(i) = j\)。如果 \(a_i\) 没被弹出过，\(f(i) = -1\)。至于这具体是为什么，证明省略，网上有很多。
/*
* @Author: crab-in-the-northeast
* @Date: 2022-12-30 02:27:56
* @Last Modified by: crab-in-the-northeast
* @Last Modified time: 2022-12-30 02:31:37
*/
#include <bits/stdc++.h>
inline int read() {
int x = 0;
bool f = true;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = false;
for (; isdigit(ch); ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return f ? x : (~(x - 1));
}
typedef std :: pair <int, int> pii;
const int maxn = (int)3e6 + 5;
int ans[maxn];
int main() {
int n = read();
std :: stack <pii> s;
for (int i = 1; i <= n; ++i) {
int x = read();
while (!s.empty() && x > s.top().first) {
ans[s.top().second] = i;
s.pop();
}
s.push({x, i});
}
for (int i = 1; i <= n; ++i)
printf("%d ", ans[i]);
puts("");
return 0;
}
应该选择什么单调栈？
在实际做了一些单调栈题目后，我发现重要的不是你选择哪种单调性的单调栈，而是选择用于求解四个问题（NGE、NLE、NNGE、NNLE）中哪个问题的单调栈。
怎么选呢？假设我们要选择 NGE 单调栈，核心代码是这样的：
for (int i = 1; i <= n; ++i) {
int x = read();
while (!s.empty() && x > s.top().first) {
ans[s.top().second] = i;
s.pop();
}
s.push({x, i});
}
上面的 x > s.top().first 正是我们体现单调栈类型是 NGE 的地方。很好理解，s.top().first 就是栈顶的值，x 就是当前的元素，因为 x > s.top().first，所以栈顶找到了它的 NGE x，直接标记即可。
假设我们要选择 NNGE 单调栈，那么 while 里的条件应该写成：
!s.empty() && x <= s.top().first
因为 x 是栈顶的 Next Not Greater Element（即小于等于栈顶）。
当然，如果你实在想知道单调性和这四个问题的对应关系，这里我也给出：
- NGE 单调栈 = 非严格单调递减栈。
- NNLE 单调栈 = 严格单调递减栈。
- NLE 单调栈 = 非严格单调递增栈。
- NNGE 单调栈 = 严格单调递增栈。
你可以用适合自己的方法记忆。
从 NGE 问题发掘出更多性质
每个时刻单调栈内元素的含义是：待确定 NGE / NLE / NNGE / NNLE 的元素。这个思想尤为重要，可以看做单调栈的第三条性质。
下面我们以 NGE 单调栈为例。
在单调栈刚好射入 \(a_i\) 后，单调栈中的任一元素 \(a_j\)，目前还没有找到它的 NGE。也即，\(a_j\) 的 NGE 要么不存在，要么下标 \(>i\)，现在还没扫到呢。
而先前被插入，后来已不在单调栈内的元素 \(a_{j'}\)，一定有 \(a_{j'}\) 的 NGE 存在，为 \(a_k\)，并且下标 \(j' < k \le i\)。
同时，考虑任意时刻 NGE 单调栈任意两个相邻的元素 \(a_i\) 和 \(a_j\)。设 \(a_i\) 靠近栈底，\(a_j\) 靠近栈顶，明显有 \(i <j\)，\(a_i \ge a_j\)。
如果 \(i < j - 1\)，则 \(a_{j - 1}\) 不在栈里。由于 \(a_{j - 1}\) 上一秒刚进栈，下一秒就被 \(a_j\) 弹出了，所以 \(a_{j - 1} < a_j\)。
如果 \(i < j - 2\)，意味着 \(a_{j - 2}\) 也没在栈里，那它要么被 \(a_{j - 1}\) 弹出去，要么被 \(a_{j}\) 弹出去。所以有 \(a_{j - 2} < a_{j - 1}\) 或 \(a_{j - 2} < a_j\)。无论如何，因为 \(a_{j - 1} < a_j\)，都有 \(a_{j - 2} < a_j\)。
非常类似地，我们可以推出对于任意 \(i < k <j\)，\(a_k < a_j\)。
所以可以推出 \(a_i \ge a_j > a_k\)。
这意味着，非严格单调递减栈中相邻的两个元素，在原序列中间夹着的所有元素，都比这两个元素更小。称之为性质四。
另外，对于 NNLE 栈，上面那个结论是 \(a_i > a_j \ge a_k\)，证明思路类似。
NLE 和 NNGE 就是上面两种情况不等号反过来啦（这里不取等的接着不取等，取等的接着取等哦）。
区间端点最大 / 小问题
题意：统计数对 \((i, j)\) 的数量，满足 \(\max(a[i + 1 \ldots j - 1]) \le \min(a_i, a_j)\)。
让 \(j\) 从 \(1 \to n\)，统计有多少个 \(i\) 满足 \((i, j)\) 满足要求。考虑维护 NGE 栈。
在射入 \(a_j\) 之前，不在单调栈内的元素 \(a_i\)，要么还没进过栈（\(i \ge j\)），要么已经找到了 NGE（即存在一个 \(k\) 满足 \(i < k< j\) 且 \(a_k > a_i\)）。很明显，这两种情况对应的 \((i, j)\) 都是不满足要求的，所以我们只需要在单调栈中找满足条件的 \(a_i\) 即可。
那么满足条件的 \(a_i\) 又有哪些呢？
我们尝试将 \(a_j\) 射入，这样弹出若干次栈顶。设其中任一元素为 \(a_k\)，则 \(a_k\) 的 NGE 为 \(a_j\)。也即，\(a_k\) 下一个比它大的数就是 \(a_j\)，所以 \(\max(a[k + 1\ldots j - 1]) \le a_k < a_j\)，很明显，\((k, j)\) 是满足要求的。
一直弹到不弹为止，很明显，如果此时栈已经为空，那么上面的所有 \((k, j)\) 已经是所有右端点为 \(j\) 的满足条件的数对了（因为不在栈里的一定不是）。
如果栈不为空，设栈顶为 \(a_p\)。则 \(a_p \ge a_j\)。此时如果我们射入 \(a_j\)，那么 \(a_p\) 和 \(a_j\) 就已经相邻了，之前推得的 性质四 说明，\((p, j)\) 也是满足条件的。
那么比 \(a_p\) 还靠近栈底的元素是否满足条件？
分类讨论。
【第一种情况：\(\boldsymbol{a_p = a_j}\)】
考虑栈中等于 \(a_p\) 的其它元素 \(a_q\)。很明显所有满足条件的 \(a_q\) 都聚集在栈的顶部（我们先不急着射 \(a_j\)）。
根据性质四，在原序列中，所有满足条件的 \(a_q\) 之间，\(a_q\) 与 \(a_p\) 之间，\(a_p\) 与 \(a_j\) 之间的元素都 \(< a_p = a_q = a_j\)，所以所有的 \((q, j)\) 也是满足条件的。
考虑比 \(a_q\) 还大，又最靠近栈顶的元素 \(a_r\)。不难发现 \(a_r >a_q\)，而且 \(a_r\) 再往栈顶走一个元素就是 \(a_q\)。考虑 \(a_r\) 和这个 \(a_q\) 之间的元素，同样满足都小于 \(a_q\)。所以 \((r, j)\) 也满足条件。
但是，\(a_r\) 再往栈底走一个元素 \(a_s\)，即使 \(a_r = a_s\)，序列上 \(s\) 到 \(j\) 也会经过 \(a_r > a_j\)，因此 \((s, j)\) 已经不再合法。比 \(a_s\) 更靠近栈底的元素也会经过 \(a_r\)，同理不合法。
【第二种情况：\(\boldsymbol{a_p > a_j}\)】
此时，只有栈顶这个 \(a_p\) 是满足条件的：如果再射入 \(a_j\)，\(a_p\) 和 \(a_j\) 将相邻，中间的元素 \(< a_j < a_p\)，满足条件。
而不在栈顶的其它元素在序列上到 \(a_j\) 一定会经过 \(a_p > a_j\)，不合法，遗憾离场。
到这里本题正确性已经做完了，但事实上上面的 第一种情况，我们还要从栈顶一直往栈底扫，找极长的一个元素相同段，复杂度已经不对了。
怎么办呢？这里有一个小技巧，那就是把栈中相邻的两个相等的元素“打包”，记成一个 pair 元素，其中 pair 的第一项是元素本身，第二项是元素出现了多少次。这样我们只需要获取栈顶信息即可，复杂度正确。
/*
* @Author: crab-in-the-northeast
* @Date: 2023-04-24 19:49:57
* @Last Modified by: crab-in-the-northeast
* @Last Modified time: 2023-04-24 20:09:39
*/
#include <bits/stdc++.h>
#define int long long
inline int read() {
int x = 0;
bool f = true;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = false;
for (; isdigit(ch); ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return f ? x : (~(x - 1));
}
typedef std :: pair <int, int> pii;
signed main() {
int n = read();
std :: stack <pii> s;
int ans = 0;
while (n--) {
int x = read();
while (!s.empty() && x > s.top().first) {
ans += s.top().second;
s.pop();
}
if (s.empty())
s.push({x, 1});
else if (s.top().first == x) {
int cnt = s.top().second;
ans += cnt;
s.pop();
ans += (s.empty() ? 0 : 1);
s.push({x, cnt + 1});
} else {
++ans;
s.push({x, 1});
}
}
printf("%lld\n", ans);
return 0;
}
对于其它类型的端点最值问题，该怎么解决？请接着阅读后面的例题。
例题
USACO06NOV Bad Hair Day S
P2866 USACO06NOV Bad Hair Day S
统计数对 \((i, j)\) 数量，满足 \(a_i > \max(a[i + 1\ldots j])\)。
【思路一】
考虑扫 \(j\) 从 \(1 \to n\) 统计 \((i, j)\) 的数量，并维护 NNLE 栈。
假设现在将要处理 \(a_j\)（刚处理完 \(a_{j - 1}\) 入栈），那么对于任意 \(i <j\)，不在栈中的元素 \(a_i\) 都找到了它的 NNLE，即存在一个 \(k\) 满足 \(i < k < j\) 并且 \(a_i \le a_k\)。这样的 \((i, j)\) 不可能满足要求，因此只需判断单调栈中的元素。
考虑射入 \(a_j\)，这样会弹出若干次栈顶，设弹出的任一元素为 \(a_k\)。此时，\(a_k\) 找到了它的 NNLE \(a_j\)，证明 \(a_k \le a_j\)，很明显 \((k, j)\) 不满足条件。
弹出所有应该弹的元素后，栈内剩下的任一元素 \(a_p\) 仍未找到它的 NNLE，也即，不存在一个 \(k\) 使得 \(p < k \le j\) 满足 \(a_p \le a_k\)。换句话说，所有满足 \(p < k \le j\) 的 \(k\) 都满足 \(a_p > a_k\)，就有 \(a_p > \max(a[p + 1\ldots j])\)。
因此只需要让每个元素入栈时，先把该弹的弹掉，然后累计剩下的栈的大小即可。
/*
* @Author: crab-in-the-northeast
* @Date: 2023-04-25 08:19:16
* @Last Modified by: crab-in-the-northeast
* @Last Modified time: 2023-04-25 08:21:27
*/
#include <bits/stdc++.h>
#define int long long
inline int read() {
int x = 0;
bool f = true;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = false;
for (; isdigit(ch); ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return f ? x : (~(x - 1));
}
signed main() {
int n = read(), ans = 0;
std :: stack <int> s;
while (n--) {
int x = read();
while (!s.empty() && x >= s.top())
s.pop();
ans += s.size();
s.push(x);
}
printf("%lld\n", ans);
return 0;
}
【思路二】
上面这个思路很巧妙，但事实上有一个无脑做法。
考虑满足条件的 \((i, j)\)，对于一个 \(i\)，所有满足条件的 \(j\) 其实就是在 \(a_i\) 和 \(a_i\) 的 NNLE 的两个下标之内的所有下标。
所以直接算 NNLE 即可。
HISTOGRA
SP1805 HISTOGRA - Largest Rectangle in a Histogram
考虑最优矩形，下方一定紧贴地线，上方一定紧贴某个矩形的高。
我们考虑对于给定每条小矩形，计算目标矩形如果在这个矩形上，以这个矩形的高为高，最宽能延伸多少。
然后发现转化成了 PLE（Previous Less Element）和 NLE 问题，用两个 NLE 栈维护，一个正着扫一个倒着扫即可。
/*
* @Author: crab-in-the-northeast
* @Date: 2023-04-25 08:46:59
* @Last Modified by: crab-in-the-northeast
* @Last Modified time: 2023-04-25 09:02:00
*/
#include <bits/stdc++.h>
#define int long long
inline int read() {
int x = 0;
bool f = true;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = false;
for (; isdigit(ch); ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return f ? x : (~(x - 1));
}
inline bool gmx(int &a, int b) {
return b > a ? a = b, true : false;
}
const int maxn = (int)1e5 + 5;
int a[maxn], ple[maxn], nle[maxn];
signed main() {
for (int n = read(); n; n = read()) {
for (int i = 1; i <= n; ++i)
a[i] = read();
std :: stack <int> s;
for (int i = 1; i <= n; ++i) {
while (!s.empty() && a[i] < a[s.top()]) {
nle[s.top()] = i;
s.pop();
}
s.push(i);
}
while (!s.empty()) {
nle[s.top()] = n + 1;
s.pop();
}
for (int i = n; i; --i) {
while (!s.empty() && a[i] < a[s.top()]) {
ple[s.top()] = i;
s.pop();
}
s.push(i);
}
while (!s.empty()) {
ple[s.top()] = 0;
s.pop();
}
int ans = 0;
for (int i = 1; i <= n; ++i)
gmx(ans, a[i] * (nle[i] - 1 - ple[i]));
printf("%lld\n", ans);
}
return 0;
}
POI2008 PLA-POSTERING
首先发现答案和矩形宽度一点关系都没有。忽略！
不难发现一种可行的方案：对每个建筑分别张贴一张海报，这样海报数量为 \(n\)。
我们必须让一张海报同时完全覆盖两个建筑，才能让需要的海报数量变小。
考虑这两个建筑的必要条件：
- 这两个建筑等高。
- 这两个建筑中间没有比这两个建筑低的建筑。
不难发现上面的条件已经充分，我们考虑优先给满足上面条件的两个建筑中间填上矩形。
这样以来矩形可能有重叠，比如按照上面的填涂规则，有如下事例：
上图中，橙色矩形是红色矩形和黄色矩形的公共部分。
这个问题也很好处理，我们缩减红色的范围，让它的下界只扩展到黄色的上界就可以了。
类似的重叠问题都可以这样解决，优先满足下面的，让上面的只扩展到下面的上界即可。
因此，问题变成统计数对 \((i, j)\) 的数量，满足 \(\max(a[i + 1\ldots j - 1]) > a_i = a_j\)。这是端点最值问题，应用单调栈解决。
统计完这个数量之后，直接用 \(n\) 减去它即可。
解释一下上面为什么是 \(>\) 而不是 \(\ge\)。如果 \((i, j)\) 中间没有比他们高的元素，\((j, k)\) 中间没有比他们高的元素，那么可以有一个矩形精确覆盖 \(a[i \ldots k]\)，这个时候需要的海报数量应该 \(-2\)。而如果是 \(\ge\)，我们会把 \((i, k)\) 也统计上，从而会让需要海报数量 \(-3\)，这不是我们期望的；而改成 \(>\) 就能解决这个问题了。
这个问题怎么做？考虑维护 NNGE 栈，扫 \(j\) 来统计 \((i, j)\) 的数量。
在射入 \(a_j\) 之前，不在栈内的任一元素 \(a_i\) 已经找到了它的 NNGE（Next Not Greater Element），说明存在 \(k\) 使得 \(i < k < j\) 且 \(a_i \ge a_k\)，这样以来 \((i, j)\) 已经不合法。
只用考虑栈内的元素。
考虑弹出为了射入 \(a_j\) 应该弹出的元素 \(a_k\)，有 \(a_k\) 的 NNGE 是 \(a_j\)，也即 \(a_{k + 1}\) 到 \(a_{j - 1}\) 这一段严格比 \(a_k\) 大。这个时候，如果 \(a_k > a_j\)，则 \((k, j)\) 不合法；如果 \(a_k = a_j\)，则 \((k, j)\) 合法。
再考虑栈内剩余的任一元素 \(a_p\)，有 \(a_p < a_j\)，不合法。
所以只需要维护严格递增栈的同时，弹出栈顶的时候看栈顶有没有和元素相同的即可。
/*
* @Author: crab-in-the-northeast
* @Date: 2023-04-25 13:36:30
* @Last Modified by: crab-in-the-northeast
* @Last Modified time: 2023-04-25 13:52:14
*/
#include <bits/stdc++.h>
inline int read() {
int x = 0;
bool f = true;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = false;
for (; isdigit(ch); ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return f ? x : (~(x - 1));
}
int main() {
int n = read(), ans = n;
std :: stack <int> s;
for (int i = 1; i <= n; ++i) {
read(); int x = read();
while (!s.empty() && x <= s.top()) {
if (s.top() == x)
--ans;
s.pop();
}
s.push(x);
}
printf("%d\n", ans);
return 0;
}
我们已经看了两道类似端点最值问题的习题了，大概总结一下方法⑧。
首先，我们要明确，这种问题找到合法 \((i, j)\) 的过程一般都是扫 \(j\) 维护单调栈，看满足条件的 \(i\) 有多少个。而且，不在单调栈里的 \(a_i\) 对应的 \(i\) 一定不合法。
那么怎么确定找那种类型的单调栈呢？看已经确定了 \(\boldsymbol{a_i}\) 的 NGE，NNGE，NLE，NNLE 的四项中的哪一项时，\(\boldsymbol{(i, j)}\) 一定不合法。举个例子吧：
统计数对 \((i, j)\) 的数量，满足 \(\max(a[i + 1 \ldots j - 1]) \le \min(a_i, a_j)\)。
为方便判断，我们将上面的最值形式做一些转化。首先就是先把 关于 \(\boldsymbol{a_j}\) 的限制砍去，即
满足 \(\max(a[i + 1 \ldots j - 1]) \le a_i\)。
然后 将最值转成“对于任意 \(\boldsymbol k\)”这种形式，也即
满足对于任意 \(i < k < j\) 都有 \(a_k \le a_i\)。
考虑 什么时候会破坏这个条件，显然，就是
满足存在 \(i < k < j\) 使得 \(a_k > a_i\)。
也就是 \(a_i\) 找到了它的 NGE，判断成功，我们应该维护 NGE 栈，这样以来，不在栈内的元素就意味着找到 NGE，找到 NGE 就意味着不合法。
再来看这个例子：
统计满足 \(\max(a[i + 1\ldots j - 1]) < a_i = a_j\)。
首先砍去 \(a_j\) 限制：
满足 \(\max(a[i + 1\ldots j-1]) < a_i\)。
最值转任意 \(k\)：
对于任意 \(i < k < j\) 有 \(a_k < a_i\)。
破坏：
存在一个 \(i < k < j\) 有 \(a_k \ge a_i\)。
所以用 NNLE 栈。
另外，上面那个 Bad Hair Day S 的思路一，也可以看成端点最值问题（只是不再将 \(a_j\) 看成端点了），所以用上面的方法也能很方便判断出应该使用什么栈，可以自己试试。
判断完应该使用哪个栈之后，剩余的部分就是看栈里的什么元素满足条件，一般分为两种看：
- 为射入 \(a_j\)，要弹出的元素。
- 射入 \(a_j\) 后仍为弹出的元素。
根据一些取等细节，上面两类可能分为更细的类，需要自己判断。
长方形
对于每个 \(i\) 从 \(1 \to n\)，统计底边在第 \(i\) 行下边界的矩形数量。
从每个点 \((i, j)\) 出发向上往上最多能延伸多少，这个是可以 \(\Theta(nm)\) 预处理的。
然后就变成了 \(n\) 次计数版的 HISTOGRA。问题转化成：
HISTOGRA，但是计算矩形的数量。
考虑一下怎么做。
对第 \(i\) 个矩形，仍然设高度 \(h_i\)，其 PLE 的下标为 \(l_i\)，NLE 的下标为 \(r_i\)。那么从这个点开始，延伸的区域最多是 \([l_i +1, r_i - 1]\)，尝试直接统计 \(h_i \times (i - l_i) \times (r_i - i)\)。
这样以来可能会有重复计数吗？
考虑并排放置的两个等高小矩形，即 \(h_i = h_{i +1}\)，则横长落在 \([i, i +1]\) 这个区间内的所有小矩形都会被 \(h_i \times (i - l_i) \times (r_i - i)\) 和 \(h_{i +1} \times (i + 1 - l_{i + 1}) \times (r_{i + 1} - i - 1)\) 分别统计一次，有重复计数。
怎么办呢？考虑更换 \(r_i\) 的定义：\(h_i\) 的 NNGE 为 \(r_i\)。分析发现，原来的 \(r_i > i +1\)，现在的 \(r_i = i + 1\)，所以 \(h_i \times (i - l_i) \times (r_i - i)\) 不再会对 \(i + 1\) 那一列里的矩形计数，解决了重复计数问题。
我们验证一下是否真的不重不漏了。
每次以 \(i\) 为中心扩展时，统计了所有以 \([l_i + 1, i]\) 内某个点为左端点，以 \([i, r_i - 1]\) 内某个点为右端点的所有矩形。我们尝试证明：对于任意 \(L \le R\)，有且仅有一个 \(i\)，满足 \(L \in [l_i + 1, i]\) 且 \(R \in [i, r_i - 1]\)。
首先很明显，满足条件的 \(i \in [L, R]\)。
其次，考虑找到 \(h[L \ldots R]\) 中取得最小值的 \(h_i\)，如果有多个最小值，取 \(i\) 最大的一个。于是有：对于任意 \(L \le j < i\)，有 \(h_j \ge h_i\)，对于任意 \(i < k \le R\)，有 \(h_k > h_i\)（这里不取等号是因为 \(i\) 在所有最小值中下标最大）。
很明显，\(h_i\) 的 PLE 下标 \(<L\)，即 \(l_i < L\)，\(h_i\) 的 NNGE \(>R\)，即 \(r_i > R\)。这个 \(i\) 满足条件。
对于任意 \(L \le j < i\)，有 \(h_j \ge h_i\)，这说明 \(h_j\) 的 NNGE 下标至少不会超过 \(i\)，即 \(r_j \le i\)。因为 \(i \le R\)，所以 \(r_j \le R\)，\(R\) 不落在 \([j, r_j - 1]\) 内部，\(j\) 不合法。
对于任意 \(i < k \le R\)，有 \(h_i <h_k\)，这说明 \(h_k\) 的 LPE 下标至少不会小于 \(i\)，即 \(l_k \ge i\)。因为 \(i \ge L\)，所以 \(l_k \ge L\)，\(L\) 不落在 \([l_k + 1, k]\) 内部，\(k\) 不合法。证毕。
也就是说，对于任何一个左端点为 \(L\)，右端点为 \(R\) 的矩形，只会在扫到 \(h\) 在 \([L, R]\) 内最靠右的最小值这个点的时候才会被统计到。验证成功。
/*
* @Author: crab-in-the-northeast
* @Date: 2023-04-25 17:53:24
* @Last Modified by: crab-in-the-northeast
* @Last Modified time: 2023-04-25 18:04:25
*/
#include <bits/stdc++.h>
#define int long long
inline int read() {
int x = 0;
bool f = true;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-')
f = false;
for (; isdigit(ch); ch = getchar())
x = (x << 1) + (x << 3) + ch - '0';
return f ? x : (~(x - 1));
}
inline char rech() {
char ch = getchar();
while (!isgraph(ch))
ch = getchar();
return ch;
}
const int maxm = 1005;
int h[maxm], ple[maxm], nnge[maxm];
signed main() {
int ans = 0, n = read(), m = read();
while (n--) {
for (int i = 1; i <= m; ++i)
h[i] = (rech() == '.') ? (h[i] + 1) : 0;
std :: stack <int> s;
for (int i = 1; i <= m; ++i) {
while (!s.empty() && h[i] <= h[s.top()]) {
nnge[s.top()] = i;
s.pop();
}
s.push(i);
}
while (!s.empty()) {
nnge[s.top()] = m + 1;
s.pop();
}
for (int i = m; i; --i) {
while (!s.empty() && h[i] < h[s.top()]) {
ple[s.top()] = i;
s.pop();
}
s.push(i);
}
while (!s.empty()) {
ple[s.top()] = 0;
s.pop();
}
for (int i = 1; i <= m; ++i)
ans += h[i] * (i - ple[i]) * (nnge[i] - i);
}
printf("%lld\n", ans);
return 0;
}
