给定一个数组序列, 需要求选出一个区间, 使得该区间是所有区间中经过如下计算的值最大的一个（单调栈）

问题描述

题目如下：

给定一个数组序列, 需要求选出一个区间, 使得该区间是所有区间中经过如下计算的值最大的一个：
区间中的最小数 × 区间所有数的和最后程序输出经过计算后的最大值即可，不需要输出具体的区间。如给定序列 [6 2 1]则根据上述公式, 可得到所有可以选定各个区间的计算值:
从上述计算可见选定区间 [6] ，计算值为 36， 则程序输出为 36。
区间内的所有数字都在[0, 100]的范围内;
[6] = 6 × 6 = 36;
[2] = 2 × 2 = 4;
[1] = 1 × 1 = 1;
[6,2] = 2 × 8 = 16;
[2,1] = 1 × 3 = 3;
[6, 2, 1] = 1 × 9 = 9;

这篇文章会介绍两种解题思路，第一种解题思路看似简单直观，但却为第二种思路进行了铺垫。这是非常重要的。

第一种方法：穷举法

第一个思路是最容易想到的方法。我们把每个元素都看作最小值，从它向左右两边延伸划定一个集合，集合中包括的其他元素当然要比这个最小值大，且集合的范围越大越好。

遍历集合中的每一个元素，最后得到最大值。

打个比方，集合为1、3、4、2、6、5，我们找到每个数的子集，该子集满足三个条件：

1. 该子集中所有元素都相邻。
2. 这个数必须是子集中最小的元素。
3. 该子集中元素要尽量多。

好了现在为每个元素都找到了这样的子集：

1: {1, 3, 4, 2, 6, 5}
3: {3, 4}
4: {4}
2: {3, 4, 2, 6, 5}
6: {6}
5: {6, 5}

那么我们是怎样找到这样的子集呢？很简单，就是从当前元素开始向左遍历，遇到$第一个比它小的元素$停止，这样就找到子集的$左边界$。然后再向右遍历，遇到$第一个比它小的元素$停止，这样就找到子集的$右边界$。得到了左右边界，就相当于我们确定了子集。

然后用最小值乘以集合内的元素之和，即
$1\times (1+3+4+2+6+5)$
$3\times (3+4)$
$4\times 4$
$......$

找到最大的那个就可以了。

这种方法的时间复杂度是$O(n^2)$，实际上是不能让全部数据AC的。下面我介绍第二种思路。

第二种思路：使用栈的思想

实际上我是学习了这位大佬的博客，大佬写得有些生涩，不适用于我这样的小白，所以我花了一晚上理解并记录下我对这种解法的二次理解。这种方法采用了单调栈的数据结构，时间复杂度为$O(n)$，非常牛批。

1. 核心要点

我们依旧以集合1、3、4、2、6、5为例，事实上，理解方法二是一定要在理解方法一的基础上进行的。上文已经提过，找到每个元素对应的子集的核心就是找到子集的$左边界$和$右边界$，而找到左右边界的核心就是找到左右第一个比当前元素小的元素。明白了这一点，我们就可以开始建栈了。

遍历集合中的元素，第一个元素为1，然后思考这样一个问题：$现在的我能确定1对应的子集的左右边界吗？$显然，我们能确定左边界，因为1已经是最左边的元素了；但我们不能确定右边界，因为如果1的下一个元素比1要大，那么1的右边界就可以往右扩大一个。当前情况下我们不能得到1的子集，所以让1$进栈$。然后遍历第二个元素。

第二个元素值为3。我们依旧思考这个问题：我们能确定下3对应的子集的左右边界吗？同样，我们能确定左边界，因为3的上一个元素是1，1比3小，所以左边界不能再扩张了，而1正是此时的栈顶元素；但右边界同样不能确定，因为我们不知道3的下一个数字是否会比3大。因为当下我们不能确定这个子集，所以3进栈。遍历第三个元素。

第三个元素为4，与3同理，左边界是栈顶元素3但不知道右边界。4进栈。

第四个元素是2，这时情况出现了改变——2比4要小。我们突然发现，我们可以确定元素4对应子集的右边界了！此时4对应的子集已经完全可以确定，因此让4$出栈$，并计算这个值也就是$\color{blue}{4\times 4=16}$。

现在栈顶元素是3，而2竟然比3也小！也就是说3对应子集的右边界也找到了。让3出栈。现在我们可以确定下3对应的子集是{3, 4}，计算这个值$3\times (3+4)=21$。

现在栈顶元素是1，2比1大，1的右边界依旧不能确定，因此1不出栈。2的左边界确定，正是当前的栈顶元素1，而右边界不能确定，2进栈。此时栈变为

同理，6比2大，进栈。

5比6小，6的右边界确定，6出栈，并计算题目要求的值即$6\times 6=36$。此时栈顶元素为2，5比2大，5进栈。

到这里，题目中给出的元素已经全部遍历结束，但栈并不为空。为了让栈为空，我们再在结尾多加一个元素0。0与栈顶元素为5，0比5小，5的右边界确定，5出栈，计算题目中要求的值$5\times (5+6)=55$。

然后比较0与栈顶元素2，0比2小，与上面同理，计算$2\times (3+4+2+6+5)=40$，2出栈。$（看到这里，我相信你已经产生了疑问，括号中的内容(3+4+2+6+5)是在怎么计算的呢？别着急，我们下面会继续讲这个问题）$

比较0与此时的栈顶元素1，0比1小，与上面同理，计算$1\times (1+3+4+2+6+5)=21$。1出栈。

循环结束。

以上就是这个算法，最核心的思想。总结一下，就是其核心要点为：

新建一个栈，然后逐个遍历集合中的元素，如果栈为空或该元素大于栈顶元素，则该元素入栈；否则让栈中的元素不停地出栈，直到栈顶元素小于该元素时，该元素入栈。

2. 计算子集中的所有元素之和

这就是上文中绿字标注的问题，我们之前刻意回避了，蓝色的公式都涉及到了它的计算，现在我们来思考一下它们时怎么被计算出来的。

我们以元素2出栈时的情况为例，2对应的子集为 { 3 , 4 , 2 , 6 , 5 } \{\color{blue}3, \color{blue}4, \color{red}2, \color{green}6, \color{green}5 \} {3,4,2,6,5}，其中3和4位于2的左侧，5和6位于2的右侧。集合中所有元素之和=当前元素+右侧元素之和+左侧元素之和。我们用temp_sum来表示。

右侧元素之和很好计算。2的右侧元素集合 { 6 , 5 } \left\{\color{green}6, \color{green}5\right\} {6,5}，正是5对应的元素集合，而2的出栈一定是紧跟在5出栈之后的，所以2右侧元素之和=5的temp_sum。

左侧元素之和没那么容易计算了。但事实上，左侧元素构成的集合 { 3 , 4 } \left\{\color{blue}3, \color{blue}4\right\} {3,4}单独拿出来，正是元素3对应的集合，而这个集合元素之和在前面元素3出栈时计算过它的temp_sum了。只要我们当时把这个temp_sum保存下来，现在就可以直接使用了。

因此我们再多新建一个栈leftsum_stack。leftsum_stack的元素和前面的栈（为了区分我将前面用到的栈命名为stack）的元素是一一对应的，leftsum_stack中的某个元素代表stack中对应位置的元素的左边元素之和。stack有元素进栈时leftsum_stack也进栈，stack有元素出栈时leftsum_stack也出栈。

因此，每当有元素进栈时，temp_sum还表示上一轮的出栈元素对应集合的所有元素之和，leftsum_stack也压入当前状态下的temp_sum。

因此有：

temp_sum = 0;
while(遍历集合) {
  if(stack为空 or 当前元素>=stack栈顶元素) {
    //说明当前元素的左边界到stack栈顶元素就截止了
    //此时的temp_sum的值表示当前元素的左侧所有元素之和

    当前元素入栈stack;
    temp_sum入栈leftsum_stack;

    temp_sum = 0;
      //无论下一个遍历的是什么样的元素，
      //它的左边界都一定是现在这个栈顶元素，temp_sum要从0开始记起

    移动到下一个元素;
  }
  else { //此时当前元素 < stack栈顶元素

    temp_sum = stack栈顶元素 + leftsum_stack栈顶元素+temp_sum;
      //翻译一下就是：当前元素对应的集合元素之和 = 当前元素 + 左侧元素之和 + 右侧元素之和

    计算stack栈顶元素*temp_sum，并与之前循环得到的结果进行比较，取最大值
    stack出栈
    leftsum_stack出栈
  }
}

3. 得到代码

至此，所有推理都完成了，上面的例子的运行过程如下图。

然后就是激动人心的写代码时间了！

#include <stdio.h>
#include <stack>
using namespace std;

int main() {
    int N;
    scanf("%d", &N);
    int set[N + 1];
    for (int i = 0; i < N; i++)
        scanf("%d", &set[i]);
    set[N] = 0; //在集合末尾多添加一个元素，设置为0，在栈的操作中会用到
    
    stack<int> st;
    int i = 0;
    int temp_sum = 0; //当前子集的和
    stack<int> leftsum_stack;
    int max_result = 0;
    while (i <= N) {
        if (st.empty() || set[i] >= st.top()) { //如果栈为空或该元素大于栈顶元素
            st.push(set[i]); //让当前元素入栈
            leftsum_stack.push(temp_sum);
            temp_sum = 0;
            i++;
        }
        else { //当前元素小于栈顶元素
            temp_sum = st.top() + leftsum_stack.top() + temp_sum;
            if (temp_sum * st.top() > max_result)
                max_result = temp_sum * st.top();
            st.pop();
            leftsum_stack.pop();
        }
    }
    printf("%d", max_result);
    return 0;
}

全部AC。

最后，感谢无私分享自己解题方法的大佬们和愿意把这篇罗里吧嗦的文章阅读到最后的你，如果哪里有错误，欢迎指出。最后，努力的人运气通常都不会太差！

这篇文章写起来不易，如果它对你有帮助的话，麻烦给个赞吧！！