BZOJ4653（区间离散化+线段树+决策单调尺取）

写得很好的题解

一眼过去很像是：排序，然后从前向后扫，有这个区间时插到树里，过去以后再删除。然后事实也是这样做的……

具体起来：

1.如果考虑暴力的话，一种想法是枚举左端和右端要选取的区间（如果我们按长度排序的话），那么只要发现当前选取的这些从左到右的区间可以得到m及以上就可以了，没必要特地考虑具体选哪些，然后ans = min（ans， 右len - 左len）即可。

2.判断这些区间是否可行的方法是：出现一个区间就把区间内所有点+1，线段树维护最大值，所以segment[1].maxx >= m时该区间可行，然后1e9太大，把每个区间端点离散化一下。

3.复杂度太大，优化手法是发现如果当前的左端区间和右端区间都合法的话，因为我们是按照长度排序的，所以右端区间没理由往右移了，只会让答案更差。所以枚举左端即可，右端类似尺取的方法即可。然后就是常见手法，遇到一个新的r就插进树里+1，路过一个l就从树里-1。

 #pragma comment(linker, "/STACK:1024000000,1024000000")
 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <cmath>
 #include <ctime>
 #include <cctype>
 #include <climits>
 #include <iostream>
 #include <iomanip>
 #include <algorithm>
 #include <string>
 #include <sstream>
 #include <stack>
 #include <queue>
 #include <set>
 #include <map>
 #include <vector>
 #include <list>
 #include <fstream>
 #include <bitset>
 #define init(a, b) memset(a, b, sizeof(a))
 #define rep(i, a, b) for (int i = a; i <= b; i++)
 #define irep(i, a, b) for (int i = a; i >= b; i--)
 #define ls(p) (p) << 1
 #define rs(p) (p) << 1 | 1
 using namespace std;

 typedef double db;
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int, int> P;
 const int inf = 0x3f3f3f3f;
 const ll INF = 1e18;

 template <typename T> void read(T &x) {
     x = ;
     int s = , c = getchar();
     for (; !isdigit(c); c = getchar())
         if (c == '-')    s = -;
     for (; isdigit(c); c = getchar())
         x = x *  + c - ;
     x *= s;
 }

 template <typename T> void write(T x) {
     if (x < )    x = -x, putchar('-');
     if (x > )    write(x / );
     putchar(x %  + '');
 }

 template <typename T> void writeln(T x) {
     write(x);
     puts("");
 }

 const int maxn = 1e6 + ;

 int n, m, c[maxn], tot, ans = inf;
 struct Section {
     int l, r, len;

     bool operator < (const Section y) const {
         return len < y.len;
     }
 }a[maxn];

 struct Node {
     int l, r, maxx, tag;
 }t[maxn << ];

 void build(int l, int r, int p) {
     t[p].l = l, t[p].r = r;
     if (l == r) {
         t[p].maxx = t[p].tag = ;
         return;
     }
     int mid = (l + r) >> ;
     build(l, mid, ls(p));
     build(mid + , r, rs(p));
 }

 void Push_down(int p) {
     if (t[p].tag) {
         t[ls(p)].maxx += t[p].tag;
         t[rs(p)].maxx += t[p].tag;
         t[ls(p)].tag += t[p].tag;
         t[rs(p)].tag += t[p].tag;
         t[p].tag = ;
     }
 }

 void Update(int l, int r, int p, int k) {
     if (l <= t[p].l && t[p].r <= r) {
         t[p].maxx += k;
         t[p].tag += k;
         return;
     }
     Push_down(p);
     int mid = (t[p].l + t[p].r) >> ;
     if (l <= mid)    Update(l, r, ls(p), k);
     if (mid < r)    Update(l, r, rs(p), k);
     t[p].maxx = max(t[ls(p)].maxx, t[rs(p)].maxx);
 }

 int main() {
     read(n), read(m);
     rep(i, , n) {
         read(a[i].l);
         read(a[i].r);
         a[i].len = a[i].r - a[i].l;
         c[++tot] = a[i].l;
         c[++tot] = a[i].r;
     }
     //离散化
     sort(c + , c +  + tot);
     tot = unique(c + , c +  + tot) - c - ;
     rep(i, , n) {
         a[i].l = lower_bound(c + , c +  + tot, a[i].l) - c;
         a[i].r = lower_bound(c + , c +  + tot, a[i].r) - c;
     }
     sort(a + , a +  + n);
     //线段树维护
     build(, tot, );
     for (int l = , r = ; l <= n; l++) {
         while (t[].maxx < m && r < n) {
             ++r;
             Update(a[r].l, a[r].r, , );
         }
         if (t[].maxx == m) {
             ans = min(ans, a[r].len - a[l].len);
         } else    break;
         Update(a[l].l, a[l].r, , -);
     }

     if (ans == inf)    puts("-1");
     else    writeln(ans);
     return ;
 }