2021牛客暑期多校训练营2 G.League of Legends(模型转化,单调队列dp)

LINK

题意

给定$n$个区间分成$k$组,要求每组至少一个区间,每个区间恰好属于一个组

每组的贡献是区间的交的点数,每组至少需要有一个公共交点

求最大收益,无解输出0.

---

考虑一个区间包含了小区间,那么这个区间只有两种决策是最优的

Ⅰ.单独成一个组,贡献就是自己的长度

Ⅱ.加入到自己包含的那个小区间的组去,此时答案不变

对于情况Ⅱ,答案不变不需要考虑.对于情况Ⅰ,单独成组可以先放一放

考虑剔除这些区间,剩下的区间有一个非常好的性质,就是左端点递增的同时右端点也递增

如果这考虑这些区间,会发现选择连续相邻的区间在一个组内一定是最优的

于是定义$f[i][j]$表示把前$j$个区间分为$i$组的最大贡献

f [ i ] [ j ] = max ⁡ { f [ i − 1 ] [ k ] + R k + 1 − L j } f[i][j]=\max\{ f[i-1][k]+R_{k+1}-L_j\} f[i][j]=max{f[i−1][k]+Rk+1​−Lj​}且满足$R_{k+1}>L_j$

也就是 f [ i ] [ j ] = max ⁡ { f [ i − 1 ] [ k ] + R k + 1 } − L j f[i][j]=\max\{f[i-1][k]+R_{k+1}\}-L_j f[i][j]=max{f[i−1][k]+Rk+1​}−Lj​

维护一个$f[i-1][k]+R_{k+1}$的最大值即可,同时不断把不满足$R_{k+1}>L_j$的状态剔除

这个可以用单调队列线性解决

最后枚举一下这些小区间占据的组数,然后剩下的组数每组贪心的放一个大区间取$max$即可

#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3+10;
struct node
{
	int l,r;
	bool operator < ( const node&p ) const {return l<p.l || ( l==p.l && r>p.r ); }
}a[maxn],s[maxn]; int top;
int n,k,q[maxn],sg[maxn],f[maxn][maxn];
int main()
{
	cin >> n >> k;
	for(int i=1;i<=n;i++)	cin >> a[i].l >> a[i].r;
	sort( a+1,a+1+n );
	int mr = 1e5+1;
	for(int i=n;i>=1;i--)
	{
		if( a[i].r>mr )	sg[++sg[0]] = a[i].r-a[i].l;
		else	mr = a[i].r, s[++top] = a[i];
	}
	sort( s+1,s+1+top );
	memset( f,-1,sizeof f );
	f[0][0] = 0;
	for(int i=1;i<=top;i++)
	{
		int head = 1, tail = 0;
		q[++tail] = i-1;
		for(int j=i;j<=top;j++)
		{
			while( head<=tail && s[q[head]+1].r<=s[j].l )	head++;
			if( head<=tail && ( ~f[i-1][q[head]] ) )
				f[i][j] = f[i-1][q[head]]+s[q[head]+1].r-s[j].l;
			if( ~f[i-1][j-1] )
				f[i][j] = max( f[i][j],f[i-1][j-1]+s[j].r-s[j].l );
			if( ~f[i-1][j] )
			{
				while( tail>=head && f[i-1][j]+s[j+1].r>=f[i-1][q[tail]]+s[q[tail]+1].r )	tail--;
				q[++tail] = j;
			}
		}
	}
	sort( sg+1,sg+1+sg[0],[](int a,int b){return a>b;} );
	int ans = 0, res = 0;
	for(int i=0;i<=sg[0] && i<=k;i++)
	{
		if( i )	res += sg[i];
		if( ~f[k-i][top] )
			ans = max( ans,f[k-i][top]+res );
	}
	cout << ans;
}