leetcode1793. 好子数组的最大分数【单调栈+双指针】

原题链接：1793. 好子数组的最大分数

题目描述：

给你一个整数数组 nums （下标从 0 开始）和一个整数 k 。

一个子数组 (i, j) 的 分数 定义为 min(nums[i], nums[i+1], ..., nums[j]) * (j - i + 1) 。一个 好 子数组的两个端点下标需要满足 i <= k <= j 。

请你返回 好 子数组的最大可能 分数 。

输入输出描述：

示例 1：

输入：nums = [1,4,3,7,4,5], k = 3
输出：15
解释：最优子数组的左右端点下标是 (1, 5) ，分数为 min(4,3,7,4,5) * (5-1+1) = 3 * 5 = 15 。

示例 2：

输入：nums = [5,5,4,5,4,1,1,1], k = 0
输出：20
解释：最优子数组的左右端点下标是 (0, 4) ，分数为 min(5,5,4,5,4) * (4-0+1) = 4 * 5 = 20 。

提示：

• 1 <= nums.length <= 105
• 1 <= nums[i] <= 2 * 104
• 0 <= k < nums.length

解题思路：

解法1：单调栈

我们把每一个位置的高度画成一个对应高度的小矩形，那么就会形成一个柱状图，那么区间的长度*区间最小值的最大值本质就是最大矩形的面积，那么每一个位置都有可能成为矩形的高，那么我们不妨可以枚举每一个位置作为矩形的高，那么这个以当前选择位置为高的矩形左右俩边选择的所有位置的高都必须大于等于当前位置的高，左右俩边尽量延伸的更远能保证矩形的面积更大，那么实际上就是需要我们找当前为高的位置的左边最近的比当前位置小的位置和右边最近的比当前位置小的位置，这个过程可以使用单调栈进行维护。

时间复杂度：O(n)。

空间复杂度：O(n)。

cpp代码如下：

class Solution {
public:
    int maximumScore(vector<int>& nums, int k) {
        int n=nums.size();
        vector<int>left(n),right(n);
        stack<int>stk;
        for(int i=0;i<n;i++)  //单调栈预处理每个位置左边最近的更小的位置
        {
            while(stk.size() && nums[stk.top()]>=nums[i])stk.pop();
            if(stk.size())left[i]=stk.top();
            else left[i]=-1;  //左边没有更小的就是-1
            stk.push(i);
        }

        stk=stack<int>();
        for(int i=n-1;i>=0;i--)  //单调栈预处理每个位置右边里的最近的更小的位置
        {
            while(stk.size() && nums[stk.top()]>=nums[i])stk.pop();
            if(stk.size())right[i]=stk.top();
            else right[i]=n;  //右边没有更小的就为n
            stk.push(i);
        }

        int ans=0;
        for(int i=0;i<n;i++)
        {
            int h=nums[i],l=left[i],r=right[i];
            if(l<k && k<r)ans=max(ans,h*(r-l-1));  //当然这个矩形必须包含k这个点
        }
        return ans;
    }
};

解法2：双指针

首先我们设置俩个指针l=k,r=k，当前位置k必须选择，然后俩个指针考虑分别往左右俩边进行移动，如果nums[l-1]>=nums[r+1]那么l指针往左移动，否则r指针往右移动，移动的过程中更新答案，那么这种移动方式为什么一定会出现包含k点的最大矩形呢，那么我们来证明一下：

假设我们包含k这个点的最大矩形，左边界是L，右边界是R，假设我们左指针l先移动到L，此时nums[l-1]=nums[L-1]<nums[r+1]，那么后续过程一定是r一直往右移动，直到r==R，也就是一定会出现l==L&&r==R这种情况，对于当r先移动到R也是同理可证，所以我们可以考虑双指针的时候更新答案即可。

注：解法2是学习的灵神的解法。

时间复杂度：O(n)。

空间复杂度：O(1)。

cpp代码如下：

class Solution {
public:
    int maximumScore(vector<int>& nums, int k) {
        int n=nums.size();
        int l=k,r=k,minh=nums[k];
        int ans=minh;
        for(int i=0;i<n-1;i++)
        {
            if(r==n-1 || l && nums[l-1]>=nums[r+1]){
                minh=min(minh,nums[--l]);
            }else {
                minh=min(minh,nums[++r]);
            }
            ans=max(ans,minh*(r-l+1));
        }
        return ans;
    }
};