LeetCode 2866. 美丽塔 II

 

一、题目

1、题目描述

给你一个长度为 n 下标从 0 开始的整数数组 maxHeights 。

你的任务是在坐标轴上建 n 座塔。第 i 座塔的下标为 i ，高度为 heights[i] 。

如果以下条件满足，我们称这些塔是 美丽 的：

1. 1 <= heights[i] <= maxHeights[i]
2. heights 是一个 山脉 数组。

如果存在下标 i 满足以下条件，那么我们称数组 heights 是一个 山脉 数组：

• 对于所有 0 < j <= i ，都有 heights[j - 1] <= heights[j]
• 对于所有 i <= k < n - 1 ，都有 heights[k + 1] <= heights[k]

请你返回满足 美丽塔 要求的方案中，高度和的最大值 。

2、接口描述

​

class Solution {
public:
    long long maximumSumOfHeights(vector& maxHeights) {
        
    }
};

3、原题链接

2866. 美丽塔 II

---

二、解题报告

1、思路分析

关于单调栈详见：单调栈详解[c/c++]-CSDN博客

---

对于山峰显然要满足左边单调递增，右边单调递减，而每个位置又给了高度限制，我们可以枚举山峰的位置，然后取最大高度和为答案。

直接暴力的话O(n^2)的时间复杂度肯定过不了，但是对于每个位置i作为山峰，其对应的高度和为

presum(i) + sufsum(i) - maxHeights[i]

我们如果能预处理出前缀和pre和后缀和suf，其中pre[i]代表0到i最大单调递增和，suf[i]代表i到n - 1最大单调递减和，我们再去找最大的pre[i] + suf[i] - maxHeights[i]即可

那么如何快速处理出pre和suf呢，直接用遍历一遍同时维护一个单调栈即可，我们以预处理pre为例：

• 从左往右遍历maxHeights，sum代表当前最大递增前缀和，单调栈中存储下标
• 如果maxHeights[i] > maxHeights[s.top()]，那么我们不弹栈
• 否则，一直弹出栈顶并还原sum，直到栈空或者栈顶小于maxHeights[i]
• sum += (i - s.top()) * maxHeights[i]
• 为了避免栈空非法访问栈顶，我们给栈中添加一个哨兵元素-1
• suf处理同理

2、复杂度

时间复杂度：O(n) 空间复杂度：O(n)

3、代码详解

class Solution {
public:
typedef long long ll;
    long long maximumSumOfHeights(vector& h) {
        stack s1 , s2;
        int n = h.size();        
        s1.push(-1);s2.push(n);

        vector pre(n);
        ll sum = 0 , ret = 0;
        for(int i = 0 ; i < n ; i++)
        {
            int t = s1.top();
            while(s1.size() > 1 && h[i] <= h[s1.top()])
                t = s1.top() , s1.pop() , sum -= (ll)h[t] * (t - s1.top());
            
            sum += (ll)h[i] * (i - s1.top());
            pre[i] = sum;
            s1.push(i);
        }
        for(auto x : pre) cout << x << " ";
        sum = 0;
        for(int i = n - 1 ; i >= 0 ; i--)
        {
            int t = s2.top();
            while(s2.size() > 1 && h[i] <= h[s2.top()])
                t = s2.top() , s2.pop() , sum -= (ll)h[t] * (s2.top() - t);

            sum += (ll)h[i] * (s2.top() - i);
            ret = max(ret , pre[i] + sum - h[i]);
            s2.push(i);
        }

        return ret;
    }
};