【BZOJ】1012 最大數

題目

維護一個數列，兩種操作：
1. 查詢操作
語法：Q L
功能：查詢當前數列中末尾L個數中的最大的數，並輸出這個數的值。
限制：L不超過當前數列的長度。
2. 插入操作
語法：A n
功能：將n加上t，其中t是最近一次查詢操作的答案（如果還未執行過查詢操作，則t=0)，並將所得結果對一個固定的常數D取模，將所得答案插入到數列的末尾。
限制：n是非負整數並且在長整範圍內。
注意：初始時數列是空的，沒有一個數。

M≤200000

分析

解法1：線段樹

區間最值，考慮直接用線段樹來維護。

時間複雜度：O(nlogn)
空間複雜度：O(nlogn)

代碼：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−2i 到j 的最值，而不是j 到j+2i 的最值，這樣可以做到一次更新的時間複雜度爲O(logn) 。

操作1：直接查詢，O(1) ；
操作2：直接更新，O(logn) ；

時間複雜度：O(nlogn)
空間複雜度：O(nlogn)

代碼：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 個最值的特殊性。

對於相同的末尾，我們設mxi 表示i 到n 中的最值，很明顯，mx 具有單調性。

mxi 的值改變當且僅當出現ai>mxi+1 ，我們只用記錄所有可能導致改變的值ai 就可以了。

我們維護一個單調隊列。
對於操作1，我們在單調隊列中二分查找，找到在k 以後的最後一個數；
對於操作2，只需要將新的數加入隊列中，並將之前的比它小的數去掉。

時間複雜度：O(nlogn)
空間複雜度：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;
}