【NOIP模拟】 (11.2) T2最佳序列

最佳序列

题目描述：
       N个数，从中选择长度不小于L且不大于R的连续子序列，求出子序列平均数的最大值。

输入格式：
       输入文件的第一行包括3个整数N，L，R。
       第二行包括N个数，按顺序依次表示序列A的每一项。

输出格式：
       输出文件包括一行，一个实数，保留四位小数。

数据范围：
       20%的数据满足：1<=N<=200;R=N。
       40%的数据满足：1<=N<=2000。
       100%的数据满足：1<=n<=20000;1<=L<=R<=N;0<=Ai<=1000000

解析：
       对于20%的数据，暴力枚举即可。
       对于40%的数据，可以用前缀和的方式降维(但这道题在暴力进行优化后可以拿满......)。
       对于100%的数据，二分答案是很好想到的，但这道题的关键在于如何验证。于是我们要进行推理：
       假设这时我们二分到的平均数为x，那么如果满足条件，在这个序列中一定有一个长度为L～R的子序列满足平均数大于等于x,如果用暴力搜索肯定超时，所以我们来思考一下若当前搜索到了i作为右端点，左端点一定在i-R+1～i-L+1这个区间里，如果满足条件，那么
       sum[i]-sum[i-R]>=(i-R)*x,sum[i]-sum[i-L]>=(i-L)*x(sum为前缀和)
       我们把等式右边拆开移到左边就变成了
       sum[i]-i*x-(sum[i-R]-R*x)>=0，右边的不等式同理
       拆开后相当于
       sum[i]'-sum[i-R]'>=0，右边的不等式同理
       所以我们只用将sum都减去x，再计算出的sum[i-R]～sum[i-L]中如果最小的sum[j]能使得不等式成立，说明满足提议，x是存在的，否则是不存在的。那么问题来了，如何求出在一个长度固定的区间求最小的值，这里出现了两种方法：一种是线段树，一种是单调队列。
       线段树很好想到，因为这个问题是一个很裸的模板题，将sum减去x后存进线段树，然后枚举i时进行查找最小值即可。时间复杂度O(N (log N)^2)。
       这道题能用单调队列的原因是满足长度固定，而且每次取最小值，满足单调性，所以可以用单调队列实现。时间复杂度O(N log N)

代码(暴力100分....)

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <ctime>
#include <sstream>
using namespace std;

const int Max=200010;
int n,L,R;
double l,r,mid;
double ans;
long long num[Max],sum[Max];

inline int get_int()
{
int x=0,f=1;
char c;
for(c=getchar();(!isdigit(c))&&(c!='-');c=getchar());
if(c=='-') {f=-1;c=getchar();}
for(;isdigit(c);c=getchar()) x=(x<<3)+(x<<1)+c-'0';
return x*f;
}

inline int check()
{
for(register int i=L;i<=R;i++)
{
long long maxx=0;
for(register int j=i;j<=n;j++)
maxx=max(sum[j]-sum[j-i],maxx);
ans=max((double)(maxx)/(double)(i),ans);
}
}

int main()
{
//freopen("seq.in","r",stdin);
//freopen("seq.out","w",stdout);

n=get_int();
L=get_int();
R=get_int();
for(register int i=1;i<=n;i++) num[i]=get_int();
for(register int i=1;i<=n;i++) sum[i]=sum[i-1]+num[i];
l=0;
r=1e7;
check();
printf("%0.4f\n",ans);
return 0;
}

代码(二分+单调队列)：

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <ctime>
#include <sstream>
using namespace std;

const int Max=200010;
int n,L,R;
double l,r,mid;
int maxx;
int num[Max];
double sum[Max];

inline int get_int()
{
int x=0,f=1;
char c;
for(c=getchar();(!isdigit(c))&&(c!='-');c=getchar());
if(c=='-') {f=-1;c=getchar();}
for(;isdigit(c);c=getchar()) x=(x<<3)+(x<<1)+c-'0';
return x*f;
}

inline int check(double x)
{
static int p[Max];
for(int i=1;i<=n;i++) sum[i]=(double)num[i]-x;
for(int i=1;i<=n;i++) sum[i]+=sum[i-1];
int head=1,tail=0;
for(int i=L;i<=n;i++)         //注意要从L开始而不能从L+1开始，不然会漏算1～L的情况
{
while(head<=tail&&sum[p[tail]]>=sum[i-L]) tail--;
p[++tail]=i-L;
while(head<=tail&&i-R>p[head]) head++;
if(sum[p[head]]<=sum[i]) return 1;
}
return 0;
}

int main()
{
//freopen("seq.in","r",stdin);
// freopen("seq.out","w",stdout);

n=get_int();
L=get_int();
R=get_int();
for(int i=1;i<=n;i++) {num[i]=get_int();maxx=max(maxx,num[i]);}
l=0;
r=maxx;
for(int i=1;i<=50;i++)
{
mid=(l+r)/2;
if(check(mid)) l=mid;
else r=mid;
}
printf("%0.4f\n",l);
return 0;
}

代码(二分+线段树)

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <string>
#include <vector>
#include <queue>
#include <ctime>
#include <sstream>
using namespace std;

const int MAX=1e9;
const int Max=200010;
int n,L,R;
double l,r,mid;
int maxx;
int num[Max];
double sum[Max];
struct shu{int l,r;double minn;};
shu tree[Max*4];

inline int get_int()
{
int x=0,f=1;
char c;
for(c=getchar();(!isdigit(c))&&(c!='-');c=getchar());
if(c=='-') {f=-1;c=getchar();}
for(;isdigit(c);c=getchar()) x=(x<<3)+(x<<1)+c-'0';
return x*f;
}

inline void build(int root,int L,int R)
{
tree[root].l=L;
tree[root].r=R;
if(L==R)
{
tree[root].minn=sum[L];
return;
}
int mid=(L+R)>>1;
build(root<<1,L,mid);
build(root<<1|1,mid+1,R);
tree[root].minn=min(tree[root<<1].minn,tree[root<<1|1].minn);
}

inline double Q(int root,int L,int R,int l,int r)
{
if(l>R||r<L) return MAX;
if(l<=L&&r>=R)
{
return tree[root].minn;
}
int mid=(L+R)>>1;
if(r<=mid) return Q(root<<1,L,mid,l,r);
else if(l>mid) return Q(root<<1|1,mid+1,R,l,r);
else return min(Q(root<<1,L,mid,l,r),Q(root<<1|1,mid+1,R,l,r));
}

inline int check(double x)
{
memset(tree,0,sizeof(tree));
static int p[Max];
for(register int i=1;i<=n;i++) sum[i]=(double)num[i]-x;
for(register int i=1;i<=n;i++) sum[i]+=sum[i-1];
build(1,0,n);
for(register int i=L+1;i<=n;i++)
{
if(Q(1,0,n,max(i-R,0),i-L)<=sum[i]) return 1;
}
return 0;
}

int main()
{
//freopen("seq.in","r",stdin);
// freopen("seq.out","w",stdout);

n=get_int();
L=get_int();
R=get_int();
for(register int i=1;i<=n;i++) {num[i]=get_int();maxx=max(maxx,num[i]);}
l=0;
r=maxx;
for(register int i=1;i<=50;i++)
{
mid=(l+r)/2;
if(check(mid)) l=mid;
else r=mid;
}
printf("%0.4f\n",l);
return 0;
}