【BZOJ】1012 最大数

题目

维护一个数列，两种操作：
1. 查询操作
语法：Q L
功能：查询当前数列中末尾L个数中的最大的数，并输出这个数的值。
限制：L不超过当前数列的长度。
2. 插入操作
语法：A n
功能：将n加上t，其中t是最近一次查询操作的答案（如果还未执行过查询操作，则t=0)，并将所得结果对一个固定的常数D取模，将所得答案插入到数列的末尾。
限制：n是非负整数并且在长整范围内。
注意：初始时数列是空的，没有一个数。

$M\leq 200000$

分析

解法1：线段树

区间最值，考虑直接用线段树来维护。

时间复杂度：$O(n\log n)$
空间复杂度：$O(n\log n)$

代码：$904ms$

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <climits>
using namespace std;

const int M=200001;
const int L=INT_MAX;
const int P=INT_MIN;

int m,d,q[M][2],qa;
struct SegmentTree
{
    int l,r,mx;
}tr[M<<2];
int lst;

inline int read(void)
{
    int s=0,f=1; char c=getchar();
    for (;c<'0'||c>'9';c=getchar()) if (c=='-') f=-1;
    for (;'0'<=c&&c<='9';c=getchar()) s=(s<<1)+(s<<3)+c-'0';
    return s*f;
}

void build(int now,int l,int r)
{
    tr[now].l=l;
    tr[now].r=r;
    tr[now].mx=L;
    if (l^r)
    {
        int mid=l+r>>1;
        build(now<<1,l,mid);
        build(now<<1|1,mid+1,r);
    }
}

inline int max(int i,int j)
{
    return i>j?i:j;
}

void ins(int now,int loc,int w)
{
    if (tr[now].l==tr[now].r) {tr[now].mx=w;return;}
    int mid=tr[now].l+tr[now].r>>1;
    ins(now<<1|(loc<=mid?0:1),loc,w);
    tr[now].mx=max(tr[now<<1].mx,tr[now<<1|1].mx);
}

int query(int now,int l,int r)
{
    if (l<=tr[now].l&&tr[now].r<=r) return tr[now].mx;
    int mx=P,mid=tr[now].l+tr[now].r>>1;
    if (l<=mid) mx=max(mx,query(now<<1,l,r));
    if (mid<r) mx=max(mx,query(now<<1|1,l,r));
    return mx;
}

int main(void)
{   
    char c;
    m=read(),d=read();
    for (int i=1;i<=m;i++)
    {
        scanf("\n%c",&c);
        if (c=='A') qa++; else q[i][0]=1;
        q[i][1]=read();
    }

    build(1,1,qa),qa=0;
    for (int i=1;i<=m;i++)
        if (!q[i][0])
            ins(1,++qa,(lst+q[i][1])%d);
        else printf("%d\n",lst=query(1,qa-q[i][1]+1,qa));

    return 0;
}

解法2：ST表

静态区间求最值，我们考虑使用ST表。
注意这里的ST表，我们用$mx[i][j]$表示$j-2^i$到$j$的最值，而不是$j$到$j+2^i$的最值，这样可以做到一次更新的时间复杂度为$O(\log n)$。

操作1：直接查询，$O(1)$；
操作2：直接更新，$O(\log n)$；

时间复杂度：$O(n\log n)$
空间复杂度：$O(n\log n)$

代码：$456ms$

#include <cstdio>
#include <cmath>
#include <cctype>
#include <algorithm>
using namespace std;

const int N=200000;
const int U=20;

int m,d;

int n;
int unit;
int mx[U][N];

inline int read(void)
{
    int x=0; char c=getchar();
    for (;!isdigit(c);c=getchar());
    for (;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x;
}

int main(void)
{
    m=read(),d=read();
    unit=(int)(log(m)/log(2));

    int t=0; char c; int x; int p;
    for (int cc=1;cc<=m;cc++)
    {
        scanf("\n"); c=getchar(); x=read();
        if (c=='A')
        {
            mx[0][++n]=(x+t)%d;
            for (int i=1;i<=unit;i++)
                mx[i][n]=max(mx[i-1][n],mx[i-1][max(1,n-(1<<i-1))]);
        }
        else
        {
            p=(int)(log(x)/log(2));
            printf("%d\n",t=max(mx[p][n],mx[p][n-x+(1<<p)]));
        }
    }

    return 0;
}

解法3：单调队列+二分

解法1中，我们只是利用了区间最值，还没有利用到求末$k$个最值的特殊性。

对于相同的末尾，我们设$mx_i$表示$i$到$n$中的最值，很明显，$mx$具有单调性。

$mx_i$的值改变当且仅当出现$a_i>mx_{i+1}$，我们只用记录所有可能导致改变的值$a_i$就可以了。

我们维护一个单调队列。
对于操作1，我们在单调队列中二分查找，找到在$k$以后的最后一个数；
对于操作2，只需要将新的数加入队列中，并将之前的比它小的数去掉。

时间复杂度：$O(n\log n)$
空间复杂度：$O(n)$

虽然复杂度一样，但是算法的常数就小多了。

代码：$364ms$

#include <cstdio>
#include <cstring>
#include <cstdlib>
using namespace std;

const int M=200010;

int m,d,lst;
struct Q
{
    int w,loc;
}q[M];
int h,t,ca;


inline int read(void)
{
    int s=0,f=1; char c=getchar();
    for (;c<'0'||c>'9';c=getchar()) if (c=='-') f=-1;
    for (;'0'<=c&&c<='9';c=getchar()) s=(s<<1)+(s<<3)+c-'0';
    return s*f;
}

int main(void)
{   
    char c; int x;
    m=read(),d=read(),h=1;

    for (int i=1;i<=m;i++)
    {
        scanf("\n%c",&c),x=read();
        if (c=='A')
        {
            x=(x+lst)%d,ca++;
            for (;h<=t&&x>=q[t].w;t--);
            q[++t].w=x,q[t].loc=ca;
        }
        else
        {
            int l=h,r=t,mid;
            for (;l<=r;)
            {
                mid=l+r>>1;
                ca-q[mid].loc+1<=x?r=mid-1:l=mid+1;
            }
            printf("%d\n",lst=q[l].w);
        }
    }

    return 0;
}