洛谷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：

输出样例#1：

说明

[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分