【题解】【原创题目】伊卡洛斯和西瓜

验题人：\(\text{YudeS}\) 楪 / \(\text{LEGENDARY_CREATOR}\)

【题目描述】

简化题意：给出 \(X,Y\) 和一个长度为 \(n\) 的序列 \(a\)，对于每次询问 \(Li,Ri\)，求 \(\sum_{Li \leqslant l \leqslant r \leqslant Ri,(S_r-S_{l-1})\in [X,Y]} 1\)，其中 \(S\) 为 \(a\) 的前缀和数组。

【分析】

【Subtask #1】

纯暴力模拟一下就好了，没啥可说的。

注意开 \(long\ long\) 。

时间复杂度：\(O(Tn^2)\) 。

分数：\(10pt\) 。

【Code】

#include<algorithm>
#include<cstring>
#include<cstdio>
#define LL long long
#define Re register LL
using namespace std;
const int N=1e6+5;
LL n,x,y,T,X,Y,a[N],S[N];
inline void in(Re &x){
    Re fu=0;x=0;char ch=getchar();
    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    x=fu?-x:x;
}
int main(){
    in(n),in(T),in(X),in(Y);
    for(Re i=1;i<=n;++i)in(a[i]),S[i]=S[i-1]+a[i];
    while(T--){
        in(x),in(y);LL ans=0;
        for(Re i=x;i<=y;++i)
            for(Re j=i;j<=y;++j)
                ans+=(X<=S[j]-S[i-1]&&S[j]-S[i-1]<=Y);
        printf("%lld\n",ans);
    }
}

【优化】

可以提前预处理出所有答案，然后直接查询。

时间复杂度：\(O(n^2+T)\) 。

分数：\(10pt\) 。

代码略。

【Subtask #2】

考虑分为两步解决：

\[ans=(\sum_{Li \leqslant l \leqslant r \leqslant Ri,S_r-S_{l-1} \leqslant Y} 1) - (\sum_{Li \leqslant l \leqslant r \leqslant Ri,S_r-S_{l-1} \leqslant X-1} 1) \]

现在的问题就是求这个式子：

\[\sum_{Li \leqslant l \leqslant r \leqslant Ri,S_r-S_{l-1} \leqslant X} 1 \]

我们把它变成：

\[\sum_{Li-1 \leqslant l < r \leqslant Ri,S_r-S_{l} \leqslant X} 1 \]

其中 \(S_r-S_{l} \leqslant X\) 又可以化为如下两种形式：\(S_r \leqslant S_l+X,\) \(S_r-X \leqslant S_l\) 。

沿用上面 \(Subtask\ 1\) 中的暴力枚举法，开一颗权值树状数组维护当前已经加入的 \(S\)，将第二层循环优化成 \(logn\) 。

时间复杂度：\(O(Tnlogn)\) 。

分数：\(10pt\) 。

代码略。

【优化】

题目没有要求强制在线，可以考虑莫队暴力搞，在 \(add,del\) 函数调用区间查询和单点修改即可，具体实现如下：

在左指针 \(l\) 向左移动后，\(ans\) 加上树状数组中小于等于 \(S_l+X\) 的数量，然后将 \(S_l\) 丢进去。
在左指针 \(l\) 向右移动后，将 \(S_l\) 抠掉，然后 \(ans\) 减去树状数组中小于等于 \(S_l+X\) 的数量。
在右指针 \(r\) 向右移动后，\(ans\) 加上树状数组中大于等于 \(S_r-X\) 的数量，然后将 \(S_r\) 丢进去。
在右指针 \(r\) 向左移动后，将 \(S_r\) 抠掉，然后 \(ans\) 减去树状数组中大于等于 \(S_r-X\) 的数量。

注意在 \(add\) 函数中是先更新 \(ans\) 再加入 \(S\)，\(del\) 是先抠掉 \(S\) 再更新 \(ans\) 。代码如下：

#define lo(_) (lower_bound(b+1,b+m+1,_)-b)
inline void addL(Re l){ans+=T1.ask(1,lo(S[l]+X)),T1.add(lo(S[l]),1);}
inline void delL(Re l){T1.add(lo(S[l]),-1),ans-=T1.ask(1,lo(S[l]+X));}
inline void addR(Re r){ans+=T1.ask(lo(S[r]-X),n),T1.add(lo(S[r]),1);}
inline void delR(Re r){T1.add(lo(S[r]),-1),ans-=T1.ask(lo(S[r]-X),n);}

发现 \(lower\_bound\) 的使用平白无故地多出了一个 \(log\)，用预处理把它去掉（QAQ不预处理的代码 \(Subtask\ 2\) 会全部 \(TLE\)）。

时间复杂度：\(O(n \sqrt{n} logn)\) 。

分数：\(60pt\) 。

【Code】

#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register LL
#define lo(_) (lower_bound(b+1,b+m+1,_)-b)
using namespace std;
const int N=1e6+5,M=1e6+3;
LL n,m,x,y,T,X,Y,BL,a[N],b[N*5],S[N],rk[N][5];
//b: 离散化数组（注意要开5倍）
//S: a的前缀和数组
//rk[i][0]: S[i]离散化后的排名
//rk[i][1]: S[i]-Y离散化后的排名
//rk[i][2]: S[i]+Y离散化后的排名
//rk[i][3]: S[i]-(X-1)离散化后的排名
//rk[i][4]: S[i]+(X-1)离散化后的排名
inline void in(Re &x){
    Re fu=0;x=0;char ch=getchar();
    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    x=fu?-x:x;
}
inline void print(Re x){if(x>9)print(x/10);putchar('0'+x%10);}
struct Query{
    LL l,r,id;
    inline bool operator<(Query O)const{
        Re B1=l/BL,B2=O.l/BL;
        return B1!=B2?B1<B2:((B1&1)?r<O.r:r>O.r);//奇偶性排序
    }
}Q[M];
struct BIT{
    LL n,C[N*5];//空间要开离散化后的权值大小
    inline void CL(){for(Re i=0;i<=n;++i)C[i]=0;}
    inline void add(Re x,Re v){while(x<=n)C[x]+=v,x+=x&-x;}
    inline LL ask_(Re x){LL ans=0;while(x)ans+=C[x],x-=x&-x;return ans;}
    inline LL ask(Re L,Re R){return ask_(R)-ask_(L-1);}
}T1;
struct Sovle{
    LL o,X,ans,Ans[M];
    inline void addL(Re l){ans+=T1.ask(1,rk[l][o+2]),T1.add(rk[l][0],1);}//S[r]<=S[l]+X
    inline void delL(Re l){ans-=T1.ask(1,rk[l][o+2])-1,T1.add(rk[l][0],-1);}//S[r]<=S[l]+X (注意ask时要减去S[l]本身)
    inline void addR(Re r){ans+=T1.ask(rk[r][o+1],m),T1.add(rk[r][0],1);}//S[r]-X<=S[l]
    inline void delR(Re r){ans-=T1.ask(rk[r][o+1],m)-1,T1.add(rk[r][0],-1);}//S[r]-X<=S[l] (注意ask时要减去S[r]本身)
    inline void sakura(){
        T1.CL();
        Re nowL=1-1,nowR=0-1;//由于位置0算了进来，所以莫队指针起点要减一
        for(Re i=1;i<=T;++i){
            Re L=Q[i].l,R=Q[i].r;
            while(nowR<R)addR(++nowR);
            while(nowR>R)delR(nowR--);
            while(nowL>L)addL(--nowL);
            while(nowL<L)delL(nowL++);
            Ans[Q[i].id]=ans;
        }
    }
}S1,S2;
int main(){
    in(n),in(T),in(X),in(Y),BL=sqrt(n)+1,S1.X=Y,S2.X=X-1,S1.o=0,S2.o=2;
    for(Re i=1;i<=n;++i)in(a[i]),S[i]=S[i-1]+a[i];
    for(Re i=0;i<=n;++i)b[++m]=S[i],b[++m]=S[i]+Y,b[++m]=S[i]+(X-1),b[++m]=S[i]-Y,b[++m]=S[i]-(X-1);//将可能用到的值都存进去离散化
    sort(b+1,b+m+1);m=unique(b+1,b+m+1)-b-1;T1.n=m;//注意树状数组中的权值上界
    for(Re i=0;i<=n;++i)rk[i][0]=lo(S[i]),rk[i][1]=lo(S[i]-Y),rk[i][2]=lo(S[i]+Y),rk[i][3]=lo(S[i]-(X-1)),rk[i][4]=lo(S[i]+(X-1));//预处理排名
    for(Re i=1;i<=T;++i)in(Q[i].l),in(Q[i].r),--Q[i].l,Q[i].id=i;//这里把Q[i].l减1,方便后面处理
    sort(Q+1,Q+T+1);
    S1.sakura(),S2.sakura();
    for(Re i=1;i<=T;++i)print(S1.Ans[i]-S2.Ans[i]),puts("");
}

【Subtask #3】

注意 \(a_i\) 为正整数，这意味着什么？

如果不考虑 \(Li,Ri\) 的限制，对于每个 \(r\)，以它为右端点的合法区间的左端点必定是一段连续的位置。

用 \(AL[i]\) 表示满足 \(S_i-S_{j} \leqslant Y\) 的最靠左边的 \(j\)

用 \(AR[i]\) 表示满足 \(S_i-S_{j} \geqslant X\) 的最靠右边的 \(j\)

如图，红线指向的位置 \(j\)均满足 \(S_i-S_j \leqslant Y\)，蓝线指向的位置 \(j\)均满足 \(S_i-S_j \geqslant X\)：

易知两区间 \([AL[i],i]\) 与 \([1,AR[i]]\) 的交集即是以 \(i\) 为右端点的合法区间左端点集合。

而随着 \(i\) 的增大，\(AL[i],AR[i]\) 均单调不下降，直接两个指针 \(O(n)\) 扫过去就可以求出来。

用 \(Seg_i\) 表示区间 \([AL[i],AR[i]]\)，由于 \(Seg_i\) 单调不下降，每次询问 \([L,R]\) 时，对 \(Seg_L,Seg_{L+1}...Seg_{R}\) 做一遍 \(O(n)\) 的线段覆盖，可以得到右端点在 \([L,R]\) 以内的所有合法左端点，统计其中大于等于 \(L\) 的部分即可。

时间复杂度：\(O(Tn)\) 。

分数：\(60pt\) 。

代码略。

【优化】

依旧是考虑离线。

先将询问按右端点从小到大排序，用一个指针 \(p\) 表示当前已经加入前 \(p\) 个区间 \(Seg\)，用线段树维护对于每个位置的合法右端点个数，每当指针向右移动时，就把区间 \(Seg_i\) 中的数全部加 \(1\) 。查询时统计区间 \([L,R]\) 中的个数总和即可。（由于 \(Seg_i\) 必定小于等于 \(i\)，所以把 \(Seg_1,Seg_2...Seg_{L-1}\) 的加入是不会对询问产生影响的）

时间复杂度：\(O(nlogn)\) 。

分数：\(100pt\) 。

【Code】

#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
#define Re register int
#define lo(_) (lower_bound(b+1,b+m+1,_)-b)
using namespace std;
const int N=1e6+5,M=1e6+3;
int n,m,x,y,T,a[N],AL[N],AR[N];LL X,Y,S[N],Ans[M];
inline void in(Re &x){
    Re fu=0;x=0;char ch=getchar();
    while(ch<'0'||ch>'9')fu|=ch=='-',ch=getchar();
    while(ch>='0'&&ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
    x=fu?-x:x;
}
inline void print(LL x){if(x>9)print(x/10);putchar('0'+x%10);}
struct Segment_Tree{
    #define pl p<<1
    #define pr p<<1|1
    #define mid (L+R>>1)
    struct QAQ{int tag;LL S;}tr[N<<2];
    inline void updata(Re p,Re L,Re R,Re v){tr[p].S+=(LL)v*(R-L+1),tr[p].tag+=v;}
    inline void pushdown(Re p,Re L,Re R){
        if(tr[p].tag){
            updata(pl,L,mid,tr[p].tag);
            updata(pr,mid+1,R,tr[p].tag);
            tr[p].tag=0;
        }
    }
    inline void pushup(Re p){tr[p].S=tr[pl].S+tr[pr].S;}
    inline void change(Re p,Re L,Re R,Re l,Re r,Re v){
        if(l>r)return;//注意判断
        if(l<=L&&R<=r){updata(p,L,R,v);return;}
        pushdown(p,L,R);
        if(l<=mid)change(pl,L,mid,l,r,v);
        if(r>mid)change(pr,mid+1,R,l,r,v);
        pushup(p);
    }
    inline LL ask(Re p,Re L,Re R,Re l,Re r){
        if(l<=L&&R<=r)return tr[p].S;
        LL ans=0;pushdown(p,L,R);
        if(l<=mid)ans+=ask(pl,L,mid,l,r);
        if(r>mid)ans+=ask(pr,mid+1,R,l,r);
        return ans;
    }
}T1;
struct Query{int l,r,id;inline bool operator<(Query O)const{return r<O.r;}}Q[M];//询问按右端点排序
inline void sakura(){
    Re L=1,R=0;
    for(Re i=1;i<=n;++i){
        while(L<=i&&S[i]-S[L-1]>Y)++L;//若L不合法，右移指针
        while(R<i&&S[i]-S[R+1-1]>=X)++R;//若R+1合法，右移指针
        AL[i]=L,AR[i]=R;
    }
    Re now=0;
    for(Re i=1;i<=T;++i){
        while(now<Q[i].r)++now,T1.change(1,1,n,AL[now],AR[now],1);//右移指针至查询处
        Ans[Q[i].id]=T1.ask(1,1,n,Q[i].l,now);//统计左端点大于等于Q[i].l的区间数
    }
}
int main(){
    in(n),in(T),scanf("%lld%lld",&X,&Y);
    for(Re i=1;i<=n;++i)in(a[i]),S[i]=S[i-1]+a[i];
    for(Re i=1;i<=T;++i)in(Q[i].l),in(Q[i].r),Q[i].id=i;
    sort(Q+1,Q+T+1),sakura();
    for(Re i=1;i<=T;++i)print(Ans[i]),puts("");
}

【一些题外话】

感谢 \(\text{YudeS}\) 楪提出的题解修改建议！

第一次出原创题，花了接近一整天的时间，感觉快要累死了。

首先是码三个针对不同数据的 \(std\)，因为一些奇奇怪怪的小细节调了好长时间。

然后就是等待无聊的对拍，在此期间发现 \(U\) 盘莫名坏掉了，急急忙忙下了一堆数据恢复软件，结果都要充钱F**k 。

此时发现对于 \(X \leqslant 0\) 的数据后两种做法都会挂，心情差到了极点，懒得去深究原因了，直接把数据全放成了大于 \(1\) 的正整数，然后就开始造大数据（或许有大佬能够指出思路或者代码上的错误？）。

造完数据就已经快 \(21\) 点了，结果大小超限？于是又砍掉了一半，只留下 \(10\) 个测试点，压缩后 \(62Mb\)，试探性地上传一下居然过了。

最后就是瞎编题面和写题解了，这项工作拖到第二天下午才完成。。。

posted @ 2019-12-29 11:06 辰星凌阅读(467) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

辰星凌的博客QAQ

时过而不知泪已落 ——散华礼弥

【题解】【原创题目】伊卡洛斯和西瓜

【题解】【原创题目】伊卡洛斯和西瓜

【题目描述】

【分析】

【Subtask #1】

【Code】

【优化】

【Subtask #2】

【优化】

【Code】

【Subtask #3】

【优化】

【Code】

【一些题外话】

公告