CF1884C Medium Design

思路

Step1. 贪心

拿到题后，第一时间想到贪心，如果这个区间加上会使答案变小或不变就不加。

但是很显然，这个贪心是错误的。

如果答案的最大值在区间 B，但是先加了区间 A，导致加区间 B 使答案不变，那么这样就会使答案变劣。

所以贪心是错误的。

Step2. 枚举

接着，想到了可以枚举最小值，如果某个区间包含了这个最小值，那么这个区间加上后的答案一定是不优于不加上这个区间的答案，所以所有包含了这个最小值的区间都不需要加，那么再把所有最小值的答案取个最大值即可。

当然了，区间的值大，所以需要离散化。

有个巨佬朋友写过这种做法的题解。

这里就不赘述了。

Step3. 优化

事实上，最小值的选择的讨论是多余的，假设最小值选在 $x$ 点，那么所有横跨 $x$ 的区间都是无效的，那么可以对答案做出贡献的只有两个端点都在 $x$ 左侧或者都在右侧的区间才有用，那么假设最后的最大值在 $x$ 左侧，那么在 $x$ 右侧的区间无用，这样的话，把 $x$ 右移可以让区间变多或不变，那么答案将会变优或者不变，同理最大值在 $x$ 右侧也可以得到 $x$ 在左端点不劣。

总而言之就是，如果 $x$ 选在中间，那么答案一定不优于 $x$ 选择两端的情况。

所以我们只需要讨论两种情况即可。

所以如果一个区间左端点有 $1$ 的话，就把这个区间加给第一组线段树。

如果一个区间右端点有 $m$ 的话，就把这个区间加给第二组线段树。

注意：一个区间可以加给两个线段树。

那么最后的答案就是两组线段树维护的最大值的较大值。

同样地，需要离散化。

AC code

#include<bits/stdc++.h>
using namespace std;
struct segtree
{
	struct node{int l,r,maxn,tag;}t[800005];
	inline void pushup(int p){t[p].maxn=max(t[p<<1].maxn,t[p<<1|1].maxn);}
	inline void addtag(int p,int k){t[p].maxn+=k,t[p].tag+=k;}
	inline void pushdown(int p){addtag(p<<1,t[p].tag),addtag(p<<1|1,t[p].tag),t[p].tag=0;}
	void build(int p,int l,int r)
	{
		t[p].l=l,t[p].r=r,t[p].maxn=t[p].tag=0;
		if(l==r) return;
		int mid=l+r>>1;
		build(p<<1,l,mid),build(p<<1|1,mid+1,r);
	}
	void update(int p,int l,int r)
	{
		if(t[p].l>=l&&t[p].r<=r){addtag(p,1);return;}
		if(t[p].tag) pushdown(p);
		int mid=t[p].l+t[p].r>>1;
		if(mid>=l) update(p<<1,l,r);
		if(mid<r) update(p<<1|1,l,r);
		pushup(p);
	}
}t1,t2;
int T,n,m,l[200005],r[200005],a[400005],num;
int main()
{
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d%d",&n,&m);
		for(int i=1;i<=n;++i) scanf("%d%d",&l[i],&r[i]),a[i*2-1]=l[i],a[i*2]=r[i];a[n*2+1]=1,a[n*2+2]=m;
		sort(a+1,a+2*n+3),num=unique(a+1,a+2*n+3)-a-1;
		t1.build(1,1,num),t2.build(1,1,num);
		//cout<<num<<endl;
		for(int i=1;i<=n;++i)
		{
			l[i]=lower_bound(a+1,a+num+1,l[i])-a,r[i]=lower_bound(a+1,a+num+1,r[i])-a;
			if(l[i]!=1) t1.update(1,l[i],r[i]);
			if(r[i]!=num) t2.update(1,l[i],r[i]);
		}
		printf("%d\n",max(t1.t[1].maxn,t2.t[1].maxn));
	}
	return 0;
}
 

Step4. 进一步优化

可以发现，只需要区间修改和一次区间查询，所以实际上可以直接使用差分数组进行维护，如果不算上离散化要用到的排序的话，时间复杂度更优，代码也更简单。

主要是因为前面的方法需要线段树，所以最开始没想到差分，辛辛苦苦写完了才发现更本不需要。

因为代码难度低，所以这里就不放差分版的代码了 （绝对不是我懒得再写一个差分了）。