Jzoj5409 Fantasy

Y sera 陷入了沉睡，幻境中它梦到一个长度为N 的序列{Ai}。
对于这个序列的每一个子串，定义其幻境值为这个子串的和，现在Y sera 希望选择K 个不同的子串并使得这K 个子串的幻境值之和最大。
然而由于梦境中的种种限制，这些子串的长度必须在L 到R 之间。

你需要告诉她，最大的幻境值之和。

对于100% 的数据，有1 <= N, K <= 10^5; 1 <= L < R <= N, |Ai|<= 10^4

此题做法比较神奇，也很好懂，但是很难搞清楚如何去构造

简单说一下，首先做出序列的前缀和，记为sum

我们发现对于一个右端点i，我们可以取为左端点的j必然在区间[i-R,i-L]中

对于每一个i，我们可以用ST表找出一个j在合法区间中使得sum[j]尽可能小

那么我们考虑，对于每一个i，我们将其建立一个五元组{val,l,r,i,t}

val表示sum[i]-sum[t]的值，l和r表示j可取的区间范围,i是右端点,t则表示在合法区间中使得sum[t]最小的值(l<=t<=r)

建立一个大根堆，按照val作为优先级

我们每次取出一个节点x后，我们将其val加入答案让后将其分裂成两个节点{val1,l,t-1,i,t1}和{val2,t+1,r,i,t2}

其中val1和t1是根据st表计算出来的，val2和t2同理

这一步操作其实就是相当于把原来的区间去掉已经统计入答案的那个点，一个区间去掉一个点分成两块而已

取出k次以后直接退出就可以得到答案

现在想想还是挺自然的

#pragma GCC optimize("O3")
#pragma G++ optimize("O3")
#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<queue>
#define N 500010
using namespace std;
struct dx{ int v,l,r,p,m; };
int st[N][20],s[N],lg[N],n,k,l,r; long long A=0;
inline bool operator< (dx a,dx b){ return a.v<b.v; } 
int gMin(int l,int r){
	int k=lg[r-l+1];
	return s[st[l][k]]<s[st[r-(1<<k)+1][k]]?st[l][k]:st[r-(1<<k)+1][k];
}
priority_queue<dx> q;
int main(){
	freopen("fantasy.in", "r", stdin);
  	freopen("fantasy.out", "w", stdout);
	scanf("%d%d%d%d",&n,&k,&l,&r);
	for(int i=1,j=0;i<=n;++i){
		scanf("%d",s+i);
		s[i]+=s[i-1]; 
		st[i][0]=i;
		if(i==(1<<j+1)) ++j;
		lg[i]=j;
	}
	for(int i=n;~i;--i)
		for(int j=1;(i+(1<<j))<=n;++j)
			st[i][j]=s[st[i][j-1]]<s[st[i+(1<<j-1)][j-1]]?st[i][j-1]:st[i+(1<<j-1)][j-1];
	for(int L,R,t,i=l;i<=n;++i){
		L=max(0,i-r); R=i-l; t=gMin(L,R);
		q.push((dx){s[i]-s[t],L,R,i,t});
	}
	for(dx c;k--;){
		c=q.top(); q.pop(); A+=c.v;
		if(c.l<c.m){
			int m=gMin(c.l,c.m-1);
			q.push((dx){s[c.p]-s[m],c.l,c.m-1,c.p,m});
		}
		if(c.m<c.r){
			int m=gMin(c.m+1,c.r);
			q.push((dx){s[c.p]-s[m],c.m+1,c.r,c.p,m});
		}
	}
	printf("%lld\n",A);
}