树状数组+贪心

小黑的树

Description

 

小H是个怕黑的人，小H的爱慕者小Z斥巨资给小H在宿舍和实验室之间修路灯。为了满足小H的审美，小Z规定只能在整数位置修路灯，并且每个整数位置都只能有一个路灯。在小H的认知里，有m个路段是非常黑的，所以之少要安装一定数量的路灯。

小H未来将会是一个贴心的女朋友，她想计算出小Z最少会为她安装多少路灯。

Input

 

第一行一个整数T（1<=T<=300）,表示测试数据的组数对于每组数据：第一行输入三个整数n,m,k;(1≤n≤1e6,1≤m≤1e5,1≤k≤n)第二行k个不同整数用空格隔开，表示这些位置已开始就有路灯接下来 m 行表示约束条件。第 i 行三个整数 li,ri,ti 表示：第 i 个区间 [li,ri] 至少要安装 ti 盏路灯 (1≤li≤ri≤n,1≤ti≤n)。

Output

 

对于每组数据，输出 Case x: ans。其中 x 表示测试数据编号（从 1 开始）。如果无解，y 为 −1。

Sample Input 1 

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

Sample Output 1

Case 1: 1
Case 2: 2
Case 3: 1

 

题解：首先按照区间右端点进行排序,对于一个区间,先用树状数组查询当前所需区间有多少灯，然后计算还需要need个灯,我们一定是贪心的从右端点r,找need个空白位置，这时候我们利用set位置当前空白位置下标，每个logn查询。

#include <bits/stdc++.h>

using namespace std;

const int maxn = 1e5 + 7;
struct tree //树状数组
{
    int c[maxn];
    int n;
    void init(int _n) {
        n = _n;
        for(int i = 0; i <= n; ++i) c[i] = 0;
    }
    void update(int p, int d) {
        for(int i = p; i <= n; i += i & -i) c[i] += d;
    }
    int query(int p) {
        int res = 0;
        for(int i = p; i > 0; i -= i & -i) res += c[i];
        return res;
    }
    int get(int L, int R) { //查询L,R有多少个灯
        return query(R) - query(L - 1);
    }
}bit;

struct node
{
    int st, ed, need;
    bool operator < (const node & x) const { //按照区间右端点排序
        if(ed != x.ed) return ed < x.ed;
        else return st < x.st;
    }
}a[maxn];
int main()
{
    ios::sync_with_stdio(false), cin.tie(0);
    int T, Case = 0;
    int n, m, k;
    cin >> T;
    while(T --) {
        cin >> n >> m >> k;
        bit.init(++n);
        set<int> pos; //set维护空白位置
        for(int i = 1; i <= n; ++i)  pos.insert(i); //初始都是空白可以放灯的位置
        for(int i = 1; i <= k; ++i) {
            int p;
            cin >> p;
            bit.update(++p, 1);
            pos.erase(p); //将已经放灯的位置进行删除
        }
        bool fg = 1;
        for(int i = 1; i <= m; ++i) {
            int l, r, t;
            cin >> l >> r >> t;
            a[i].st = l + 1;
            a[i].ed = r + 1;
            a[i].need = t;
            if(t > r - l + 1) fg = 0; //区间需要灯数大于区间长度,无解.(也只有这一种无解的情况)
        }
        cout << "Case " << ++Case << ": ";
        if(!fg) {
            cout << -1 << '\n';
            continue;
        }
        sort(a + 1, a + 1 + m);
        int res = 0;
        for(int i = 1; i <= m; ++i) {
            int cur = bit.get(a[i].st, a[i].ed); //当前区间已经有的灯
            int cnt = a[i].need - cur; //还需要多少灯
            int r = a[i].ed; //我们肯定是贪心从右边放灯,放灯位置不能超过当前右边界
//            cout << "i = "<< i << " " << cnt << " r = " << r << endl;
            while(cnt > 0) {
                -- cnt;
                auto it = pos.upper_bound(r); //二分找到大于r的第一个位置.
                -- it; //找到后再对迭代器剪一下,就是小于或等于r的第一个位置
                int p = *it; //解引用
                if(p > r) -- it;
                p = *it;
                bit.update(p, 1); //把这个位置更新成1
                pos.erase(it); //把空白位置删除
                res ++;
            }
        }
        cout << res << '\n';
    }
    return 0;
}
/*
首先总区间长度n只有1e5
首先排序复杂度m * log(m)
放灯最多放n个灯(最多更新n次),放灯时候每次进行更新log(n),即为n*log(n)
总复杂度 O(m*log(m) + n*log(n))
*/