LOJ#2086. 「NOI2016」区间

$n \leq 500000$个区间，从中挑出一些，使得至少有一个点被$m$个选中区间包含，且选中区间长度的极差最小。

区间题死脑筋晚期：把区间按左端点排序，然后右端点用个优先队列来弹，然后需要维护下标相差$m$的数字差的最值，可以在$n^2$的时间完美拿到签到题的60分。

求极差嘛，就是关注最大最小，不如把区间按长度升序，这样枚举两个区间时，可以把大小在他们之间的都加进线段树观察是否合法。然鹅，可以发现较长区间R往后枚举越来越长后，最优的较短区间L不会变小，也就是满足决策单调性，可以双指针搞定。

 //#include<iostream>
 #include<cstring>
 #include<cstdio>
 //#include<math.h>
 //#include<set>
 //#include<queue>
 //#include<bitset>
 //#include<vector>
 #include<algorithm>
 #include<stdlib.h>
 using namespace std;

 #define LL long long
 int qread()
 {
     char c; int s=,f=; while ((c=getchar())<'' || c>'') (c=='-') && (f=-);
     do s=s*+c-''; while ((c=getchar())>='' && c<=''); return s*f;
 }

 //Pay attention to '-' , LL and double of qread!!!!

 int n,m;
 #define maxn 500011
 struct Line{int x,y,v; bool operator < (const Line &b) const {return v<b.v;} }p[maxn];

 int lisa[maxn*],li=;
 struct SMT
 {
     struct Node{int ls,rs,Max,add;}a[maxn<<]; int size,n;
     void up(int x) {a[x].Max=max(a[a[x].ls].Max,a[a[x].rs].Max);}
     void build(int &x,int L,int R)
     {
         x=++size;
         if (L==R) return;
         int mid=(L+R)>>;
         build(a[x].ls,L,mid); build(a[x].rs,mid+,R);
     }
     void clear(int N) {n=N; size=; int x; build(x,,n);}
     void addsingle(int x,int v) {a[x].add+=v; a[x].Max+=v;}
     void down(int x) {if (a[x].add) {addsingle(a[x].ls,a[x].add); addsingle(a[x].rs,a[x].add); a[x].add=;} }
     int ql,qr,v;
     void Add(int x,int L,int R)
     {
         if (ql<=L && R<=qr) {addsingle(x,v); return;}
         down(x);
         int mid=(L+R)>>;
         if (ql<=mid) Add(a[x].ls,L,mid);
         if (qr>mid) Add(a[x].rs,mid+,R);
         up(x);
     }
     void add(int x,int y,int V) {ql=x; qr=y; v=V; Add(,,n);}
 }t;

 int main()
 {
     n=qread(); m=qread();
     for (int i=;i<=n;i++)
     {p[i].x=qread(); p[i].y=qread()+; p[i].v=p[i].y-p[i].x-; lisa[++li]=p[i].x; lisa[++li]=p[i].y;}
     sort(p+,p++n); sort(lisa+,lisa++li); li=unique(lisa+,lisa++li)-lisa-;
     for (int i=;i<=n;i++) p[i].x=lower_bound(lisa+,lisa++li,p[i].x)-lisa,
     p[i].y=lower_bound(lisa+,lisa++li,p[i].y)-lisa;

     t.clear(li);

     int ans=0x3f3f3f3f;
     for (int i=,j=;i<=n;i++)
     {
         t.add(p[i].x,p[i].y-,);
         for (;j<=n;j++)
         {
             t.add(p[j].x,p[j].y-,-);
             if (t.a[].Max<m) {t.add(p[j].x,p[j].y-,); break;}
         }
         if (t.a[].Max>=m) ans=min(ans,p[i].v-p[j].v);
     }
     printf("%d\n",ans==0x3f3f3f3f?-:ans);
     return ;
 }