HDU 6562 Lovers（线段树取模的适用范围）

最新推荐文章于 2024-04-02 16:47:09 发布

原创最新推荐文章于 2024-04-02 16:47:09 发布 · 267 阅读

2 ·

CC 4.0 BY-SA版权

数据结构-线段树专栏收录该内容

10 篇文章

订阅专栏

本文介绍了一种处理区间操作的高效算法，利用线段树维护数值和10的幂次和，解决数列上的swap和query操作，通过实例详细讲解了算法思路和代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

大致题意

给一个长度为 n 的数列，初始都为0 ，m 次操作。有两种操作如下：
swap x y z : z 是一个0-9 的数字，将区间 [x,y] 的每个数字 num 看成一个串，在两端加上 z ，相当于变成了 z“num”z 的一个数字。
query x y : 求区间 [x,y] 的所有串表示的数字的和。mod 1000000007

思路

首先要意识到取模可以适用在修改操作中，千万不要用串去存储（不然显然是MLE的假算法）。因为修改操作可以看成
在这里插入图片描述
其中 leni 表示数字的长度。那么可以看出整个swap操作也就是一系列乘法和加法运算，中间过程均可以取模。所以用线段树维护两个和，一个是数值和，另一个是10的长度幂次和。
这样在pushdown的时候会有一个问题，可能会有多个要加在两端的数字累计在一起，所以需要一个更一般的式子。
在这里插入图片描述
其中lazlen 表示当前需要添加的数字长度，lazl 是添加在左侧的值，lazr 是添加在右侧的值，lazl 和 lazr 是对称数字串。具体更新也比较好想了，思路要清晰才行。

代码

注意线段树虽然写了build 但是还是要清空一下，因为Build 虽然把我要用到的点都清空了，但是由于这不一定是一个满二叉树，所以在边上pushup的时候仍然可能用到 n 以外的点。
代码还是有不少可以常数优化的地方。

#include<bits/stdc++.h>
using namespace std;
#define maxn 100005
#define maxm 1000006
#define ll long long int
#define INF 0x3f3f3f3f
#define inc(i,l,r) for(int i=l;i<=r;i++)
#define dec(i,r,l) for(int i=r;i>=l;i--)
#define mem(a) memset(a,0,sizeof(a))
#define sqr(x) (x*x)
#define inf (ll)2e18+1
#define mod 1000000007
#define ls x<<1
#define rs x<<1|1
int read(){
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
     while(isdigit(ch))x=x*10+ch-'0',ch=getchar();
     return f*x;
}
int T,n,m;
char c[5];
ll fast(ll x,int y){
    ll res=1ll;
    while(y){
        if(y&1)res=res*x%mod;
        x=x*x%mod;
        y>>=1;
    }
    return res;
}
struct node{ll v,lazl,lazr,len;int lazlen;}t[maxn<<2];
void pushup(int x,int l,int r){
    t[x].v=(t[ls].v+t[rs].v)%mod;
    t[x].len=(t[ls].len+t[rs].len)%mod;
}
void pushdown(int x,int l,int r){
    int mid=(l+r)>>1;
    t[ls].v=((t[x].lazl*fast(10ll,t[x].lazlen)%mod*t[ls].len%mod) + (fast(10ll,t[x].lazlen)*t[ls].v%mod) + (t[x].lazr*(mid-l+1)%mod))%mod;
    t[rs].v=((t[x].lazl*fast(10ll,t[x].lazlen)%mod*t[rs].len%mod) + (fast(10ll,t[x].lazlen)*t[rs].v%mod) + (t[x].lazr*(r-mid)%mod))%mod;
    t[ls].len=t[ls].len*fast(10ll,t[x].lazlen*2)%mod;
    t[rs].len=t[rs].len*fast(10ll,t[x].lazlen*2)%mod;
    t[ls].lazl=((t[x].lazl*fast(10ll,t[ls].lazlen)%mod) + t[ls].lazl)%mod;
    t[ls].lazr=((t[ls].lazr*fast(10ll,t[x].lazlen)%mod) + t[x].lazr)%mod;
    t[rs].lazl=((t[x].lazl*fast(10ll,t[rs].lazlen)%mod) + t[rs].lazl)%mod;
    t[rs].lazr=((t[rs].lazr*fast(10ll,t[x].lazlen)%mod) + t[x].lazr)%mod;
    t[ls].lazlen+=t[x].lazlen;t[rs].lazlen+=t[x].lazlen;
    t[x].lazl=t[x].lazr=t[x].lazlen=0;
}
void build(int x,int l,int r){
    if(l==r){
        t[x].v=t[x].lazl=t[x].lazr=t[x].lazlen=0;
        t[x].len=1;
        return ;
    }
    int mid=(l+r)>>1;
    build(ls,l,mid);build(rs,mid+1,r);
    pushup(x,l,r);
}
void update(int x,int l,int r,int lp,int rp,int s){
    if(l<r&&t[x].lazlen>0)pushdown(x,l,r);
    if(lp<=l&&r<=rp){
        t[x].v=(1ll*s*10*t[x].len%mod + 1ll*10*t[x].v%mod + 1ll*s*(r-l+1)%mod)%mod;
        t[x].len=(1ll*t[x].len*100)%mod;
        t[x].lazl=t[x].lazr=s;
        t[x].lazlen=1;
        return ;
    }
    int mid=(l+r)>>1;
    if(lp<=mid)update(ls,l,mid,lp,rp,s);
    if(mid+1<=rp)update(rs,mid+1,r,lp,rp,s);
    pushup(x,l,r);
}
ll query(int x,int l,int r,int lp,int rp){
    if(l<r&&t[x].lazlen>0)pushdown(x,l,r);
    if(lp<=l&&r<=rp)return t[x].v;
    int mid=(l+r)>>1;
    ll res=0;
    if(lp<=mid)res=(res+query(ls,l,mid,lp,rp))%mod;
    if(mid+1<=rp)res=(res+query(rs,mid+1,r,lp,rp))%mod;
    return res;
}
int main()
{
    T=read();
    int kase=0;
    while(T--){
        n=read();m=read();
        mem(t);///虽然有build 但是还是要memset 不然边界的值pushup的时候仍然可能把大于n的节点搞上来
        build(1,1,n);
        printf("Case %d:\n",++kase);
        int x,y,z;
        while(m--){
            scanf("%s",c);
            if(c[0]=='w'){
                x=read();y=read();z=read();
                update(1,1,n,x,y,z);
            }
            else {
                x=read();y=read();
                printf("%lld\n",query(1,1,n,x,y));
            }
        }
    }
    return 0;
}