单调栈题目：132 模式

题目

标题和出处

标题：132 模式

出处：456. 132 模式

难度

6 级

题目描述

要求

给你一个整数数组 $\text{nums}$，数组中共有 $\text{n}$ 个整数。$\text{132}$ 模式的子序列由三个整数 $\text{nums[i]}$、$\text{nums[j]}$ 和 $\text{nums[k]}$ 组成，并同时满足：$\text{i < j < k}$ 和 $\text{nums[i] < nums[k] < nums[j]}$。

如果 $\text{nums}$ 中存在 $\text{132}$ 模式的子序列，返回 $\text{true}$；否则，返回 $\text{false}$。

示例

示例 1：

输入：$\text{nums = [1,2,3,4]}$
输出：$\text{false}$
解释：序列中不存在 $\text{132}$ 模式的子序列。

示例 2：

输入：$\text{nums = [3,1,4,2]}$
输出：$\text{true}$
解释：序列中有 $\text{1}$ 个 $\text{132}$ 模式的子序列：$\text{[1, 4, 2]}$。

示例 3：

输入：$\text{nums = [-1,3,2,0]}$
输出：$\text{true}$
解释：序列中有 $\text{3}$ 个 $\text{132}$ 模式的的子序列：$\text{[-1, 3, 2]}$、$\text{[-1, 3, 0]}$ 和 $\text{[-1, 2, 0]}$。

数据范围

• $\text{n}=\text{nums.length}$
• $\text{1}\le \text{n}\le \text{2}\times {\text{10}}^{\text{5}}$
• ${\text{-10}}^{\text{9}}\le \text{nums[i]}\le {\text{10}}^{\text{9}}$

解法

思路和算法

这道题要求判断长度为 $n$ 的数组 $\text{nums}$ 中是否存在下标三元组 $(i,j,k)$ 满足 $i<j<k$ 且 $\text{nums}[i]<\text{nums}[k]<\text{nums}[j]$。

由于三元组的最小下标 $i$ 对应最小的元素，因此可以在枚举 $i$ 的同时寻找符合要求的下标 $j$ 和 $k$。

对于下标 $j$ 和 $k$，如果满足 $j<k$ 且 $\text{nums}[j]>\text{nums}[k]$，则只要存在一个下标 $i$ 满足 $i<j$ 且 $\text{nums}[i]<\text{nums}[k]$，即存在满足要求的下标三元组 $(i,j,k)$。因此，可以记录数组 $\text{nums}$ 的每个前缀的最小值。

创建长度为 $n$ 的数组 $\text{minArray}$，对于任意 $0\le i<n$，$\text{minArray}[i]$ 表示数组 $\text{nums}$ 从下标 $0$ 到下标 $i$ 的范围内的最小值。数组 $\text{minArray}$ 中的元素计算方法是：

• $\text{minArray}[0]=\text{nums}[0]$；

• 对于 $1\le i<n$，$\text{minArray}[i]=\min (\text{minArray}[i-1],\text{nums}[i])$。

根据数组 $\text{minArray}$ 的定义可知，对于任意 $1\le i<n$，$\text{minArray}[i-1]\ge \text{minArray}[i]$，因此 $\text{minArray}$ 的元素具有非严格单调性，从左到右遍历时单调递减，从右到左遍历时单调递增。

得到数组 $\text{minArray}$ 之后，从右到左遍历数组 $\text{nums}$，寻找满足条件的下标三元组。遍历过程中维护单调栈，单调栈存储数组 $\text{nums}$ 的元素，满足从栈底到栈顶的元素单调递减（非严格）。

记当前下标为 $j$，需要寻找小于 $j$ 的下标 $i$ 和大于 $j$ 的下标 $k$，满足 $\text{nums}[i]<\text{nums}[k]<\text{nums}[j]$。具体做法如下：

1. 如果栈不为空且栈顶元素小于或等于 $\text{minArray}[j]$，则将栈顶元素出栈，重复该操作直到栈为空或栈顶元素大于 $\text{minArray}[j]$；

2. 如果栈不为空且栈顶元素小于 $\text{nums}[j]$，则返回 $\text{true}$，否则将 $\text{nums}[j]$ 入栈。

遍历结束时，如果没有发现满足要求的下标三元组，返回 $\text{false}$。

证明

对于上述解法的正确性，需要从两个方面证明，一是只有当找到符合要求的下标三元组时才会返回 $\text{true}$，二是只要存在符合要求的下标三元组就一定会返回 $\text{true}$。

由于对单调栈操作时是从右到左遍历数组 $\text{nums}$，因此当遍历到下标 $j$ 时，单调栈内的元素一定是 $\text{nums}[j]$ 右边的元素，即单调栈内的元素在数组中的下标一定大于 $j$。当单调栈不为空时，假设单调栈的栈顶元素在数组中对应下标 $k$，即栈顶元素是 $\text{nums}[k]$，则必有 $j<k$。又由于当遍历到下标 $j$ 时，如果单调栈不为空，则单调栈的栈顶元素一定大于 $\text{minArray}[j]$（否则栈顶元素出栈），因此当单调栈不为空时，一定存在下标 $i$，使得 $i\le j<k$ 且 $\text{nums}[i]=\text{minArray}[j]<\text{nums}[k]$。如果 $\text{nums}[j]$ 大于栈顶元素，则 $\text{nums}[j]>\text{nums}[k]$，根据传递性可知 $\text{nums}[j]>\text{nums}[k]>\text{nums}[i]$，因此 $i\ne j$，必有 $i<j$，此时找到一个下标三元组 $(i,j,k)$，满足 $i<j<k$ 且 $\text{nums}[i]<\text{nums}[k]<\text{nums}[j]$，该下标三元组满足 $132$ 模式，返回 $\text{true}$。

由于当遍历到下标 $j$ 时，单调栈内的元素一定大于 $\text{minArray}[j]$，且当 $\text{nums}[j]$ 大于栈顶元素时即返回 $\text{true}$，因此只有当 $\text{nums}[j]$ 小于等于栈顶元素时才会将 $\text{nums}[j]$ 入栈，可知单调栈满足从栈底到栈顶的元素单调递减（非严格）。

根据数组 $\text{minArray}$ 的定义可知，对于任意 $1\le i<n$，$\text{minArray}[i-1]\ge \text{minArray}[i]$，因此在从右到左遍历数组 $\text{nums}$ 的过程中，下标 $j$ 递减，访问到的 $\text{minArray}[j]$ 的值递增（非严格）。由于单调栈内的元素必须大于 $\text{minArray}[j]$，因此在从右到左遍历过程中，单调栈的栈顶元素允许的最小值在递增，如果单调栈不为空，则栈顶元素 $\text{nums}[k]$ 一定是数组 $\text{nums}$ 位于下标 $j$ 右边的元素中的大于 $\text{minArray}[j]$ 的最小元素，只要 $\text{nums}[j]>\text{nums}[k]$ 即找到满足要求的下标三元组。如果此时单调栈为空，则不存在满足 $j<k$ 且 $\text{minArray}[j]<\text{nums}[k]$ 的下标 $k$，因此不存在满足要求的下标三元组；如果此时 $\text{nums}[j]$ 小于等于单调栈的栈顶元素，则虽然存在下标 $i$ 和 $k$ 满足 $i<j<k$ 且 $\text{nums}[i]<\text{nums}[k]$，但是当前下标 $j$ 不满足 $\text{nums}[j]>\text{nums}[k]$，因此不存在满足要求的下标三元组。根据上述分析可知，对于当前下标 $j$，如果存在满足要求的下标三元组则不会遗漏，如果没有找到将当前下标 $j$ 作为中间下标的下标三元组则说明当前下标 $j$ 无法作为任何一个下标三元组中的 $j$。

代码

class Solution {
    public boolean find132pattern(int[] nums) {
        int n = nums.length;
        int[] minArray = new int[n];
        minArray[0] = nums[0];
        for (int i = 1; i < n; i++) {
            minArray[i] = Math.min(minArray[i - 1], nums[i]);
        }
        Deque<Integer> stack = new ArrayDeque<Integer>();
        for (int j = n - 1; j >= 0; j--) {
            int num = nums[j];
            while (!stack.isEmpty() && stack.peek() <= minArray[j]) {
                stack.pop();
            }
            if (!stack.isEmpty() && stack.peek() < num) {
                return true;
            }
            stack.push(num);
        }
        return false;
    }
}

复杂度分析

• 时间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。需要从左到右遍历数组 $\text{nums}$ 计算数组 $\text{minArray}$ 的值，然后从右到左遍历 $\text{nums}$ 寻找满足要求的下标三元组，由于每个元素最多入栈和出栈各一次，因此时间复杂度是 $O(n)$。

• 空间复杂度：$O(n)$，其中 $n$ 是数组 $\text{nums}$ 的长度。空间复杂度主要取决于数组 $\text{minArray}$ 和栈空间，数组 $\text{minArray}$ 的长度是 $n$，栈内元素个数不会超过 $n$。