一刷456

Author: diguage

README.adoc

@@ -3218,12 +3218,12 @@ TIP: **公众号的微信号是: `jikerizhi`**。__因为众所周知的原因
 |Easy
 |
 
-//|{counter:codes}
-//|{leetcode_base_url}/132-pattern/[456. 132 Pattern^]
-//|{source_base_url}/_0456_132Pattern.java[Java]
-//|{doc_base_url}/0456-132-pattern.adoc[题解]
-//|Medium
-//|
+|{counter:codes}
+|{leetcode_base_url}/132-pattern/[456. 132 Pattern^]
+|{source_base_url}/_0456_132Pattern.java[Java]
+|{doc_base_url}/0456-132-pattern.adoc[题解]
+|Medium
+|
 
 |{counter:codes}
 |{leetcode_base_url}/circular-array-loop/[457. Circular Array Loop^]

docs/0456-132-pattern.adoc

@@ -1,57 +1,81 @@
 [#0456-132-pattern]
-= 456. 132 Pattern
+= 456. 132 模式
 
-{leetcode}/problems/132-pattern/[LeetCode - 132 Pattern^]
+https://leetcode.cn/problems/132-pattern/[LeetCode - 456. 132 模式 ^]
 
+给你一个整数数组 `nums` ，数组中共有 `n` 个整数。*132 模式的子序列* 由三个整数 `nums[i]`、`nums[j]` 和 `nums[k]` 组成，并同时满足：`+i < j < k+` 和 `+nums[i] < nums[k] < nums[j]+` 。
 
-Given a sequence of n integers a~1~, a~2~, ..., a~n~, a 132 pattern is a subsequence a~*i*~, a~*j*~, a~*k*~ such
-that *i* < *j* < *k* and a~*i*~ < a~*k*~ < a~*j*~. Design an algorithm that takes a list of n numbers as input and checks whether there is a 132 pattern in the list.
+如果 `nums` 中存在 *132 模式的子序列* ，返回 `true` ；否则，返回 `false` 。
 
-*Note:* n will be less than 15,000.
+*示例 1：*
 
-*Example 1:*
+....
+输入：nums = [1,2,3,4]
+输出：false
+解释：序列中不存在 132 模式的子序列。
+....
 
+*示例 2：*
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* [1, 2, 3, 4]
+....
+输入：nums = [3,1,4,2]
+输出：true
+解释：序列中有 1 个 132 模式的子序列： [1, 4, 2] 。
+....
 
-*Output:* False
+*示例 3：*
 
-*Explanation:* There is no 132 pattern in the sequence.
-----
+....
+输入：nums = [-1,3,2,0]
+输出：true
+解释：序列中有 3 个 132 模式的的子序列：[-1, 3, 2]、[-1, 3, 0] 和 [-1, 2, 0] 。
+....
 
+*提示：*
 
-*Example 2:*
+* `+n == nums.length+`
+* `1 \<= n \<= 2 * 10^5^`
+* `-10^9^ \<= nums[i] \<= 10^9^`
 
 
-[subs="verbatim,quotes,macros"]
-----
-*Input:* [3, 1, 4, 2]
 
-*Output:* True
+== 思路分析
 
-*Explanation:* There is a 132 pattern in the sequence: [1, 4, 2].
-----
+完全没有想到竟然可以使用单调栈来解决！
 
+image::images/0456-10.jpeg[{image_attr}]
 
-*Example 3:*
-
-
-[subs="verbatim,quotes,macros"]
-----
-*Input:* [-1, 3, 2, 0]
-
-*Output:* True
-
-*Explanation:* There are three 132 patterns in the sequence: [-1, 3, 2], [-1, 3, 0] and [-1, 2, 0].
-----
+image::images/0456-11.jpeg[{image_attr}]
 
+image::images/0456-12.jpeg[{image_attr}]
 
+从右向左遍历，使用一个单调递减栈，来维护 `32` 的关系：弹出的就是 `2`，栈中的就是 `3`，当前元素小于 `k` 时，就找到了 `132` 模式。
 
 [[src-0456]]
+[tabs]
+====
+一刷::
++
+--
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0456_132Pattern.java[tag=answer]
 ----
+--
+
+// 二刷::
+// +
+// --
+// [{java_src_attr}]
+// ----
+// include::{sourcedir}/_0456_132Pattern_2.java[tag=answer]
+// ----
+// --
+====
+
+
+== 参考资料
 
+. https://leetcode.cn/problems/132-pattern/solutions/676970/xiang-xin-ke-xue-xi-lie-xiang-jie-wei-he-95gt/[456. 132 模式 - 详解为何使用「单调栈」来找最大的 K 是正确的^]
+. https://leetcode.cn/problems/132-pattern/solutions/676741/fu-xue-ming-zhu-cong-bao-li-qiu-jie-dao-eg78f/[456. 132 模式 - 从「暴力求解」到「单调栈」^]
+. https://leetcode.cn/problems/132-pattern/solutions/676437/132mo-shi-by-leetcode-solution-ye89/[456. 132 模式 - 官方题解^]

docs/images/0456-10.jpeg

@@ -997,7 +997,7 @@ include::0454-4sum-ii.adoc[leveloffset=+1]
 
 include::0455-assign-cookies.adoc[leveloffset=+1]
 
-// include::0456-132-pattern.adoc[leveloffset=+1]
+include::0456-132-pattern.adoc[leveloffset=+1]
 
 include::0457-circular-array-loop.adoc[leveloffset=+1]
 

docs/images/0456-11.jpeg

@@ -1389,6 +1389,10 @@ endif::[]
 |{doc_base_url}/0457-circular-array-loop.adoc[题解]
 |✅ 使用回溯，对每一个元素做深度优先遍历。遇到环形数组则返回，否则继续向前遍历，直到结束。优化：遍历过的节点肯定不是环形数组，遇到遍历过的节点，直接“返回 false”，这样，所有节点只需要出来一次，时间复杂度 stem:[O(n)]。
 
+|{counter:codes}
+|{leetcode_base_url}/132-pattern/[456. 132 模式^]
+|{doc_base_url}/0456-132-pattern.adoc[题解]
+|❌ 单调栈！完全没想到单调栈的解法！从右向左遍历，使用一个单调递减栈，来维护 `32` 的关系：弹出的就是 `2`，栈中的就是 `3`，当前元素小于 `k` 时，就找到了 `132` 模式。
 
 |===
 

docs/images/0456-12.jpeg

@@ -0,0 +1,36 @@
+package com.diguage.algo.leetcode;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+public class _0456_132Pattern {
+  // tag::answer[]
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-08-24 19:46:45
+   */
+  public boolean find132pattern(int[] nums) {
+    int n = nums.length;
+    Deque<Integer> stack = new ArrayDeque<>();
+    int k = Integer.MIN_VALUE;
+    for (int i = n - 1; i >= 0; i--) {
+      // k 初始化时是 Integer.MIN_VALUE，
+      // 当出现小于 k 的元素时，说明 k 被更新过了，
+      //                     也说明栈中有元素且比 k 大
+      if (nums[i] < k) {
+        return true;
+      }
+      // 单调递减栈，遇到大的元素，就把小的都弹出来
+      while (!stack.isEmpty() && stack.peekLast() < nums[i]) {
+        // 在弹出来的小的元素里面，找最大的元素
+        k = Math.max(k, stack.pollLast());
+      }
+      stack.addLast(nums[i]);
+    }
+    return false;
+  }
+  // end::answer[]
+  public static void main(String[] args) {
+    new _0456_132Pattern().find132pattern(new int[]{1, -4, 2, -1, 3, -3, -4, 0, -3, -1});
+  }
+}