bzoj5102 [POI2018]Prawnicy 线段树

$bzoj$跑的太慢了......

我们考虑用线段树来解决这个问题

考虑扫描线

当扫到左端点$i$时，我们把线段$i$加入线段树

同时，对于每个左端点$i$，我们在线段树上二分出最远的$r$满足$r$被覆盖了$k$次以上

复杂度$O(n \log n)$

然后$TLE$了，这一定不是我的锅...

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

#define ri register int
#define rep(io, st, ed) for(ri io = st; io <= ed; io ++)
#define drep(io, ed, st) for(ri io = ed; io >= st; io --)
extern inline char gc() {
    static char RR[], *S = RR + , *T = RR + ;
    if(S == T) fread(RR, , , stdin), S = RR;
    return *S ++;
}
inline int read() {
    int p = ; char c = gc();
    while(c > '' || c < '') c = gc();
    while(c >= '' && c <= '') p = p *  + c - '', c = gc();
    return p;
}

int wr[], rw;
#define pc(iw) putchar(iw)
inline void write(int x, char c = '\n') {
    if(!x) pc('');
    if(x < ) x = -x, pc('-');
    while(x) wr[++ rw] = x % , x /= ;
    while(rw) pc(wr[rw --] + ''); pc(c);
}

const int sid = ;
const int tid = ;

int nl, nr, ans;
int n, k, tn, tot;
int T[sid], mx[tid], tag[tid];
struct seg {
    int l, r, id;
    friend bool operator < (seg a, seg b)
    { return a.l < b.l; }
} t[];

#define ls (o << 1)
#define rs (o << 1 | 1)

inline void pushdown(int o) {
    if(!tag[o]) return;
    tag[ls] += tag[o]; mx[ls] += tag[o];
    tag[rs] += tag[o]; mx[rs] += tag[o];
    tag[o] = ;
}

int ml, mr;
inline void mdf(int o, int l, int r) {
    if(ml <= l && mr >= r) { tag[o] ++; mx[o] ++; return; }
    pushdown(o);
    int mid = (l + r) >> ;
    if(ml > mid) mdf(rs, mid + , r);
    else if(mr <= mid) mdf(ls, l, mid);
    else mdf(ls, l, mid), mdf(rs, mid + , r);
    mx[o] = max(mx[ls], mx[rs]);
}

inline int qry(int o, int l, int r) {
    if(l == r) {
        if(mx[o] >= k) return l;
        return ;
    }
    pushdown(o);
    int mid = (l + r) >> ;
    if(mx[rs] < k && mx[ls] < k) return ;
    if(mx[rs] >= k) return qry(rs, mid + , r);
    else return qry(ls, l, mid);
}

int b[sid], f[];
inline void radix_sort(int *a, int n) {
    rep(i, , n) ++ f[a[i] & ];
    rep(i, , ) f[i] += f[i - ];
    drep(i, n, ) b[f[a[i] & ] --] = a[i];
    memset(f, , sizeof(f));
    rep(i, , n) ++ f[b[i] >> ];
    rep(i, , ) f[i] += f[i - ];
    drep(i, n, ) a[f[b[i] >> ] --] = b[i];
}

int main() {
    n = read(); k = read();
    rep(i, , n) {
        t[i].id = i;
        t[i].l = read(); t[i].r = read();
        T[++ tot] = t[i].l; T[++ tot] = t[i].r;
    }
    sort(t + , t + n + );
    radix_sort(T, tot);
    tn = unique(T + , T + tot + ) - T - ;

    rep(i, , n)
        t[i].r = lower_bound(T + , T + tn + , t[i].r) - T;

    for(ri i = , j = ; i <= tn; i ++) {
        while(j <= n && t[j].l == T[i]) {
            ml = i; mr = t[j].r;
            mdf(, , tn); j ++;
        }
        int far = qry(, , tn);
        if(T[far] - T[i] > ans) {
            nl = i; nr = far;
            ans = T[far] - T[i];
        }
    }

    write(ans);
    int num = ;
    rep(i, , n) {
        if(t[i].l <= T[nl] && nr <= t[i].r)
            num ++, write(t[i].id, ' ');
        if(num == k) break;
    }
    return ;
}