BZOJ 4631: 踩气球

4631: 踩气球

Time Limit: 10 Sec Memory Limit: 256 MB
Submit: 267 Solved: 138
[Submit][Status][Discuss]

Description

六一儿童节到了， SHUXK 被迫陪着M个熊孩子玩一个无聊的游戏：有N个盒子从左到右排成一排，第i个盒子里装着Ai个气球。

SHUXK 要进行Q次操作，每次从某一个盒子里拿出一个没被踩爆的气球，然后熊孩子们就会立刻把它踩爆。

这M个熊孩子每个人都指定了一个盒子区间[Li, Ri]。如果某一个时刻，一个熊孩子发现自己选定的盒子区间[Li, Ri]中的所

有气球都已经被踩爆了，他就会非常高兴（显然之后他一直会很高兴）。

为了不辜负将自己的任务强行塞给 SHUXK 的那个人的期望， SHUXK 想向你询问：

他每次操作过后会有多少个熊孩子很高兴。

Input

第一行包含两个正整数N和M，分别表示盒子和熊孩子的个数。

第二行包含N个正整数Ai（ 1 < = Ai < = 10^5），表示每个盒子里气球的数量。

以下M行每行包含两个正整数Li, Ri（ 1 < = Li < = Ri < = N），分别表示每一个熊孩子指定的区间。

以下一行包含一个正整数Q，表示 SHUXK 操作的次数。

以下Q行每行包含一个正整数X，表示这次操作是从第X个盒子里拿气球。为

了体现在线，我们对输入的X进行了加密。

假设输入的正整数是x'，那么真正的X = (x' + Lastans − 1)Mod N + 1。其

中Lastans为上一次询问的答案。对于第一个询问， Lastans = 0。

输入数据保证1 < = x' < = 10^9，且第X个盒子中有尚未被踩爆的气球。

N < = 10^5 ,M < = 10^5 �,Q < = 10^5

Output

包含Q行，每行输出一个整数，表示 SHUXK 一次操作后询问的

答案。答案的顺序应与输入数据的顺序保持一致。

Sample Input

5 3
1 1 1 1 1
5 5
2 2
1 3
5
4
2
5
2
3

Sample Output

0
1
1
2
3
【样例说明】
实际上每次操作的盒子是： 4 2 1 3 5
在第二次操作后，第二个熊孩子会高兴（区间[2,2]中的气球已经全部被踩爆）。
在第四次操作后，第三个熊孩子会高兴（区间[1,3]中的气球已经全部被踩爆）。
在第五次操作后，第一个熊孩子会高兴（区间[5,5]中的气球已经全部被踩爆）。

HINT

Source

[Submit][Status][Discuss]

看到短短在写这道题，听说LRD大佬也写了这道题，小生也来凑凑热闹。其实这道题很简单哈，秒切~~~ 美滋滋~~~

如果询问不强制在线的话，NeighThorn小同学有个不错的离线方法，只需要求出所有的熊孩子从什么时候开始变得高兴即可，这个可以先用可持久化线段树维护一下每个时刻，每个盒子的01状态，然后查询区间和就知道是否高兴，所以外层套个二分就可以轻松做到$O(NlogN)$了，美滋滋~~~ 然后问我是不是可持久化线段树，我说是啊，你好强啊，秒正解啊，然后她就愉快地去码代码了，然后突然发现是强制在线，欲哭无泪~~~ 默哀一秒~~~

不过正解确实是可持久化线段树哈，NEIGHTHORN小同学还是很厉害的，猜对了数据结构哈。

就是考虑每次当前箱子变成空的，答案才会有更新哈，所以先维护一下每个箱子的气球个数哈，这个就是一个数组的事情，轻松搞定。

然后发现每次求出全局答案比较难哈，所以我们就求出新增的高兴熊孩儿就可以了，这个就需要知道有多少个区间变得满足要求。

我们不妨设当前箱子是p，然后原来在其左侧有个极大的空箱子区间，记为[l,p-1]，在右侧有个累死的极大空区间，记为[p+1,r]，不难发现新产生的高兴区间一定满足一下要求——左端点在[l,p]范围内，右端点在[p,r]范围内（也许在p位置上有些细节问题，但这不重要~~~）。然后考虑怎么资瓷这个东西，显然把所有区间按左端点排序，右端点可持久化线段树维护一下就可以了，用二分+线段树，总的复杂度还是一个log，优秀啊~~~ （自恋ing）

  1 #include<bits/stdc++.h>
  2 
  3 #define mxn 100005
  4 #define mxm 8000005
  5 
  6 #define min(a, b) (a < b ? a : b)
  7 #define max(a, b) (a > b ? a : b)
  8 
  9 int n, m;
 10 
 11 int a[mxn];
 12 
 13 struct pair {
 14     int x, y;
 15 }pt[mxn];
 16 
 17 inline bool cmp(const pair &a, const pair &b) {
 18     if (a.x != b.x)
 19         return a.x < b.x;
 20     else
 21         return a.y < b.y;
 22 }
 23 
 24 int tt;
 25 int sm[mxm];
 26 int ls[mxm];
 27 int rs[mxm];
 28 
 29 int root[mxn];
 30 
 31 void insert(int &a, int b, int l, int r, int p) {
 32     a = ++tt;
 33     
 34     ls[a] = ls[b];
 35     rs[a] = rs[b];
 36     sm[a] = sm[b] + 1;
 37     
 38     if (l == r)return;
 39     
 40     int d = (l + r) >> 1;
 41     
 42     if (p <= d)
 43         insert(ls[a], ls[b], l, d, p);
 44     else
 45         insert(rs[a], rs[b], d + 1, r, p);
 46 }
 47 
 48 int query(int a, int b, int l, int r, int x, int y) {
 49     if (l == x && r == y)
 50         return sm[a] - sm[b];
 51     
 52     int d = (l + r) >> 1;
 53     
 54     if (y <= d)
 55         return query(ls[a], ls[b], l, d, x, y);
 56     else if (x > d)
 57         return query(rs[a], rs[b], d + 1, r, x, y);
 58     else
 59         return query(ls[a], ls[b], l, d, x, d) + query(rs[a], rs[b], d + 1, r, d + 1, y);
 60 }
 61 
 62 int fa[mxn];
 63 int mn[mxn];
 64 int mx[mxn];
 65 
 66 int find(int u) {
 67     return fa[u] == u ? u : fa[u] = find(fa[u]);
 68 }
 69 
 70 int ans = 0;
 71 
 72 inline int lower(int p) {
 73     int lt = 1, rt = m, mid, ans = m + 1;
 74     
 75     while (lt <= rt) {
 76         mid = (lt + rt) >> 1;
 77         
 78         if (pt[mid].x >= p)
 79             rt = mid - 1, ans = mid;
 80         else
 81             lt = mid + 1;
 82     }
 83     
 84     return ans;
 85 }
 86 
 87 inline int upper(int p) {
 88     int lt = 1, rt = m, mid, ans = 0;
 89     
 90     while (lt <= rt) {
 91         mid = (lt + rt) >> 1;
 92         
 93         if (pt[mid].x <= p)
 94             lt = mid + 1, ans = mid;
 95         else
 96             rt = mid - 1;
 97     }
 98     
 99     return ans;
100 }
101 
102 inline int query(int la, int ra, int lb, int rb) {
103     int st = lower(la);
104     int ed = upper(ra);
105     
106     if (st > ed)return 0;
107     
108     return query(root[ed], root[st - 1], 1, n, lb, rb);
109 }
110 
111 inline void merge(int a, int b) {
112     a = find(a);
113     b = find(b);
114     
115     int la = mn[a];
116     int ra = mx[a];
117     int lb = mn[b];
118     int rb = mx[b];
119     
120     ans += query(la, ra, lb, rb);
121     
122     fa[a] = b;
123     mn[b] = la;
124     mx[b] = rb;
125 }
126 
127 signed main(void) {
128 #ifndef ONLINE_JUDGE
129     freopen("in", "r", stdin);
130 #endif    
131 
132     scanf("%d%d", &n, &m);
133     
134     for (int i = 1; i <= n; ++i)
135         scanf("%d", a + i);
136         
137     for (int i = 1; i <= m; ++i)
138         scanf("%d%d", &pt[i].x, &pt[i].y);
139     
140     std::sort(pt + 1, pt + m + 1, cmp);
141     
142     for (int i = 1; i <= m; ++i)
143         insert(root[i], root[i - 1], 1, n, pt[i].y);
144     
145     int q, lst = 0;
146 
147     for (int i = 1; i <= n; ++i)
148         fa[i] = mn[i] = mx[i] = i;
149     
150     for (int i = 1; i <= n; ++i)
151         if (!a[i]) {
152             merge(i, i);
153             
154             if (i > 1 && !a[i - 1]
155             && find(i) != find(i - 1))
156                 merge(i - 1, i);
157             
158             if (i < n && !a[i + 1]
159             && find(i) != find(i + 1))
160                 merge(i, i + 1);
161         }
162     
163     for (scanf("%d", &q); q--; ) {
164         int p; scanf("%d", &p);
165         
166         p = (p + lst - 1) % n + 1;
167         
168         if (--a[p] == 0)
169         {
170             merge(p, p);
171             
172             if (p > 1 && !a[p - 1]
173             && find(p) != find(p - 1))
174                 merge(p - 1, p);
175             
176             if (p < n && !a[p + 1]
177             && find(p) != find(p + 1))
178                 merge(p, p + 1);
179         }
180         
181         printf("%d\n", lst = ans);
182     }
183 }