大视野 1012: [JSOI2008]最大数maxnumber（线段树/ 树状数组/ 单调队列/ 单调栈/ rmq）

1012: [JSOI2008]最大数maxnumber

Time Limit: 3 Sec  Memory Limit: 162 MB
Submit: 9851  Solved: 4318
[Submit][Status][Discuss]

Description

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

Input

　　第一行两个整数，M和D，其中M表示操作的个数(M <= 200,000)，D如上文中所述，满足D在longint内。接下来
M行，查询操作或者插入操作。

Output

　　对于每一个询问操作，输出一行。该行只有一个数，即序列中最后L个数的最大数。

Sample Input

5 100
A 96
Q 1
A 97
Q 1
Q 2

Sample Output

96
93
96

HINT

　　数据如下http://pan.baidu.com/s/1i4JxCH3

Source

线段树

#include <bits/stdc++.h>
using namespace std;

#define L(root) ((root) << 1)
#define R(root) (((root) << 1) | 1)

const int MAXN = 200000 + 5;
int numbers[MAXN];

struct Node {
    int left, right;
    //int sum;//
    int mx;//最大值
    int mid()
    {
        return left + ((right - left) >> 1);
    }
} tree[MAXN * 4];

void pushUp(int root)
{
//    tree[root].sum = tree[L(root)].sum + tree[R(root)].sum;
    tree[root].mx = max(tree[L(root)].mx, tree[R(root)].mx);
}

void build(int root, int left, int right)
{
    tree[root].left = left;
    tree[root].right = right;
    if (left == right) {
//        tree[root].sum = numbers[left];
        tree[root].mx = 0;
        return;
    }
    int mid = tree[root].mid();
    build(L(root), left, mid);
    build(R(root), mid + 1, right);
    pushUp(root);
}

int query(int root, int left, int right)
{
    if (tree[root].left == left && tree[root].right == right) {
//        return tree[root].sum;
        return tree[root].mx;
    }
    int mid = tree[root].mid();
    if (right <= mid) {
        return query(L(root), left, right);
    } else if (left > mid) {
        return query(R(root), left, right);
    } else {
        //return query(L(root), left, mid) + query(R(root), mid + 1, right);
        //注意返回最大值...
        int lv = query(L(root), left, mid);
        int rv = query(R(root), mid + 1, right);
        return lv > rv ? lv : rv;
    }
}

void update(int root, int pos, int add)
{
    if (tree[root].left == tree[root].right) {
        //tree[root].sum = tree[root].sum + add;
        tree[root].mx = add;
        return;
    }
    int mid = tree[root].mid();
    if (pos <= mid) {
        update(L(root), pos, add);
    } else {
        update(R(root), pos, add);
    }
    pushUp(root);
}

void test01()
{
    memset(numbers, 0, sizeof(numbers));
    int i;
    for (i = 1; i < MAXN; ++i) {
        numbers[i] = i;
    }
    build(1, 1, 10);
    printf("%d
", query(1, 2, 3));
    update(1, 2, 100);
    printf("%d
", query(1, 2, 3));
}

int main()
{
    //test01();

    int M, D;
    char str[2];
    int x;
    int i;
    int t;
    int len;//当前长度

    while (~scanf("%d%d", &M, &D)) {
        build(1, 1, M);

        t = 0;
        len = 0;
        for (i = 0; i < M; ++i) {
            scanf("%1s%d", str, &x);
            if (str[0] == 'Q') {
                t = query(1, len - x + 1, len);
                printf("%d
", t);
            } else {
                update(1, ++len, (x + t) % D);
            }
        }
    }

    return 0;
}

树状数组（代码好难理解，日后再看）

区间最值其实和区间求和差不多，就是将sum数组的含义转移到max，然后通过特定的区间更新max。

在区间求和中，当我们维护max[i]的时候，要找到它前面所有的max[j]来更新，在这里因为是树状数组，所以可以降成一个log级，画图可知，max[i]需要的max只有max[i-2^0],max[i-2^1],max[i-2^2]..max[i-lowbit(i)+1]

更新操作简单，即

void change(int r) {
    c[r]=num[r];
    for(int i=1; i<lowbit(r); i<<=1)
        c[r]=max(c[r], c[r-i]);
}
接下来是求区间最值，很容易看出，我们找[l,r]的最值就是找在次区间的max，即递减r，在这里可以有个优化，即当找到一个max[i]，有i-lowbit(i)>=l时，更新后，i直接-=lowbit(i)，然后继续递减。当l>=r就跳出循环

int getk(int l, int r) {
    int ret=num[r];
    while(l<=r) {
        ret=max(ret, num[r]);
        for(--r; r-l>=lowbit(r); r-=lowbit(r))
            ret=max(ret, c[r]);
    }
    return ret;
}
其实在这里更新操作可以和区间最值放在一起，(现在用c代表max)即c[i]=max(getk(i-lowbit(i)+1, i), num[i]);

#include <cstdio>
using namespace std;
#define lowbit(x) (x&-x)
#define max(a,b) ((a)>(b)?(a):(b))
const int N=200005;
int num[N], c[N], cnt;
int getk(int l, int r) {
    int ret=num[r];
    while(l<=r) {
        ret=max(ret, num[r]);
        for(--r; r-l>=lowbit(r); r-=lowbit(r))
            ret=max(ret, c[r]);
    }
    return ret;
}

int main() {
    int n, d, t=0, a;
    char ch[3];
    scanf("%d%d", &n, &d);
    while(n--) {
        scanf("%s%d", ch, &a);
        if(ch[0]=='A') {
            num[++cnt]=(t+a)%d;
            c[cnt]=max(getk(cnt-lowbit(cnt)+1, cnt-1), num[cnt]);
        }
        else {
            printf("%d
", t=getk(cnt-a+1, cnt));
        }
    }
    return 0;
}

单调递减队列/ 单调递增栈

#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <climits>
#define N 1000000
#define INF INT_MAX

using namespace std;

//单调递减队列, [队首, 队尾], [3, 2, 1], 队列中存下标
//单调递增栈, [栈底, 栈顶], [3, 2, 1]
int q[N],m,d,h=1,t=1,num;
int val[N],ans;

//二分找到x后面第一个数
inline int getans(int x)
{
    int l=h,r=t-1,mid,res;
    while(l<=r)
    {
        mid=(l+r)>>1;
        if(x<=q[mid]) res=mid,r=mid-1;
        else l=mid+1;
    }
    return q[res];
}

inline void go()
{
    scanf("%d%d",&m,&d);
    int a;
    char str[10];
    while(m--)
    {
        scanf("%s%d",str,&a);
        if(str[0]=='A')
        {
            val[++num]=(a+ans)%d;
            while(h<t&&val[q[t-1]]<=val[num]) t--;
            q[t++]=num;
        }
        else
        {
            //二分
            ans=val[getans(num-a+1)];
            printf("%d
",ans);
        }
    }
}

int main()
{
    go();
    return 0;
}

下面的代码比较挫了，如果输入序列递增，估计要超时。辅助理解单调队列思想。

//qscqesze
#include <cstdio>
#include <cmath>
#include <cstring>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>
#include <sstream>
#include <queue>
#include <typeinfo>
#include <fstream>
#include <map>
typedef long long ll;
using namespace std;
//freopen("D.in","r",stdin);
//freopen("D.out","w",stdout);
#define sspeed ios_base::sync_with_stdio(0);cin.tie(0)
#define maxn 250001
#define eps 1e-9
const int inf=0x7fffffff;   //无限大 
//**************************************************************************************
int a[maxn],max_num[maxn],t=0,ans=0;
int main()
{
    int n,d;
    scanf("%d%d",&n,&d);
    char ch[3];
    int g;
    while(n--)
    {
        scanf("%s%d",ch,&g);
        if(ch[0]=='A')
        {
            a[++t]=(ans+g)%d;
            for(int i=t;i;i--)
            {
                if(max_num[i]<a[t])
                    max_num[i]=a[t];
                else
                    break;
            }
        }
        else
        {
            ans=max_num[t-g+1];
            printf("%d
",ans);
        }
    }
    return 0;
}

rmq（我写的这个速度有点捉急...）

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 200000 + 5;
int mx[MAXN][20];
int num[MAXN];
int tot;

void update()
{
    mx[tot][0] = num[tot];
    int k1 = log2(tot);
    int k2;
    int i, j;
    for (j = 1; j <= k1; ++j) {
        k2 = tot - pow(2, j) + 1;
        for (i = k2; i <= k2; ++i) {
            mx[i][j] = max(mx[i][j - 1], mx[i + (int)pow(2, j - 1)][j - 1]);
        }
    }
}

int rmq(int i, int j)
{
    int k = log2(j - i + 1);
    return max(mx[i][k], mx[j - (int)pow(2, k) + 1][k]);
}

int main()
{
    int M, D;
    char str[2];
    int x;
    int i;
    int t;

    while (~scanf("%d%d", &M, &D)) {
        tot = 0;
        t = 0;
        for (i = 0; i < M; ++i) {
            scanf("%1s%d", str, &x);
            if (str[0] == 'Q') {
                t = rmq(tot - x + 1, tot);
                printf("%d
", t);
            } else {
                num[++tot] = (x + t) % D;
                update();
            }
        }
    }

    return 0;
}