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）

#include<bits/stdc++.h>

#define mxn 100005
#define mxm 8000005

#define min(a, b) (a < b ? a : b)
#define max(a, b) (a > b ? a : b)

int n, m;

int a[mxn];

struct pair {
    int x, y;
}pt[mxn];

inline bool cmp(const pair &a, const pair &b) {
    if (a.x != b.x)
        return a.x < b.x;
    else
        return a.y < b.y;
}

int tt;
int sm[mxm];
int ls[mxm];
int rs[mxm];

int root[mxn];

void insert(int &a, int b, int l, int r, int p) {
    a = ++tt;
    
    ls[a] = ls[b];
    rs[a] = rs[b];
    sm[a] = sm[b] + 1;
    
    if (l == r)return;
    
    int d = (l + r) >> 1;
    
    if (p <= d)
        insert(ls[a], ls[b], l, d, p);
    else
        insert(rs[a], rs[b], d + 1, r, p);
}

int query(int a, int b, int l, int r, int x, int y) {
    if (l == x && r == y)
        return sm[a] - sm[b];
    
    int d = (l + r) >> 1;
    
    if (y <= d)
        return query(ls[a], ls[b], l, d, x, y);
    else if (x > d)
        return query(rs[a], rs[b], d + 1, r, x, y);
    else
        return query(ls[a], ls[b], l, d, x, d) + query(rs[a], rs[b], d + 1, r, d + 1, y);
}

int fa[mxn];
int mn[mxn];
int mx[mxn];

int find(int u) {
    return fa[u] == u ? u : fa[u] = find(fa[u]);
}

int ans = 0;

inline int lower(int p) {
    int lt = 1, rt = m, mid, ans = m + 1;
    
    while (lt <= rt) {
        mid = (lt + rt) >> 1;
        
        if (pt[mid].x >= p)
            rt = mid - 1, ans = mid;
        else
            lt = mid + 1;
    }
    
    return ans;
}

inline int upper(int p) {
    int lt = 1, rt = m, mid, ans = 0;
    
    while (lt <= rt) {
        mid = (lt + rt) >> 1;
        
        if (pt[mid].x <= p)
            lt = mid + 1, ans = mid;
        else
            rt = mid - 1;
    }
    
    return ans;
}

inline int query(int la, int ra, int lb, int rb) {
    int st = lower(la);
    int ed = upper(ra);
    
    if (st > ed)return 0;
    
    return query(root[ed], root[st - 1], 1, n, lb, rb);
}

inline void merge(int a, int b) {
    a = find(a);
    b = find(b);
    
    int la = mn[a];
    int ra = mx[a];
    int lb = mn[b];
    int rb = mx[b];
    
    ans += query(la, ra, lb, rb);
    
    fa[a] = b;
    mn[b] = la;
    mx[b] = rb;
}

signed main(void) {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
#endif    

    scanf("%d%d", &n, &m);
    
    for (int i = 1; i <= n; ++i)
        scanf("%d", a + i);
        
    for (int i = 1; i <= m; ++i)
        scanf("%d%d", &pt[i].x, &pt[i].y);
    
    std::sort(pt + 1, pt + m + 1, cmp);
    
    for (int i = 1; i <= m; ++i)
        insert(root[i], root[i - 1], 1, n, pt[i].y);
    
    int q, lst = 0;

    for (int i = 1; i <= n; ++i)
        fa[i] = mn[i] = mx[i] = i;
    
    for (int i = 1; i <= n; ++i)
        if (!a[i]) {
            merge(i, i);
            
            if (i > 1 && !a[i - 1]
            && find(i) != find(i - 1))
                merge(i - 1, i);
            
            if (i < n && !a[i + 1]
            && find(i) != find(i + 1))
                merge(i, i + 1);
        }
    
    for (scanf("%d", &q); q--; ) {
        int p; scanf("%d", &p);
        
        p = (p + lst - 1) % n + 1;
        
        if (--a[p] == 0)
        {
            merge(p, p);
            
            if (p > 1 && !a[p - 1]
            && find(p) != find(p - 1))
                merge(p - 1, p);
            
            if (p < n && !a[p + 1]
            && find(p) != find(p + 1))
                merge(p, p + 1);
        }
        
        printf("%d
", lst = ans);
    }
}

无调试1遍AC，爽歪歪~~~

UPDATE 这题的做法还真是多啊，放几个链接吧，多多益善嘛~~~

SD_le

Claris

BraketBN

lych_cys

@Author: YouSiki