<p>给你一个长度为 <code>n</code>&nbsp;下标从 <strong>0</strong>&nbsp;开始的整数数组&nbsp;<code>maxHeights</code>&nbsp;。</p>

<p>你的任务是在坐标轴上建 <code>n</code>&nbsp;座塔。第&nbsp;<code>i</code>&nbsp;座塔的下标为 <code>i</code>&nbsp;，高度为&nbsp;<code>heights[i]</code>&nbsp;。</p>

<p>如果以下条件满足，我们称这些塔是 <strong>美丽</strong>&nbsp;的：</p>

<ol>

<li><code>1 &lt;= heights[i] &lt;= maxHeights[i]</code></li>

<li><code>heights</code>&nbsp;是一个 <strong>山脉</strong> 数组。</li>

</ol>

<p>如果存在下标 <code>i</code>&nbsp;满足以下条件，那么我们称数组&nbsp;<code>heights</code>&nbsp;是一个 <strong>山脉</strong> 数组：</p>

<ul>

<li>对于所有&nbsp;<code>0 &lt; j &lt;= i</code>&nbsp;，都有&nbsp;<code>heights[j - 1] &lt;= heights[j]</code></li>

<li>对于所有&nbsp;<code>i &lt;= k &lt; n - 1</code>&nbsp;，都有&nbsp;<code>heights[k + 1] &lt;= heights[k]</code></li>

</ul>

<p>请你返回满足 <b>美丽塔</b>&nbsp;要求的方案中，<strong>高度和的最大值</strong>&nbsp;。</p>

<p>&nbsp;</p>

<p><strong class="example">示例 1：</strong></p>

<pre><b>输入：</b>maxHeights = [5,3,4,1,1]

<b>输出：</b>13

<b>解释：</b>和最大的美丽塔方案为 heights = [5,3,3,1,1] ，这是一个美丽塔方案，因为：

- 1 &lt;= heights[i] &lt;= maxHeights[i]

- heights 是个山脉数组，峰值在 i = 0 处。

13 是所有美丽塔方案中的最大高度和。</pre>

<p><strong class="example">示例 2：</strong></p>

<pre><b>输入：</b>maxHeights = [6,5,3,9,2,7]

<b>输出：</b>22

<strong>解释：</strong> 和最大的美丽塔方案为 heights = [3,3,3,9,2,2] ，这是一个美丽塔方案，因为：

- 1 &lt;= heights[i] &lt;= maxHeights[i]

- heights 是个山脉数组，峰值在 i = 3 处。

22 是所有美丽塔方案中的最大高度和。</pre>

<p><strong class="example">示例 3：</strong></p>

<pre><b>输入：</b>maxHeights = [3,2,5,5,2,3]

<b>输出：</b>18

<strong>解释：</strong>和最大的美丽塔方案为 heights = [2,2,5,5,2,2] ，这是一个美丽塔方案，因为：

- 1 &lt;= heights[i] &lt;= maxHeights[i]

- heights 是个山脉数组，最大值在 i = 2 处。

注意，在这个方案中，i = 3 也是一个峰值。

18 是所有美丽塔方案中的最大高度和。

</pre>

<p>&nbsp;</p>

<p><strong>提示：</strong></p>

<ul>

<li><code>1 &lt;= n == maxHeights &lt;= 10³</code></li>

<li><code>1 &lt;= maxHeights[i] &lt;= 10⁹</code></li>

</ul>

- 单调栈

- 暂无

朴素的思路是枚举山峰。山峰贪心地取 maxHeight[i]，因为取不到 maxHeight[i] 的话后面限制更大不会更优。然后向左向右扩展。扩展的时候除了 maxHeight 限制，还多了一个左边（或者右边）山峰的高度限制。因此可以同时维护一变量 min_v，表示左边（或者右边）山峰的高度，用于限制可以取到的最大值。

直观上来说就是山的高度在扩展的同时不断地下降或者不变，因此我们只需要每次都保证当前的高度都小于等于前面的山峰的高度即可。

ans, n = 0, len(maxHeight)

for i, x in enumerate(maxHeight):

y = t = x

# t 是高度和，y 是 min_v

for j in range(i - 1, -1, -1):

y = min(y, maxHeight[j])

t += y

y = x

for j in range(i + 1, n):

y = min(y, maxHeight[j])

t += y

ans = max(ans, t)

return ans

这种做法时间复杂度是 $O(n^2)$，可以通过，这也是为什么这道题分数比较低的原因。

不过这道题还有一种动态规划 + 单调栈的做法。

以向左枚举为例。同样枚举山峰 i，i 取 maxheight[i]， 然后找左侧第一个小于它的位置 l（用单调栈）。那么 [l+1, i-1] 之间的位置都能且最多取到 maxHeight[l]。那么 [0, l] 之间的能取到多少呢？这其实相当于以 l 为峰顶左侧的最大和。这不就是一个规模更小的子问题吗？用动态规划即可。

向右也是同理，不再赘述。

- 单调栈优化

- 动态规划

- 语言支持：Python3

Python3 Code:

class Solution:

def maximumSumOfHeights(self, maxHeight: List[int]) -> int:

n = len(maxHeight)

f = [-1] * n # f[i] 表示 i 作为峰顶左侧的高度和

g = [-1] * n # g[i] 表示 -i-1 作为峰顶右侧的高度和

def gao(f):

st = []

for i in range(len(maxHeight)):

while st and maxHeight[i] <= maxHeight[st[-1]]:

st.pop()

if st:

f[i] = (i - st[-1]) * maxHeight[i] + f[st[-1]]

else:

f[i] = maxHeight[i] * (i + 1)

st.append(i)

gao(f)

maxHeight = maxHeight[::-1]

gao(g)

maxHeight = maxHeight[::-1]

ans = 0

for i in range(len(maxHeight)):

ans = max(ans, f[i] + g[-i-1] - maxHeight[i])

return ans

**复杂度分析**

令 n 为数组长度。

- 时间复杂度：$O(n)$

- 空间复杂度：$O(n)$

力扣的小伙伴可以[关注我](https://leetcode-cn.com/u/fe-lucifer/)，这样就会第一时间收到我的动态啦~

以上就是本文的全部内容了。大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 40K star 啦。大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

关注公众号力扣加加，努力用清晰直白的语言还原解题思路，并且有大量图解，手把手教你识别套路，高效刷题。

<p>给你一个&nbsp;&nbsp;<code>n x 2</code>&nbsp;的二维数组 <code>points</code>&nbsp;，它表示二维平面上的一些点坐标，其中&nbsp;<code>points[i] = [x_i, y_i]</code>&nbsp;。</p>

<p>我们定义 x 轴的正方向为 <strong>右</strong>&nbsp;（<strong>x 轴递增的方向</strong>），x 轴的负方向为 <strong>左</strong>&nbsp;（<strong>x 轴递减的方向</strong>）。类似的，我们定义 y 轴的正方向为 <strong>上</strong>&nbsp;（<strong>y 轴递增的方向</strong>），y 轴的负方向为 <strong>下</strong>&nbsp;（<strong>y 轴递减的方向</strong>）。</p>

<p>你需要安排这 <code>n</code>&nbsp;个人的站位，这 <code>n</code>&nbsp;个人中包括 Alice 和 Bob 。你需要确保每个点处&nbsp;<strong>恰好</strong>&nbsp;有&nbsp;<strong>一个</strong>&nbsp;人。同时，Alice 想跟 Bob 单独玩耍，所以&nbsp;Alice 会以 Bob<b>&nbsp;</b>的坐标为 <strong>左上角</strong>&nbsp;，Bob 的坐标为 <strong>右下角</strong>&nbsp;建立一个矩形的围栏（<strong>注意</strong>，围栏可能&nbsp;<strong>不</strong> 包含任何区域，也就是说围栏可能是一条线段）。如果围栏的 <strong>内部</strong>&nbsp;或者 <strong>边缘</strong>&nbsp;上有任何其他人，Alice 都会难过。</p>

<p>请你在确保 Alice&nbsp;<strong>不会</strong> 难过的前提下，返回 Alice 和 Bob 可以选择的 <strong>点对</strong>&nbsp;数目。</p>

<p><b>注意</b>，Alice 建立的围栏必须确保 Alice 的位置是矩形的左上角，Bob 的位置是矩形的右下角。比方说，以&nbsp;<code>(1, 1)</code>&nbsp;，<code>(1, 3)</code>&nbsp;，<code>(3, 1)</code>&nbsp;和&nbsp;<code>(3, 3)</code>&nbsp;为矩形的四个角，给定下图的两个输入，Alice 都不能建立围栏，原因如下：</p>

<ul>

<li>图一中，Alice 在&nbsp;<code>(3, 3)</code>&nbsp;且 Bob 在&nbsp;<code>(1, 1)</code>&nbsp;，Alice 的位置不是左上角且 Bob 的位置不是右下角。</li>

<li>图二中，Alice 在&nbsp;<code>(1, 3)</code>&nbsp;且 Bob 在&nbsp;<code>(1, 1)</code>&nbsp;，Bob 的位置不是在围栏的右下角。</li>

</ul>

<img alt="" src="https://assets.leetcode.com/uploads/2024/01/04/example0alicebob-1.png" style="width: 750px; height: 308px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem;">

<p>&nbsp;</p>

<p><strong class="example">示例 1：</strong></p>

<p><img alt="" src="https://assets.leetcode.com/uploads/2024/01/04/example1alicebob.png" style="width: 376px; height: 308px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem;"></p>

<pre><b>输入：</b>points = [[1,1],[2,2],[3,3]]

<b>输出：</b>0

<strong>解释：</strong>没有办法可以让 Alice 的围栏以 Alice 的位置为左上角且 Bob 的位置为右下角。所以我们返回 0 。

</pre>

<p><strong class="example">示例 2：</strong></p>

<p><strong class="example"><a href="https://pic.leetcode.cn/1706880313-YelabI-example2.jpeg"><img alt="" src="https://pic.leetcode.cn/1708226715-CxjXKb-20240218-112338.jpeg" style="width: 900px; height: 248px;"></a></strong></p>

<pre><b>输入：</b>points = [[6,2],[4,4],[2,6]]

<b>输出：</b>2

<b>解释：</b>总共有 2 种方案安排 Alice 和 Bob 的位置，使得 Alice 不会难过：

- Alice 站在 (4, 4) ，Bob 站在 (6, 2) 。

- Alice 站在 (2, 6) ，Bob 站在 (4, 4) 。

不能安排 Alice 站在 (2, 6) 且 Bob 站在 (6, 2) ，因为站在 (4, 4) 的人处于围栏内。

</pre>

<p><strong class="example">示例 3：</strong></p>

<p><strong class="example"><a href="https://pic.leetcode.cn/1706880311-mtPGYC-example3.jpeg"><img alt="" src="https://pic.leetcode.cn/1708226721-wTbEuK-20240218-112351.jpeg" style="width: 911px; height: 250px;"></a></strong></p>

<pre><b>输入：</b>points = [[3,1],[1,3],[1,1]]

<b>输出：</b>2

<b>解释：</b>总共有 2 种方案安排 Alice 和 Bob 的位置，使得 Alice 不会难过：

- Alice 站在 (1, 1) ，Bob 站在 (3, 1) 。

- Alice 站在 (1, 3) ，Bob 站在 (1, 1) 。

不能安排 Alice 站在 (1, 3) 且 Bob 站在 (3, 1) ，因为站在 (1, 1) 的人处于围栏内。

注意围栏是可以不包含任何面积的，上图中第一和第二个围栏都是合法的。

</pre>

<p>&nbsp;</p>

<p><strong>提示：</strong></p>

<ul>

<li><code>2 &lt;= n &lt;= 1000</code></li>

<li><code>points[i].length == 2</code></li>

<li><code>-10⁹ &lt;= points[i][0], points[i][1] &lt;= 10⁹</code></li>

<li><code>points[i]</code>&nbsp;点对两两不同。</li>

</ul>

- 暂无

- 暂无

为了方便确定谁是 alice，谁是 bob，首先我们按 x 正序排序。

令索引 i 是 alice (x1, y1)，索引 j != i 的都**可能**作为 bob(x2, y2)。那什么样的 j 满足条件呢？需要满足：

1. alice 纵坐标要大于等于 bob（横坐标由于排序已经保证了 alice 不大于 bob，满足题目要求）

2. 中间的点纵坐标要么比两人都大，要么比两人都小。（即中间的点的纵坐标不能位于 alice 和 bob 中间）

有一个特殊的 case： alice 和 bob 的横坐标相等，这种情况下如果 i 的纵坐标小于 j 的纵坐标，不一定是不满足题意的。因此 alice 和 bob 横坐标相等，因此我们可以将 alice 看成是 bob， bob 看成是 alice。经过这样的处理，就又满足题意了。

为了不做这种特殊处理，我们可以按照 x 正序排序的同时，对 x 相同的按照 y 逆序排序，这样就不可能出现横坐标相同，i 的纵坐标小于 j 的纵坐标的情况。另外这样在 i 确定的时候，i 前面的点也一定不是 j，因此只需要枚举 i 之后的点即可。

因此我们可以枚举 i 为 alice， j > i 为 bob。然后枚举 i 个 j 中间的点是否满足题意（不在 i 和 j 中间的不用看）。

接下来，我们看如何满足前面提到的两点。

对于第一点，只需比较 alice 和 bob 的 y 即可。

对于第二点，我们只需要记录最大的 y 即可。只要 y2 大于最大的 y 就行。如果 y2 <= max <= y1，那么就不行，否则可以。 其中 max 是 最可能在 alice 和 bob 之间的 y，这样不需要全部比较。这个所谓最可能得就是最大的 y。

大家可以结合图来理解。

如图，虚点是 i 和 j 中间的点。对于这些点只要纵坐标**不**在图上的两个横线之间就行。因此这些点的纵坐标**都**要么大于 y1，要么小于 y2。换句话说，这些点的纵坐标要么最小值大于 y1，要么最大值小于 y2。因此我们只需要记录最大的 y 即可。

- 排序

- 语言支持：Python3

Python3 Code:

class Solution:

def numberOfPairs(self, points: List[List[int]]) -> int:

points.sort(key=lambda p: (p[0], -p[1]))

ans = 0

for i, (x1, y1) in enumerate(points): # point i

max_y = -inf

min_y = inf

for (x2, y2) in points[i + 1:]: # point j

if y1 < y2: continue # 确保条件1

if y2 > max_y or y1 < min_y: # 确保条件2

ans += 1

max_y = max(max_y, y2)

min_y = min(min_y, y2)

return ans

**复杂度分析**

令 n 为 points 长度。

- 时间复杂度：$O(nlogn)$

- 空间复杂度：$O(1)$

力扣的小伙伴可以[关注我](https://leetcode-cn.com/u/fe-lucifer/)，这样就会第一时间收到我的动态啦~

以上就是本文的全部内容了。大家对此有何看法，欢迎给我留言，我有时间都会一一查看回答。更多算法套路可以访问我的 LeetCode 题解仓库：https://github.com/azl397985856/leetcode 。 目前已经 40K star 啦。大家也可以关注我的公众号《力扣加加》带你啃下算法这块硬骨头。

关注公众号力扣加加，努力用清晰直白的语言还原解题思路，并且有大量图解，手把手教你识别套路，高效刷题。