洛谷P1198 [JSOI2008]最大数（BZOJ.1012 ）

To 洛谷.1198 最大数

题目描述

现在请求你维护一个数列，要求提供以下两种操作：

1、 查询操作。

语法：Q L

功能：查询当前数列中末尾L个数中的最大的数，并输出这个数的值。

限制：L不超过当前数列的长度。

2、 插入操作。

语法：A n

功能：将n加上t，其中t是最近一次查询操作的答案（如果还未执行过查询操作，则t=0)，并将所得结果对一个固定的常数D取模，将所得答案插入到数列的末尾。

限制：n是整数（可能为负数）并且在长整范围内。

注意：初始时数列是空的，没有一个数。

输入输出格式

输入格式：

第一行两个整数，M和D，其中M表示操作的个数(M <= 200,000)，D如上文中所述，满足(0<D<2,000,000,000)

接下来的M行，每行一个字符串，描述一个具体的操作。语法如上文所述。

输出格式：

对于每一个查询操作，你应该按照顺序依次输出结果，每个结果占一行。

输入输出样例

输入样例#1：

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

输出样例#1：

96
93
96

说明

[JSOI2008]

思路：

　　1.线段树。在初始建树时将所有节点赋值为-INF，操作和单点修改与区间最值并没有多少不同。

　　2.单调队列+二分查找。

代码：

1.线段树  722ms/17.06MB，比方法2要慢近一倍。

 #include<cstdio>
 #include<algorithm>
 #define LL long long
 using namespace std;
 const int N=,INF=1e9+;

 int m,mod,len;
 LL t,Max[N<<];

 void read(int &now)
 {
     now=;bool f=;char c=getchar();
     while(c<''||c>'')
     {
         if(c=='-')f=;
         c=getchar();
     }
     while(c>=''&&c<='')now=(now<<)+(now<<)+c-'',c=getchar();
     now= f?-now:now;
 }

 void PushUp(int rt)
 {
     Max[rt]= Max[rt<<]<Max[rt<<|]?Max[rt<<|]:Max[rt<<];
 }

 void Build(int l,int r,int rt)
 {
     if(l==r)
     {
         Max[rt]=-INF;
         return;
     }
     int m=(l+r)>>;
     Build(l,m,rt<<);
     Build(m+,r,rt<<|);
     PushUp(rt);
 }

 void ModifyPoint(int l,int r,int rt,int p,int v)
 {
     if(l==r)
     {
         Max[rt]= Max[rt]<v?v:Max[rt];
         return;
     }
     int m=(l+r)>>;
     if(p<=m) ModifyPoint(l,m,rt<<,p,v);
     else ModifyPoint(m+,r,rt<<|,p,v);
     PushUp(rt);
 }

 LL QueryMax(int l,int r,int rt,int L,int R)
 {
     if(L<=l && r<=R) return Max[rt];
     int m=(l+r)>>;
     LL res=-INF;
     if(L<=m) res=max(res,QueryMax(l,m,rt<<,L,R));
     if(m<R) res=max(res,QueryMax(m+,r,rt<<|,L,R));
     return res;
 }

 int main()
 {
     read(m);read(mod);
     Build(,m,);
     for(int i=;i<=m;++i)
     {
         char opt[];int num;
         scanf("%s",opt);read(num);
         if(opt[]=='A')
           ModifyPoint(,m,,++len,(num+t)%mod);
         else
           printf("%lld\n",t=QueryMax(,m,,len-num+,len));
     }
     return ;
 }

线段树（插入元素 区间最值）

2.单调队列+lower_bound（+栈） 337ms/12.6MB

（先写 if(opt[0]=='Q')+询问 后写插入 就会错是什么鬼。。 哪位dalao看出来帮我指出一下。。thanks）

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 const int N=;

 int m,mod,len,size,t,Num[N],Stack[N];

 void read(int &now)
 {
     now=;bool f=;char c=getchar();
     while(c<''||c>'')
     {
         if(c=='-')f=;
         c=getchar();
     }
     while(c>=''&&c<='')now=(now<<)+(now<<)+c-'',c=getchar();
     now= f?-now:now;
 }

 /*int Mylower_bound(int s,int t,int p)
 {
     int l=s,r=t,m;
     while(l<r)
     {
         m=(l+r)>>1;
         if(Stack[m]<p)
           l=m+1;
         else if(Stack[m]==p)
           return m;
         else
           r=m;
     }
     return l;
 }*/

 int main()
 {
     read(m);read(mod);
     char opt[];int a;
     while(m--)
     {
         scanf("%s",opt);read(a);
         if(opt[]=='A')
         {//因为比当前元素小的数在最后的求最大值中毫无作用，所以直接弹出
             a=(a+t)%mod;
             Num[++len]=a;
             while(size && Num[Stack[size]]<=a)
               --size;
             Stack[++size]=len;
         }
         else
         {//Stack[i]存储的是一个位置pos，且这些位置单调递增，这些位置对应的Num[pos]也单调递增
             int pos=lower_bound(Stack+,Stack+size+,len-a+)-Stack;//找出一个Stack中大于等于查询位置的pos
             //int pos=Mylower_bound(1,size,len-a+1);
             printf("%d\n",t=Num[Stack[pos]]);
         }
     }
     return ;
 }

单调队列

错误的写法

 #include<cstdio>
 #include<algorithm>
 using namespace std;
 const int N=;

 int m,mod,len,size,t,Num[N],Stack[N];

 void read(int &now)
 {
     now=;bool f=;char c=getchar();
     while(c<''||c>'')
     {
         if(c=='-')f=;
         c=getchar();
     }
     while(c>=''&&c<='')now=(now<<)+(now<<)+c-'',c=getchar();
     now= f?-now:now;
 }

 int main()
 {
     read(m);read(mod);
     char opt[];int a;
     while(m--)
     {
         scanf("%s",opt);read(a);
         if(opt[]=='Q')
         {//Stack[i]存储的是一个位置，且这些位置单调递增，这些位置对应的Num[pos]也单调递增
             int pos=lower_bound(Stack+,Stack+size+,len-a+)-Stack;
             printf("%d\n",t=Num[pos]);
         }
         else
         {//因为比当前元素小的数在最后的求最大值中毫无作用，所以直接弹出
             a=(a+t)%mod;
             Num[++len]=a;
             while(size && Num[Stack[size]]<=a)
               --size;
             Stack[++size]=len;
         }
     }
     return ;
 }

0分