LightOJ - 1301 Monitoring Processes(树状数组)

题目大意：给你N个区间，问区间覆盖的最多次数

解题路上：坐标比较大，得离散话，然后树状数组维护每个点被覆盖了几次即可，最后再取最大值

#include <cstdio>
#include <cstring>
#include <map>
#include <algorithm>
using namespace std;
const int N = 50010;

struct Node {
    int l, r;
    Node() {}
    Node(int l, int r): l(l), r(r) {}
}node[N];

int bit[2 * N], num[N * 2];
int n, cnt, cas = 1;
map<int,int> Map;

void init() {
    scanf("%d", &n);
    Map.clear();

    cnt = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d%d", &node[i].l, &node[i].r);
        if (!Map[node[i].l]) {
            Map[node[i].l] = ++cnt;
            num[cnt] = node[i].l;
        }
        if (!Map[node[i].r])  {
            Map[node[i].r] = ++cnt;
            num[cnt] = node[i].r;
        }
    }
    sort(num + 1, num + 1 + cnt);
}

int find(int pos) {
    int l = 1, r = cnt;
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (num[mid] == pos) return mid;
        else if (num[mid] > pos) r = mid - 1;
        else l = mid + 1;
    }
    return -1;
}

inline int lowbit(int x) {
    return x & (-x);
}

void Modify(int x, int val) {
    while (x <= cnt) {
        bit[x] += val;
        x += lowbit(x);
    }
}

int Query(int x) {
    int ans = 0;
    while (x) {
        ans += bit[x];
        x -= lowbit(x);
    }
    return ans;
}

void solve() {
    memset(bit, 0, sizeof(bit));
    for (int i = 0; i < n; i++) {
        int l = find(node[i].l);
        int r = find(node[i].r) + 1;
        Modify(l, 1);
        Modify(r, -1);
    }
    int ans = 0;
    for (int i = 1; i <= cnt; i++) {
        ans = max(ans, Query(i));
    }
    printf("Case %d: %d\n", cas++, ans);
}

int main() {
    int test;
    scanf("%d", &test);
    while (test--) {
        init();
        solve();
    }
    return 0;
}