UVA - 1619 Feel Good（高效算法：滑动窗口）

    题意大致是从一个数列里找一个最短的子序列，使得这个子序列的最小值乘这个子序列的和最大。

    这道题最关键的地方是找到数列中的某个数在哪个连续序列里是最小的，即这个数的统治区域，一开始我想到的就是输入完之后重新遍历数列，向前向后遍历找第一个比它大的，但是总是感觉会超时，于是我想到了另一种方法，滑动窗口，就可以在输入数据的时候同时找到这个数的的统治区域，即仅仅遍历一遍数组，分析如下：

    滑动窗口的精髓是在一个数列里保存着一个递增数列，同时这个数列维持了它在原数列的位次递增，这个窗口里保存的第一个数即在这个区间里最小的数。这样不停得把新输入的数同这个滑动窗口里右边的数比较，如果比它大，删除窗口里的这个数，同时删除的数统治区域的最右边就是新输入的数，它的左统治区域即新输入的数的左统治区域，然后不停地向窗口的左边比。这样只需要一个数组记录它左边区域的边界就可以了，而它的右边界即是在滑动数组里删除的时候。

    我语文学得不好，表述可能不太清楚，我把样例用图解释一下：

    差不多就是这样。最后说一件事，我看到另一个人写的代码，就是一开始那个分别向两头遍历找边界的方法，其实速度不比这个慢多少，可能是我的代码优化的问题，大家有兴趣可以自己写一下。下面给出我写的代码：

#include <bits/stdc++.h>
using namespace std;
const int maxn = 1001000;
int A[maxn],T,m,n,f[maxn],q[maxn][2];
long long B[maxn],sum;
int main(){
    bool qwe = false;
    while (scanf("%d",&T) != EOF){
        B[0] = 0;sum = -1;
        q[0][0] = 100000000;q[0][1] = 1;
        f[1] = 1;
        int rear = 0;
        for (int i  = 1 ;i <= T;++i){
            scanf("%d",&A[i]);
            B[i] = B[i-1] + A[i];
            while (rear >= 0 && A[i] <= q[rear][0]) {
                int k = q[rear][1];
                long long s = (B[i-1] - B[f[k]-1]) * A[k];
                if (s > sum || (s == sum && fabs(n-m) > i-1-f[k])){
                    sum = s;
                    m = f[k];
                    n = i-1;
                }
                f[i] = f[k];
                rear--;
            }
            if (rear >= 0) f[i] = q[rear][1]+1;
            ++rear;
            q[rear][0] = A[i];
            q[rear][1] = i;
        }
        while (rear >= 0){
            int k = q[rear][1];
            long long s= (B[T] - B[f[k]-1]) * A[k];
            if (s > sum || (s == sum && fabs(n-m) > T-f[k])){
                sum = s;
                m = f[k];
                n = T;
            }
            rear--;
        }
        if (qwe) printf("\n");
        else qwe = true;
        printf("%lld\n%d %d\n",sum,m,n);
    }
    return 0;
}