Leetcode: 132 Pattern

Posted 2020-08-22 neverlandly

Given a sequence of n integers a1, a2, ..., an, a 132 pattern is a subsequence ai, aj, ak such that i < j < k and ai < ak < aj. Design an algorithm that takes a list of n numbers as input and checks whether there is a 132 pattern in the list.

Note: n will be less than 15,000.

Example 1:
Input: [1, 2, 3, 4]

Output: False

Explanation: There is no 132 pattern in the sequence.
Example 2:
Input: [3, 1, 4, 2]

Output: True

Explanation: There is a 132 pattern in the sequence: [1, 4, 2].
Example 3:
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].

我觉得这道题是hard，难点第一是要想到用stack，第二是要维护一个这样子的min-max序列：So at any time in the stack, non-overlapping Pairs are formed in descending order by their min value, which means the min value of peek element in the stack is always the min value globally.

The idea is that we can use a stack to keep track of previous min-max intervals.

 

For each number num in the array

If stack is empty:

• push a new Pair of num into stack

If stack is not empty:

• if num < stack.peek().min, push a new Pair of num into stack

• if num >= stack.peek().min, we first pop() out the peek element, denoted as last

  • if num < last.max, we are done, return true;

  • if num >= last.max, we merge num into last, which means last.max = num.
    Once we update last, if stack is empty, we just push back last.
    However, the crucial part is:
    If stack is not empty, the updated last might:

    • Entirely covered stack.peek(), i.e. last.min < stack.peek().min (which is always true) && last.max >= stack.peek().max, in which case we keep popping out stack.peek().
    • Form a 1-3-2 pattern, we are done ,return true

refer to: https://discuss.leetcode.com/topic/68193/java-o-n-solution-using-stack-in-detail-explanation/2

 1 class Pair{
 2         int min, max;
 3         public Pair(int min, int max){
 4             this.min = min;
 5             this.max = max;
 6         }
 7     }
 8     public boolean find132pattern(int[] nums) {
 9         Stack<Pair> stack = new Stack();
10         for(int n: nums){
11             if(stack.isEmpty() || n <stack.peek().min ) stack.push(new Pair(n,n));
12             else if(n > stack.peek().min){ 
13                 Pair last = stack.pop();
14                 if(n < last.max) return true;
15                 else {
16                     last.max = n;
17                     while(!stack.isEmpty() && n >= stack.peek().max) stack.pop();
18                     // At this time, n < stack.peek().max (if stack not empty)
19                     if(!stack.isEmpty() && stack.peek().min < n) return true;
20                     stack.push(last);
21                 }
22                 
23             }
24         }
25         return false;
26     }

我的方法第15行不一样

 1 public class Solution {
 2     public class Pair {
 3         int min;
 4         int max;
 5         public Pair(int n1, int n2) {
 6             min = n1;
 7             max = n2;
 8         }
 9     }
10     
11     public boolean find132pattern(int[] nums) {
12         if (nums.length < 3) return false;
13         Stack<Pair> st = new Stack<Pair>();
14         for (int n : nums) {
15             if (st.isEmpty() || n<=st.peek().min) st.push(new Pair(n, n));
16             else {
17                 if (n < st.peek().max) return true;
18                 Pair last = st.pop();
19                 last.max = Math.max(last.max, n);
20                 while (!st.isEmpty() && last.max>=st.peek().max) st.pop();
21                 if (!st.isEmpty() && last.max>st.peek().min) return true;
22                 st.push(last);
23             }
24         }
25         return false;
26     }
27 }