bnuoj 27411 数据结构维护区间RMQ

很显然n方的复杂度过不了。

于是考虑优化最值的查询，可以考虑用堆或者单调队列来做。

堆：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;

const int INF = 99999999;
const int N = 32768;
int a[N];
int n, l, u;

struct Node
{
    int l;
    int s;
    Node () {}
    Node ( int _l, int _s )
    {
        l = _l;
        s = _s;
    }
    bool operator < ( const Node & t ) const
    {
        return s < t.s;
    }
};

int solve()
{
    priority_queue<Node> q;
    int ans = INF;
    for ( int i = l; i <= n; i++ )
    {
        q.push( Node ( i - l, a[i - l] ) );
        while ( q.top().l + u < i ) q.pop();
        int tmp = a[i] - q.top().s;
        if ( tmp < ans ) ans = tmp;
    }
    return ans;
}

int main()
{
    while ( scanf("%d", &n), n )
    {
        scanf("%d%d", &l, &u);
        a[0] = 0;
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%d", a + i);
            a[i] += a[i - 1];
        }
        printf("%d
", solve());
    }
    return 0;
}

单调队列：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <queue>
using namespace std;

const int INF = 99999999;
const int N = 32768;
int a[N];
int n, l, u;
int head, tail;

struct Node
{
    int l, s;
} q[N];

int solve()
{
    int ans = INF;
    head = tail = 0;
    for ( int i = l; i <= n; i++ )
    {
        while ( head < tail && a[i - l] > q[tail - 1].s )
        {
            tail--;
        }
        q[tail].l = i - l, q[tail].s = a[i - l];
        tail++;
        while ( q[head].l + u < i ) head++;
        int tmp = a[i] - q[head].s;
        if ( tmp < ans ) ans = tmp;
    }
    return ans;
}

int main()
{
    while ( scanf("%d", &n), n )
    {
        scanf("%d%d", &l, &u);
        a[0] = 0;
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%d", a + i);
            a[i] += a[i - 1];
        }
        printf("%d
", solve());
    }
    return 0;
}

 块状链表：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
using namespace std;

const int INF = 999999999;
const int N = 32768;
const int M = 500;
int a[N];
int n, tot;
int ps;
int lower, upper;

int max( int a, int b )
{
    return a > b ? a : b;
}

int min( int a, int b )
{
    return a < b ? a : b;
}

struct Block
{
    int num[M];
    int size, maxn;
    void init()
    {
        size = 0;
        maxn = -INF;
    }
    void push( int tmp )
    {
        num[size++] = tmp;
        if ( tmp > maxn ) maxn = tmp;
    }
} bl[M];

int query( int l, int r )
{
    l++, r++;
    int cur = 0, ncur = 0;
    while ( l > ps )
    {
        l -= ps;
        cur++;
    }
    while ( r > ps )
    {
        r -= ps;
        ncur++;
    }
    int ans = -INF;
    for ( int i = cur + 1; i <= ncur - 1; i++ )
    {
        ans = max( ans, bl[i].maxn );
    }
    if ( cur == ncur )
    {
        for ( int j = l - 1; j < r; j++ )
        {
            ans = max( ans, bl[cur].num[j] );
        }
    }
    else
    {
        for ( int j = l - 1; j < bl[cur].size; j++ )
        {
            ans = max( ans, bl[cur].num[j] );
        }
        for ( int j = 0; j < r; j++ )
        {
            ans = max( ans, bl[ncur].num[j] );
        }
    }
    return ans;
}

int main()
{
    while ( scanf("%d", &n), n )
    {
        scanf("%d%d", &lower, &upper);
        a[0] = 0;
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%d", a + i);
            a[i] += a[i - 1];
        }
        tot = 0;
        bl[tot].init();
        ps = sqrt((double)n);
        for ( int i = 0; i <= n; i++ )
        {
            if ( bl[tot].size == ps )
            {
                tot++;
                bl[tot].init();
            }
            bl[tot].push(a[i]);
        }
        int ans = INF;
        for ( int i = lower; i <= n; i++ )
        {
            int qq = query( max( i - upper, 0 ), i - lower );
            ans = min( ans, a[i] - qq );
        }
        printf("%d
", ans);
    }
    return 0;
}

还可以用线段树或者RMQ的ST算法，解法实在是太多了。