bzoj2011: [Ceoi2010]Mp3 Player

Description

Georg有个MP3 Player，没有任何操作T秒钟就会锁定，这时按下任意一个键就会变回没锁定的状态，但不会改变频道。只有在没锁定的状态下按键才有可能改变频道。 MP3的频道为0~Vmax(2<=Vmax<=5000)，如果现在是X频道，若X<>Vmax,在无锁状态下按+，X就会加1。若X<>0,在无锁状态下按-，X就会减一。 想在Georg忘记了MP3的T是多少。他想通过一段操作试验一下。然后他就写下他的操作顺序和最后停留的频道V2(0<=V2<=Vmax),然后就给你了，你要求的是T的最大值和T在这个值的情况下，第一个操作前的频道V1的最大可能数。若T为无限大时经过这段操作最后能停在V2，则输出infinity。

Input

第1行：N，Vmax，V2 N表示Georg操作了N次(2<=N<=100000); 以下N行，每行第一个为字符C(C为'+'或'-')，第二个为数字Ti(0<=Ti<=10^9)， 表示Georg在Ti秒按下了C键。

Output

如题所述。

Sample Input

6 4 3
- 0
+ 8
+ 9
+ 13
- 19
- 24

Sample Output

5 4

题解：

这题肯定要从大到小枚举T，判断这时有效的操作能否有解

判断能否有解有两种做法

第一种是将所有操作倒过来作，这样加边减，减变加

无解的情况就是 在未到达过0之前，最后某段音量>vmax 或未到达过vmax之前，最后某段音量<0

然后就是分情况讨论了

如果没有到过vmax，那么最大初始音量为所有操作之和

否则就是vmax

第二种就是类似清华集训V那题一样的去维护一个分段函数f（x）

其定义域为[0,vmax]，表示这段操作的初始音量，值域也为[0,vmax]，表示这段操作后的音量为多少

然后也是一通讨论

code：

第一种：

 #include<cstdio>
 #include<iostream>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 char ch;
 bool ok;
 void read(int &x){
     ok=;
     for (ch=getchar();!isdigit(ch);ch=getchar()) if (ch=='-') ok=;
     for (x=;isdigit(ch);x=x*+ch-'',ch=getchar());
     if (ok) x=-x;
 }
 const int maxn=;
 const int inf=0x7f7f7f7f;
 char s[];
 int n,vm,v[maxn];
 struct oper{
     int id,t;
 }op[maxn];
 bool cmp(const oper &a,const oper &b){return a.t>b.t;}
 void write(int a,int b){
     if (a==inf) puts("infinity");
     else printf("%d %d\n",a,b);
 }
 struct Node{
     int sum,maxv,minv;
 };
 Node operator+(const Node &a,const Node &b){return (Node){a.sum+b.sum,max(a.maxv,a.sum+b.maxv),min(a.minv,a.sum+b.minv)};}
 struct Seg{
     Node node[maxn<<],res,tmp;
     void build(int k,int l,int r){
         if (l==r){node[k]=(Node){v[l],v[l],v[l]};return;}
         int m=(l+r)>>;
         build(k<<,l,m),build((k<<)+,m+,r),node[k]=node[k<<]+node[(k<<)+];
     }
     void modify(int k,int l,int r,int x){
         if (l==r){node[k]=(Node){,,inf};return;}
         int m=(l+r)>>;
         if (x<=m) modify(k<<,l,m,x); else modify((k<<)+,m+,r,x);
         node[k]=node[k<<]+node[(k<<)+];
     }
     int query_max(int k,int l,int r){
         if (l==r){tmp=res+node[k];return tmp.maxv<vm;}
         int m=(l+r)>>;
         tmp=res+node[k<<];
         if (tmp.maxv>=vm) return query_max(k<<,l,m);
         res=tmp; return query_max((k<<)+,m+,r)+(m-l+);
     }
     int query_min(int k,int l,int r){
         if (l==r){tmp=res+node[k];return tmp.minv>;}
         int m=(l+r)>>;
         tmp=res+node[k<<];
         if (tmp.minv<=) return query_min(k<<,l,m);
         res=tmp; return query_min((k<<)+,m+,r)+(m-l+);
     }
     Node query(int k,int l,int r,int x){
         if (l==r) return node[k];
         int m=(l+r)>>;
         if (x<=m) return query(k<<,l,m,x);
         else return node[k<<]+query((k<<)+,m+,r,x);
     }
     bool check(int ans){
         int t1,t2;
         res=(Node){,,inf},t1=query_max(,,n-);
         res=(Node){,,inf},t2=query_min(,,n-);
         if (t1==n&&t2==n){write(ans,node[].sum);return true;}
         if (t1>t2){
             res=query(,,n-,t1);
             if (res.minv<) return false;
             if (t1==n) write(ans,node[].sum);
             else write(ans,vm);
             return true;
         }
         else{
             res=query(,,n-,t2);
             if (res.maxv>vm) return false;
             write(ans,vm);
             return true;
         }
         return false;
     }
 }T;
 int main(){
     read(n),read(vm),read(v[]);
     for (int i=n;i>=;i--) scanf("%s",s),v[i]=s[]=='+'?-:,read(op[i].t),op[i].id=i;
     T.build(,,n-);
     if (T.check(inf)) return ;
     for (int i=;i<n;i++) op[i].t-=op[i+].t;
     sort(op+,op+n,cmp);
     for (int i=,j;i<n;i=j){
         for (j=i;op[j].t==op[i].t;j++) T.modify(,,n-,op[j].id);
         if (T.check(op[i].t-)) return ;
     }
     return ;
 }

第二种：

 #include<cstdio>
 #include<iostream>
 #include<cmath>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 char ch;
 bool ok;
 void read(int &x){
     for (ok=,ch=getchar();!isdigit(ch);ch=getchar()) if (ch=='-') ok=;
     for (x=;isdigit(ch);x=x*+ch-'',ch=getchar());
     if (ok) x=-x;
 }
 const int maxn=;
 inline int min(const int &a,const int &b){
     int diff=b-a;
     return a+(diff&(diff>>));
 }
 inline int max(const int &a,const int &b){
     int diff=b-a;
     return b-(diff&(diff>>));
 }
 char s[];
 int n,vm,v2;
 struct Oper{
     int op,t,id;
 }oper[maxn];
 bool cmp(const Oper &a,const Oper &b){return a.t>b.t||(a.t==b.t&&a.id<b.id);}
 struct Data{
     int a,b,c;
     void init(){a=,b=vm,c=;}
 }res;
 Data operator+(const Data &x,const Data &y){return (Data){min(y.b,max(y.a,x.a+y.c)),max(y.a,min(y.b,x.b+y.c)),x.c+y.c};}
 struct Seg{
     #define ls k<<1
     #define rs (k<<1)+1
     Data val[maxn<<];
     void build(int k,int l,int r){
         if (l==r){val[k]=(Data){,vm,oper[l].op};return;}
         int m=(l+r)>>;
         build(ls,l,m),build(rs,m+,r),val[k]=val[ls]+val[rs];
     }
     void modify(int k,int l,int r,int x){
         if (l==r){val[k].init();return;}
         int m=(l+r)>>;
         if (x<=m) modify(ls,l,m,x); else modify(rs,m+,r,x);
         val[k]=val[ls]+val[rs];
     }
     void modify(int x,int op){modify(,,n,x);}
 }T;
 int calc(){
     if (v2==res.b&&res.b-res.c<=vm) return vm;
     return max(,min(v2-res.c,vm));
 }
 int f(int x){return min(res.b,max(res.a,x+res.c));}
 int main(){
     read(n),read(vm),read(v2);
     for (int i=;i<=n;i++) scanf("%s",s),read(oper[i].t),oper[i].op=s[]=='+'?:-,oper[i].id=i;
     T.build(,,n);
     for (int i=n;i>=;i--) oper[i].t-=oper[i-].t;
     sort(oper+,oper+n+,cmp);
     res=T.val[];
     if (f()<=v2&&v2<=f(vm)){puts("infinity");return ;}
     for (int i=,j;i<=n;i=j){
         for (j=i;oper[j].t==oper[i].t;j++) T.modify(oper[j].id,oper[j].op);
         res=T.val[];
         if (f()<=v2&&v2<=f(vm)){printf("%d %d\n",oper[i].t-,calc());return ;}
     }
     return ;
 }