[NOI2016]区间

对于$l_i$、$r_i$的范围太大，我们离散化一下就可以缩到百万的范围了。

这道题要求花费最小。所以根据区间的长度排序，就可以转化成单调性的问题了：选取一段区间，使得这些区间的覆盖存在一个点被覆盖$\geq M$次。

于是维护一颗线段树，然后维护选取区间的开头和结尾，加入区间时将线段树对应的区间修改$+1$，去掉时就$-1$。

当存在一个点被覆盖$m$次时，说明线段树中有一个点的值$=m$，我们通过区间查询判断出来。然后维护答案，此时的答案为选取的区间中最长的减最短的，也就是选取中最后一个减去第一个。

最后输出最小值即可。

#include <bits/stdc++.h>

using namespace std;

#define re register
#define rep(i, a, b) for (re int i = a; i <= b; ++i)
#define repd(i, a, b) for (re int i = a; i >= b; --i)
#define maxx(a, b) a = max(a, b);
#define minn(a, b) a = min(a, b);
#define LL long long
#define INF (1 << 30)

inline int read() {
    int w = 0, f = 1; char c = getchar();
    while (!isdigit(c)) f = c == '-' ? -1 : f, c = getchar();
    while (isdigit(c)) w = (w << 3) + (w << 1) + (c ^ '0'), c = getchar();
    return w * f;
}

const int maxn = 500000 + 5;

struct Seg_tree {
#define lson (o << 1)
#define rson (o << 1 | 1)
    int maxv[maxn << 5], tag[maxn << 5];
    void pushup(int o) { maxv[o] = max(maxv[lson], maxv[rson]); }
    void pushdown(int o) {
        if (!tag[o]) return;
        tag[lson] += tag[o]; tag[rson] += tag[o];
        maxv[lson] += tag[o]; maxv[rson] += tag[o];
        tag[o] = 0;
    }
    void modify(int o, int l, int r, int ql, int qr, int v) {
        if (ql <= l && r <= qr) { maxv[o] += v, tag[o] += v; return; }
        pushdown(o);
        int mid = (l + r) >> 1;
        if (ql <= mid) modify(lson, l, mid, ql, qr, v);
        if (mid < qr) modify(rson, mid+1, r, ql, qr, v);
        pushup(o);
    }
} T;

struct Pair {
    int l, r, sz;
} a[maxn];

int n, m, b[maxn << 1];
map<int, int> s;
bool cmp(Pair a, Pair b) { return a.sz < b.sz; }

int main() {
    n = read(), m = read();
    rep(i, 1, n) a[i].l = read(), a[i].r = read(), a[i].sz = a[i].r-a[i].l, b[i*2-1] = a[i].l, b[i*2] = a[i].r;
    sort(b+1, b+n*2+1);
    int p = 0; b[0] = -INF;
    rep(i, 1, n*2) { 
        if (b[i] != b[i-1]) p++;
        s[b[i]] = p;
    }
    rep(i, 1, n) a[i].l = s[a[i].l], a[i].r = s[a[i].r];
    sort(a+1, a+n+1, cmp);
    p = 1;
    int ans = INF;
    rep(i, 1, n) {
        T.modify(1, 1, 2*n, a[i].l, a[i].r, 1);
        while (T.maxv[1] >= m) {
            minn(ans, a[i].sz-a[p].sz);
            T.modify(1, 1, 2*n, a[p].l, a[p].r, -1);
            p++;
        }
    }
    printf("%d", ans == INF ? -1 : ans);
    return 0;
}