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=0,f=1; while ((c=getchar())<'0' || c>'9') (c=='-') && (f=-1);
    do s=s*10+c-'0'; while ((c=getchar())>='0' && c<='9'); 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*2],li=0;
struct SMT
{
    struct Node{int ls,rs,Max,add;}a[maxn<<2]; 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)>>1;
        build(a[x].ls,L,mid); build(a[x].rs,mid+1,R);
    }
    void clear(int N) {n=N; size=0; int x; build(x,1,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=0;} }
    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)>>1;
        if (ql<=mid) Add(a[x].ls,L,mid);
        if (qr>mid) Add(a[x].rs,mid+1,R);
        up(x);
    }
    void add(int x,int y,int V) {ql=x; qr=y; v=V; Add(1,1,n);}
}t;

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