HDU 5372 Segment Game（线段树+离散化）

题意：

有两种操作：

1. 插入一个线段

2. 删除一个已存在的线段

每次插入后输出当前插入的线段能完整覆盖存在的几条线段。

解析：

线段树上面维护的是两个值，左端点的和，右端点的和

每次插入一条区间[L, R]就，

先询问 [0, R] 的右端点个数 lsum

再询问[L, INF]的左端点的个数 rsum

tot表示：当前线段还有几条

那么题目要求的是整条线段的个数就是：lsum+rsum?tot

（这里用到了容斥的思想）

再用线段树（或者树状数组）单点增加左节点的个数，和右节点的个数

删除的时候就先获取区间，然后单点修改两个端点，

由于b比较大，有1e9，所以还需要先离散化一下。

my code

#include <cstdio>
#include <cstring>
#include <algorithm>
#define mp make_pair
#define ls (o<<1)
#define rs (o<<1|1)
#define lson ls, L, M
#define rson rs, M+1, R
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = (int)3e5 + 10;

struct Node {
    int lsum, rsum;
    Node() { lsum = rsum = 0; }
} node[MAXN << 2];

inline void pushUp(int o) {
    node[o].lsum = node[ls].lsum + node[rs].lsum;
    node[o].rsum = node[ls].rsum + node[rs].rsum;
}

void build(int o, int L, int R) {
    node[o] = Node();
    if(L == R) return ;
    int M = (L + R)/2;
    build(lson);
    build(rson);
}

void modify(int o, int L, int R, int pos, int val, int type) {
    if(L == R) {
        if(type == -1)
            node[o].lsum += val;
        else
            node[o].rsum += val;
        return ;
    }
    int M = (L + R)/2;
    if(pos <= M) modify(lson, pos, val, type);
    else modify(rson, pos, val, type);
    pushUp(o);
}

int query(int o, int L, int R, int ql, int qr, int type) {
    if(ql <= L && R <= qr) {
        if(type == -1)
            return node[o].lsum;
        else
            return node[o].rsum;
    }
    int M = (L + R)/2, ret = 0;
    if(ql <= M) ret += query(lson, ql, qr, type);
    if(qr > M) ret += query(rson, ql, qr, type);
    return ret;
}

struct Line {
    int L, R;
    int lid, rid;
    Line() {}
    Line(int L, int R) : L(L), R(R) {}
} line[MAXN];
pii oper[MAXN];
int ln, n;
int arr[MAXN*2], an;

void descrete() {
    sort(arr, arr+an);
    an = unique(arr, arr+an) - arr;
    for(int i = 1; i < ln; i++) {
        line[i].lid = lower_bound(arr, arr+an, line[i].L) - arr;
        line[i].rid = lower_bound(arr, arr+an, line[i].R) - arr;
    }
}

void solve() {
    build(1, 0, MAXN);
    int tot = 0, idx = 1;
    int ql, qr;
    for(int i = 1; i <= n; i++) {
        if(oper[i].first == 0) {
            ql = line[idx].lid;
            qr = line[idx].rid;
            int lsum = query(1, 0, MAXN, 0, qr, 1);
            int rsum = query(1, 0, MAXN, ql, MAXN, -1);
            printf("%d\n", lsum + rsum - tot);
            modify(1, 0, MAXN, ql, 1, -1);
            modify(1, 0, MAXN, qr, 1, 1);
            idx++, tot++;
        }else {
            ql = line[oper[i].second].lid;
            qr = line[oper[i].second].rid;
            modify(1, 0, MAXN, ql, -1, -1);
            modify(1, 0, MAXN, qr, -1, 1);
            tot--;
        }
    }
}

int main() {
    int cas = 1;
    while(scanf("%d", &n) != EOF) {
        ln = 1, an = 0;
        int a, b;
        for(int i = 1; i <= n; i++) {
            scanf("%d%d", &a, &b);
            oper[i] = mp(a, b);
            if(a == 0) {
                int L = b, R = b+ln;
                line[ln++] = Line(L, R);
                arr[an++] = L, arr[an++] = R;
            }
        }
        printf("Case #%d:\n", cas++);
        descrete();
        solve();
    }
    return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。