「CodePlus 2017 12 月赛」火锅盛宴

n<=100000种食物，给每个食物煮熟时间，有q<=500000个操作：在某时刻插入某个食物；查询熟食中编号最小的并删除之；查询是否有编号为id的食物，如果有查询是否有编号为id的熟食，如果有熟食删除之，否则输出其离煮熟的最小时间；查询编号在[L,R]的熟食有多少。保证操作时间递增。

可以发现：针对某种食物的信息维护只需要知道其未煮熟的食物中煮熟时间的最小值，而所有的熟食都可以一起维护。为此可以：对每个食物开个队列存未熟食物，对所有食物开个优先队列以便及时把熟食从队列中提出来，并开个以编号为下标的“东西”来维护每个编号的数量和区间信息。

由于只需要单点修改、区间查询，可以用BIT。至于查熟食中的编号最小可以用BIT上倍增。

这里比较脑残就写了线段树。。然而被卡常卡死了。

 #include<stdio.h>
 #include<string.h>
 #include<algorithm>
 #include<stdlib.h>
 #include<queue>
 //#include<queue>
 //#include<math.h>
 //#include<time.h>
 //#include<iostream>
 using namespace std;

 int T,n,m;
 #define maxn 200011
 #define maxq 500011

 struct SMT
 {
     struct Node
     {
         int sum;
         int ls,rs;
     }a[maxn<<];
     int size;
     void build(int &x,int L,int R)
     {
         x=++size; a[x].sum=;
         if (L==R) {a[x].ls=a[x].rs=; return;}
         const int mid=(L+R)>>;
         build(a[x].ls,L,mid); build(a[x].rs,mid+,R);
     }
     void build() {size=; int x; build(x,,n);}
     void up(int x) {a[x].sum=a[a[x].ls].sum+a[a[x].rs].sum;}
     int ql,qr,v;
     bool Add(int x,int L,int R)
     {
         if (L==R)
         {
             if (v==- && a[x].sum==) return ;
             a[x].sum+=v; return ;
         }
         else
         {
             const int mid=(L+R)>>;bool ans;
             if (ql<=mid) ans=Add(a[x].ls,L,mid);
             else ans=Add(a[x].rs,mid+,R);
             up(x); return ans;
         }
     }
     bool add(int x,int v) {ql=x; this->v=v; return Add(,,n);}
     int Find(int x,int L,int R)
     {
         if (L==R) return L;
         const int mid=(L+R)>>;
         if (a[a[x].ls].sum>) return Find(a[x].ls,L,mid);
         return Find(a[x].rs,mid+,R);
     }
     int find() {return Find(,,n);}
     int Query(int x,int L,int R)
     {
         if (ql<=L && R<=qr) return a[x].sum;
         int mid=(L+R)>>,ans=;
         if (ql<=mid) ans+=Query(a[x].ls,L,mid);
         if (qr> mid) ans+=Query(a[x].rs,mid+,R);
         return ans;
     }
     int query(int L,int R) {ql=L; qr=R; return Query(,,n);}
 }smt;

 struct qnode
 {
     int v,id;
     bool operator > (const qnode &b) const {return v>b.v;}
 };
 priority_queue<qnode,vector<qnode>,greater<qnode> > qtot;
 queue<int> q[maxn];

 int a[maxn];
 int qread()
 {
     char c;int s=; while (!((c=getchar())>='' && c<=''));
     do s=s*+c-''; while ((c=getchar())>='' && c<=''); return s;
 }
 void write(int x)
 {
     if (!x) {putchar('');putchar('\n');return;}
     char buf[]; int lb=;
     while (x) {buf[++lb]=x%; x/=;}
     for (;lb;lb--) putchar(buf[lb]+''); putchar('\n');
 }
 int main()
 {
     scanf("%d",&T);
 while (T--)
 {
     scanf("%d",&n);
     for (int i=;i<=n;i++) a[i]=qread();
     for (int i=;i<=n;i++) while (!q[i].empty()) q[i].pop();
     while (!qtot.empty()) qtot.pop();
     smt.build();
     scanf("%d",&m);
     int t,op,id,x,y;
     while (m--)
     {
         t=qread(),op=qread();
         while (!qtot.empty() && qtot.top().v<=t) smt.add(qtot.top().id,),q[qtot.top().id].pop(),qtot.pop();
         if (op==)
         {
             id=qread();
             q[id].push(t);
             qtot.push((qnode){t+a[id],id});
         }
         else if (op==)
         {
             if (smt.a[].sum==) puts("Yazid is angry.");
             else
             {
                 int ans=smt.find();
                 write(ans);
                 smt.add(ans,-);
             }
         }
         else if (op==)
         {
             id=qread();
             if (smt.add(id,-)) puts("Succeeded!");
             else if (q[id].empty()) puts("YJQQQAQ is angry.");
             else write(q[id].front()+a[id]-t);
         }
         else
         {
             x=qread(),y=qread();
             write(smt.query(x,y));
         }
     }
 }
     return ;
 }