单调队列优化dp--bzoj5185: [Usaco2018 Jan]Lifeguards

传送门

$luogu$上据说有一道这个题的弱化版，把删$k$个改成了删$1$个，那个大概线段树之类的随便做一下就好了

这道题可以先把包含的都去掉，所有线段就是相交或者不相交的了，然后考虑用$dp$解决，设$f[i][j]$表示到第$i$个线段，$i$必须留下，之前删掉了$j$条线段的最长覆盖长度，则
$$f[i][j]=f[x][j-(i-x-1)]+r_i-max(l_i,r_x)$$
这样复杂度不对，考虑优化
看到$f[i][j]$的决策点是一类的点，就是$f[x][y],x-y=i-j-1$，那就可以根据这个，算出前面每个$x-y=i-j-1$的最优解，对后面那个$max$可以分类讨论，如果不相交就直接是$r_i-l_i$，相交的就是取一个$f[x][y]-r_x$的最大值

可以用双端队列维护（第一次见学到了学到了），队列从前到后是$r$递增$f$递减的，这样就可以先从队头把不相交的都弹掉并记录一个$mx[id]$表示这一类的最大值，然后取队头的那个最大的取$max$就好了

代码如下：

#include
#include
#include
#include
#include
#include
#define N 100005
#define M 105
#define prii pair
using namespace std;

template<class T>inline void rd(T &x){
	x=0; short f=1; char c=getchar();
	while(c<'0' || c>'9') f=c=='-'?-1:1,c=getchar();
	while(c<='9' && c>='0') x=x*10+c-'0',c=getchar();
	x*=f;
}

int n,K,tot,f[N][M],mxr,mx[N],ans;
deque<prii> q[N];

struct qwq{
	int l,r;
	inline bool operator <(const qwq &x) const{
		return l<x.l||(l==x.l&&r>x.r);
	}
}a[N],b[N];

int main(){
	rd(n); rd(K);
	for(int i=1;i<=n;i++) rd(a[i].l),rd(a[i].r);
	sort(a+1,a+n+1);
	for(int i=1;i<=n;i++)
		if(a[i].r<=a[i-1].r) K--;
		else b[++tot]=a[i],mxr=max(mxr,a[i].r);
	if(K<=0){
		for(int i=1;i<=tot;i++) ans+=b[i].r-max(b[i-1].r,b[i].l);
		printf("%d\n",ans);
		return 0;
	}
	for(int i=1;i<=tot;i++)
		for(int j=0;j<=K && j<i;j++){
			int id=i-j-1;
			while(!q[id].empty() && b[q[id].front().second].r<b[i].l){
				int x=q[id].front().second; q[id].pop_front();
				mx[id]=max(mx[id],f[x][x-id]);
			}
			f[i][j]=mx[id]-b[i].l+b[i].r;
			if(!q[id].empty()) f[i][j]=max(f[i][j],q[id].front().first+b[i].r);
			id=i-j; int val=f[i][j]-b[i].r;
			while(!q[id].empty() && q[id].back().first<=val) q[id].pop_back();
			q[id].push_back(make_pair(val,i));
		}
	for(int i=1;i<=tot;i++)
		if(K-(tot-i)>=0) ans=max(ans,f[i][K-(tot-i)]);
	printf("%d\n",ans);
	return 0;
}