【随想录】-【11 单调栈】-【03】503 下一个更大元素Ⅱ

重点：

（1）暴力法：原始暴力法，O(n^2)，逻辑简单；

（2）动态规划：也能做，但此处不写；

（3）两段式单调栈：第一遍得到后面比自己大的。第二遍不入栈直接比，得到前面有比自己大的；

（4）阿哲单调栈：看了答案之后发现自己想多了，就直接延展前面n-1个元素，将2n-1个元元素硬做就行，然后输出前n个；

503. 下一个更大元素 II

难度中等663

给定一个循环数组 nums （ nums[nums.length - 1] 的下一个元素是 nums[0] ），返回 nums 中每个元素的 下一个更大元素 。

数字 x 的 下一个更大的元素 是按数组遍历顺序，这个数字之后的第一个比它更大的数，这意味着你应该循环地搜索它的下一个更大的数。如果不存在，则输出 -1 。

示例 1:

输入: nums = [1,2,1]
输出: [2,-1,2]
解释: 第一个 1 的下一个更大的数是 2；
数字 2 找不到下一个更大的数； 
第二个 1 的下一个最大的数需要循环搜索，结果也是 2。

示例 2:

输入: nums = [1,2,3,4,3]
输出: [2,3,4,-1,4]

提示:

• 1 <= nums.length <= 104
• -109 <= nums[i] <= 109

解析：

方法1：暴力搜索

暴力搜索，O(n^2)复杂度，逻辑简单，直接看代码；

方法2：单调栈

搜索下一个比它更大的数，循环数组，单调栈。

（1）两段式：首先运行一遍，将有的答案result存储下来。此时栈中余留的元素就是后面没有比它更大的，但是它前面可能会有比它更大的。那么再将前n-1个元素检检测一遍。这次就不入栈了，直接拿来比，如果比栈顶小直接下一个，如果比栈顶大直接开始出栈，直至栈为空或者遇到一个比自己大的。遍历完第二遍n-1个元素后，如果栈中还有，说明这个就彻底没比自己大的了，有的话都出栈了。

（2）延展数组：直接延展n-1个数，然后照常操作就行。后面的就算二次更新，也不会影响结果。

代码：

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(),-1);
        for(int i=0;i<nums.size();i++){
            int j=(i+1)%nums.size();
            while(j!=i){
                if(nums[j]>nums[i]){
                    result[i]=nums[j];
                    break;
                }
                j=(j+1)%nums.size();
            }           
        }
        return result;
    }
};

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(),-1);
        stack<int> stk;
        while(!stk.empty())
            stk.pop();
        stk.push(0);
        for(int i=1;i<nums.size();i++){
            if(stk.empty())
                stk.push(i);
            else if(nums[i]<=nums[stk.top()])
                stk.push(i);
            else{
                while(!stk.empty()){
                    if(nums[stk.top()]<nums[i]){
                        result[stk.top()]=nums[i];
                        stk.pop();
                    }
                    else
                        break;
                }
                stk.push(i);
            }
        }
        for(int i=0;i<nums.size()-1;i++){
            if(stk.empty())
                break;
            if(nums[i]<=nums[stk.top()])
                continue;
            else{
                while(!stk.empty()){
                    if(nums[stk.top()]<nums[i]){
                        result[stk.top()]=nums[i];
                        stk.pop();
                    }
                    else
                        break;
                }
            }
        }
        return result;
    }
};

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        vector<int> result(nums.size(),-1);
        stack<int> stk;
        while(!stk.empty())
            stk.pop();
        for(int i=0;i<2*nums.size()-1;i++){
            while(!stk.empty()&&nums[stk.top()]<nums[i%nums.size()]){
                result[stk.top()]=nums[i%nums.size()];
                stk.pop();
            }
            stk.push(i%nums.size());
        }
        return result;
    }
};