给定一个
n
n
n个元素的数组
132模式,就是找到
n
u
m
s
[
i
]
,
n
u
m
s
[
j
]
,
n
u
m
s
[
k
]
nums[i], nums[j], nums[k]
nums[i],nums[j],nums[k],满足
i
<
j
<
k
,
n
u
m
s
[
i
]
<
n
u
m
s
[
k
]
<
n
u
m
s
[
j
]
i < j < k, nums[i] < nums[k] <nums[j]
i<j<k,nums[i]<nums[k]<nums[j]
如果存在132序列,返回True,否则返回false
暴力
遍历过程中,保留最小的,然后右边找两个满足元素
class Solution {
public:
bool find132pattern(vector<int>& nums) {
int n = nums.size();
if(n < 3)return false;
bool flag = true;
int min_i = nums[0];
for(int j = 1; j + 1 < n; ++j){
if(nums[j] < min_i){
min_i = nums[j];
continue;
}
for(int k = j + 1; k < n; ++k){
if(min_i < nums[k] && nums[k] < nums[j]){
return true;
}
}
}
return false;
}
};
但是这样时间复杂度 O ( n 2 ) O(n^2) O(n2) 会超时
单调栈
逆序遍历,这样的目的是要找
j
,
k
j,k
j,k
其实只要保留最大的
n
u
m
s
[
j
]
nums[j]
nums[j],然后保留右边最大的
n
u
m
s
[
k
]
nums[k]
nums[k]
因此可以维护一个单调递减栈,如果当前元素小于
n
u
m
s
[
k
]
nums[k]
nums[k]就找到了
class Solution {
public:
bool find132pattern(vector<int>& nums) {
if(nums.size() < 3)return false;
int max_third = 0x80000000;
stack<int> st;
for(int i = nums.size() - 1; i >= 0; --i){
if(nums[i] < max_third)return true;
while(!st.empty() && nums[i] > st.top()){
max_third = st.top();
st.pop();
}
st.push(nums[i]);
}
return false;
}
};
时间复杂度 O ( n ) O(n) O(n)