寻找下一个最大/小问题【单调栈】

• 单调栈实际上就是栈，只是运用了一些巧妙的逻辑使得每次新元素入栈之后，栈内的元素都保持有序状态
• 单调栈一般用来解决寻找下一个最大/小问题(Next Greater Element)
• 例如，给定一个数组[2,1,2,4,3]，需要返回的数组是[4,2,4,-1,-1]，即每一位的值是从这一位向后的最大的元素的值，如果不存在比当前元素大的值，返回-1
• 我们可以想象是具有数字大小身高的人按照顺序排队，从前往后看，看到的第一个高个子的人，就是此位置的答案

具体代码见模板：

vector<int> nextGreaterElement(vector<int>& nums) {
    vector<int> ans(nums.size()); // 存放答案的数组
    stack<int> s;
    for (int i = nums.size() - 1; i >= 0; i--) { // 倒着往栈里放
        while (!s.empty() && s.top() <= nums[i]) { // 判定个子高矮
            s.pop(); // 去除矮个，反正也被挡着了
        }
        ans[i] = s.empty() ? -1 : s.top(); // 这个元素身后的第一个高个
        s.push(nums[i]); // 进队，接受之后的身高判定
    }
    return ans;
}

练习几个题：

1. 下一个更大元素Ⅰ

• 题目可以分为两个子问题：①如何计算nums2数组中每个元素右边的第一个更大的值 ②如歌存储第一个子问题的结果
• 解决方法是：第一个子问题用单调栈来实现，第二个子问题用哈希表来实现，每个元素的值记录为key，他在nums2中的下一个最大的元素的值记为value，然后再nums1中查找哈希表

代码如下：

vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
    unordered_map<int,int>m;
    stack<int>s;
    for(int i=nums2.size()-1;i>=0;i--){
        while(!s.empty()&&nums2[i]>=s.top()){ //单调栈
            s.pop();
        }
        m[nums2[i]]=s.empty()? -1:s.top(); //哈希记录
        s.push(nums2[i]);
    }
    vector<int>ans;
    for(int i=0;i<nums1.size();i++){ //查找哈希
        ans.push_back(m[nums1[i]]);
    }
    return ans;
}

---

2. 下一个更大元素Ⅱ
   

• 此问题需要循环的查找下一个最大的元素，很容易想到将数组扩展，向后复制一份数组，从复制的数组的最后向前遍历，进行单调栈查找下一个最大值，然后记录原数组位置的结果即可

代码如下：

vector<int> nextGreaterElements(vector<int>& nums) {
    int n=nums.size();
    vector<int>res(n*2,0);
    for(int i=0;i<n;i++){ //向后复制数组
        res[i]=nums[i];
        res[i+n]=nums[i];
    }
    stack<int>s;
    vector<int>ans(n,0);
    for(int i=2*n-1;i>=0;i--){ //单调栈查找下一个最大值
        while(!s.empty()&&res[i]>=s.top()){
            s.pop();
        }
        if(i<n){
            if(s.empty()) ans[i]=-1;
            else ans[i]=s.top();
        }
        s.push(res[i]);
    }
    return ans;
}

---

3.子数组最小成绩的最大值

• 分析题目，最小成绩的定义为最小值乘以和，由于和难以枚举，因此我们考虑枚举最小值
• 在遍历数组枚举最小值时，假设此时枚举的最小值为$num{s}_i$，很容易考虑到：对于某个最小值，我们希望乘的[和]的值最大，因此子数字要最长，长到左右端点值的比$num{s}_i$小
• 因此，我们首先要完成此子问题：找到在$num{s}_i$[之前]/[之后]且[第一个]严格小于$num{s}_i$的元素；很显然这是一个寻找下一个最大/小问题(Next Greater Element)，用单调栈解决
• 找到子数字的范围后，我们还要求出此子数组的和，可以用前缀和来实现
  代码如下：

int maxSumMinProduct(vector<int>& nums) {
    int n=nums.size();
    stack<int>s;
    vector<int>left(n,0),right(n,0); //记录左右第一个小于当前元素的位置
    for(int i=0;i<n;i++){
        while(!s.empty()&&nums[i]<=nums[s.top()]){ //单调栈求解左边
            s.pop();
        }
        left[i]=s.empty()? -1:s.top();
        s.push(i);
    }
    while(!s.empty()) s.pop();
    for(int i=n-1;i>=0;i--){
        while(!s.empty()&&nums[i]<=nums[s.top()]){  //单调栈求解右边
            s.pop();
        }
        right[i]=s.empty()? -1:s.top();
        s.push(i);
    }
    vector<long long>sum;
    long long t=0;
    for(int i=0;i<n;i++){ //前缀和
        t+=nums[i];
        sum.push_back(t);
    }
    long long ans=0;
    for(int i=0;i<n;i++){
        int l,r;
        if(left[i]==-1) l=-1;
        else l=left[i]+1;
        if(right[i]==-1) r=n;
        else r=right[i]-1;
        if(l==-1&&r!=n) ans=max(ans,(long long)(nums[i]*(sum[r]))); //左边没有比当前元素小的，右边有
        else if(r==n&&l!=-1)  ans=max(ans,(long long)(nums[i]*(sum[n-1]-sum[l-1]))); //右边没有比当前元素小的，左边有
        else if(r==n&&l==-1) ans=max(ans,(long long)(nums[i]*sum[n-1])); //左右都没有比当前元素小的
        else ans=max(ans,(long long)(nums[i]*(sum[r]-sum[l-1]))); //左右都有比当前元素小的
    }
    int MOD=1e9+7;
    ans%=MOD;
    return (int)ans;
}