[poj 2796 Feel Good] 单调栈

[poj 2796 Feel Good] 单调栈

题目链接：[poj 2796 Feel Good] 单调栈
题意描述：给定N个数$a_1,a_2,\ldots,a_n(1\le N\le 10^5, 0\le a_i\le 10^6)$,求区间最小的数*区间和。
解题思路：

单调栈: 顾名思义就是在入栈时遵循单调原则，可以求出一个元素向左（或向右）所能扩展到的最大长度，并不是说在这一段区间内是单调的，而是保证在该区间内该元素一定是最大或最小；
单调栈主要是大家要自己枚举，需要找到每个元素最左能扩展到那 ，最优能扩展到那，当然最小的是你枚举的那个元素。
我们有如下的性质：
1. 如果当前元素大于前一元素，那么前一元素能扩展到当前元素，同时说明前面的数对当前元素来说是没有贡献的
2。如果当前元素等于前一元素，那么前一元素也能扩展到当前元素，同时说明前面的元素是可以被忽略的
3。如果当前元素小于前一个元素，那么前面至少有一个元素不能扩展到当前元素的位置，那么这些不能继续扩展的元素的存在显的没有什么意义了，不妨删除它。
我们得到两条结论：
1。一旦一个元素已经进入栈中那么这个元素向左扩展的位置就确定下来了.
2。一旦一个元素出栈被弹出栈,那么这个元素向右扩展的位置也确定下来了.

很容易想到暴力一点的方法，枚举每一个点，然后以该点为最小值向右，向左拓展区间。可是这样的复杂度会到$O(N^2)$…
想一下怎么优化，其实我们发现暴力的方法很有很多次重复计算。
创建一个单调递减栈，每次入栈的元素比栈顶元素大，弹出栈顶元素，那么栈顶元素能够向后能拓展的最长区间就是当前入栈的元素的前一个。这样就求出了右区间。
然后，对序列逆序操作一遍，就能够求出左区间了。
最后，枚举每个点，统计最大值就行了。

#include <stack>
#include <queue>
#include <cmath>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

//#pragma comment(linker, "/STACK:1024000000,1024000000")

#define FIN             freopen("input.txt","r",stdin)
#define FOUT            freopen("output.txt","w",stdout)
#define fst             first
#define snd             second

typedef __int64 LL;
//typedef long long LL;
typedef pair<int, int> PII;

const int MAXN = 100000 + 5;
const int INF = 0x3f3f3f3f;
int N;
int A[MAXN], L[MAXN], R[MAXN];
LL pre[MAXN];
struct SNode {
    int id, val;
    SNode () {}
    SNode (int id, int val) : id (id), val (val) {}
} tp;
stack<SNode> stk;
int main() {
#ifndef ONLINE_JUDGE
    FIN;
#endif // ONLINE_JUDGE
    while (~scanf ("%d", &N) ) {
        int P = 0;
        pre[0] = 0;
        for (int i = 1; i <= N; i++) {
            scanf ("%d", &A[i]);
            pre[i] = pre[i - 1] + A[i];
        }
        for (int i = 1; i <= N; i++) {
            while (!stk.empty() && stk.top().val > A[i]) {
                tp = stk.top();
                R[tp.id] = i - 1;
                stk.pop();
            }
            stk.push (SNode (i, A[i]) );
        }
        while (!stk.empty() ) {
            tp = stk.top();
            R[tp.id] = N;
            stk.pop();
        }
        for (int i = N; i >= 1; i--) {
            while (!stk.empty() && stk.top().val > A[i]) {
                tp = stk.top();
                L[tp.id] = i + 1;
                stk.pop();
            }
            stk.push (SNode (i, A[i]) );
        }
        while (!stk.empty() ) {
            tp = stk.top();
            L[tp.id] = 1;
            stk.pop();
        }
        LL ans = -1;
        int l, r;
        for (int i = 1; i <= N; i++) {
            LL x = (LL) (pre[R[i]] - pre[L[i] - 1]) * A[i];
            if (x >= ans) {
                ans = x, l = L[i], r = R[i];
            }
        }
        printf ("%I64d\n%d %d\n", ans, l, r);
    }
    return 0;
}