洛谷 P1712 区间

题目描述

在数轴上有 n个闭区间 [l1,r1],[l2,r2],...,[ln,rn]。现在要从中选出 m 个区间，使得这 m个区间共同包含至少一个位置。换句话说，就是使得存在一个 x，使得对于每一个被选中的区间 [li,ri]，都有 li≤x≤ri。

对于一个合法的选取方案，它的花费为被选中的最长区间长度减去被选中的最短区间长度。区间 [li,ri] 的长度定义为 ri−li，即等于它的右端点的值减去左端点的值。

求所有合法方案中最小的花费。如果不存在合法的方案，输出 −1。

输入输出格式

输入格式：

第一行包含两个正整数 n,m用空格隔开，意义如上文所述。保证 1≤m≤n

接下来 n行，每行表示一个区间，包含用空格隔开的两个整数 li 和 ri 为该区间的左右端点。

N<=500000,M<=200000,0≤li≤ri≤10^9

输出格式：

只有一行，包含一个正整数，即最小花费。

输入输出样例

输入样例#1：

6 3
3 5
1 2
3 4
2 2
1 5
1 4

输出样例#1：

2

说明

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

线段树+贪心~

我们先把线段按照长度排序，然后从短到长加入，用线段树记录重复最多的地方重复了x次，当x>=m时更新答案，然后删去前面的边直到x<m，这样贪心地选择即可。

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

int n,m,x,y,ans,xx[1000001],tot1,tot2,cnt,root;

struct node{
	int l,r,len;
	bool operator < (const node&u)
	{
		return len<u.len;
	}
}a[500001];

struct node1{
	int l,r,tag,mx;
}c[500001<<2];

int read()
{
	int x=0,f=1;char ch=getchar();
	while(ch<'0' || ch>'9') {if(ch=='-') f=-1;ch=getchar();}
	while(ch>='0' && ch<='9') {x=x*10+ch-'0';ch=getchar();}
	return x*f;
}

void pushdown(int u)
{
	if(!c[u].l) c[u].l=++cnt;
	c[c[u].l].mx+=c[u].tag;c[c[u].l].tag+=c[u].tag;
	if(!c[u].r) c[u].r=++cnt;
	c[c[u].r].mx+=c[u].tag;c[c[u].r].tag+=c[u].tag;
	c[u].tag=0;
}

void add(int u,int v,int l,int r,int val,int &rot)
{
	if(!rot) rot=++cnt;
	if(l>=u && r<=v)
	{
		c[rot].mx+=val;c[rot].tag+=val;return;
	}
	if(c[rot].tag) pushdown(rot);
	int mid=l+r>>1;
	if(u<=mid) add(u,v,l,mid,val,c[rot].l);
	if(v>mid) add(u,v,mid+1,r,val,c[rot].r);
	c[rot].mx=max(c[c[rot].l].mx,c[c[rot].r].mx);
}

int main()
{
	n=read();m=read();ans=0x3f3f3f3f;
	for(int i=1;i<=n;i++)
	{
		x=read();y=read();
		xx[++tot1]=x;xx[++tot1]=y;
		a[i]=(node){x,y,y-x+1};
	}
	sort(xx+1,xx+tot1+1);
	tot1=unique(xx+1,xx+tot1+1)-xx-1;
	for(int i=1;i<=n;i++)
	{
		a[i].l=lower_bound(xx+1,xx+tot1+1,a[i].l)-xx;
		a[i].r=lower_bound(xx+1,xx+tot1+1,a[i].r)-xx;
	}
	sort(a+1,a+n+1);
	for(int i=1,las=1;i<=n;i++)
	{
		add(a[i].l,a[i].r,1,tot1,1,root);
		while(c[root].mx>=m)
		{
			ans=min(ans,a[i].len-a[las].len);
			add(a[las].l,a[las].r,1,tot1,-1,root);
			las++;
		}
	}
	if(ans==0x3f3f3f3f) ans=-1;
	printf("%d\n",ans);
	return 0;
}