LG3372 【【模板】线段树 1】

介绍我的三种算法

1、线段树

既然这题是线段树板子，我还是尊重一下先发这个。跑的时间376ms不是很快，但也还是不错。O（nlogn）。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<string>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<algorithm>
const int INF = 0x7fffffff;
using namespace std;
inline void read(long long &x) {
    long long data=0,w=1;
    char ch=0;
    while(ch!='-' && (ch<'0' || ch>'9')) ch=getchar();
    if(ch=='-') w=-1,ch=getchar();
    while(ch>='0' && ch<='9') data=data*10+ch-'0',ch=getchar();
    x=data*w;
}

inline void write(long long x) {
    if(x<0) putchar('-'),x=-x;
    if(x>9) write(x/10);
    putchar(x%10+'0');
}

const int MAXN=1e5;
long long a[MAXN];
struct SegmentTree{
#define lson(o) (o<<1)
#define rson(o) (o<<1|1)
protected:
    long long sumv[MAXN<<2],addv[MAXN<<2];
    void pushup(int o){
        sumv[o]=sumv[lson(o)]+sumv[rson(o)];
    }
    void pushdown(int o,int l,int r){
        if(!addv[o])
            return;
        addv[lson(o)]+=addv[o];
        addv[rson(o)]+=addv[o];
        int mid=(l+r)>>1;
        sumv[lson(o)]+=addv[o]*(mid-l+1);
        sumv[rson(o)]+=addv[o]*(r-mid);
        addv[o]=0;
    }
public:
    void build(int o,int l,int r){
        addv[o]=0;
        if(l==r){//Recursive basis
            read(sumv[o]);
            return;
        }
        int mid=(l+r)>>1;
        build(lson(o),l,mid);
        build(rson(o),mid+1,r);
        pushup(o);
    }
    void optadd(int o,int l,int r,int ql,int qr,int v){
        if(ql<=l&&r<=qr){//Recursive basis
            addv[o]+=v;
            sumv[o]+=v*(r-l+1);
            return;
        }
        int mid=(l+r)>>1;
        pushdown(o,l,r);
        if(ql<=mid)
            optadd(lson(o),l,mid,ql,qr,v);
        if(mid+1<=qr)
            optadd(rson(o),mid+1,r,ql,qr,v);
        pushup(o);
    }
    long long querysum(int o,int l,int r,int ql,int qr){
        if(ql<=l&&r<=qr)//Recursive basis
            return sumv[o];
        int mid=(l+r)>>1;
        long long ans=0;
        pushdown(o,l,r);
        if(ql<=mid)
            ans+=querysum(lson(o),l,mid,ql,qr);
        if(mid+1<=qr)
            ans+=querysum(rson(o),mid+1,r,ql,qr);
        return ans;
    }
}st;
int main(){
    long long n,m;
    read(n);read(m);
    //for(int i=1;i<=n;++i)
    //    read(a[i]);
    st.build(1,1,n);
    long long q,x,y,k;
    while(m--){
        read(q);
        if(q==1){
            read(x);read(y);read(k);
            st.optadd(1,1,n,x,y,k);
        }
        else if(q==2){
            read(x);read(y);
            write(st.querysum(1,1,n,x,y));
            putchar('\n');
        }
    }
    return 0;
}

2、分块

对此题这种O(nsqrt(n))的算法竟然更快...可能是因为常数很小+o2。192ms。

// luogu-judger-enable-o2
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<ctime>
#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
//#pragma GCC optimize(2)
using namespace std;
typedef long long ll;
const int INF=0x7fffffff;
template<class T> inline T read(T&x){
    T data=0;
    int w=1;
    char ch=getchar();
    while(ch!='-'&&!isdigit(ch))
        ch=getchar();
    if(ch=='-')
        w=-1,ch=getchar();
    while(isdigit(ch))
        data=10*data+ch-'0',ch=getchar();
    return x=data*w;
}

const int maxn=1e5+10;
int n,m,a[maxn],belong[maxn];
int block,l[400],r[400],num,tag[400];
ll sum[400];

void build(){
    block=sqrt(n);
    num=(n-1)/block+1;
    for(int i=1;i<=num;++i)
        l[i]=(i-1)*block+1,r[i]=i*block;
    r[num]=n;
    memset(sum,0,sizeof(sum));
    memset(tag,0,sizeof(tag));
    for(int i=1;i<=n;++i){
        belong[i]=(i-1)/block+1;
        sum[belong[i]]+=a[i];
    }
}

void add(int x,int y,int k){
    if(belong[x]==belong[y]){
        sum[belong[x]]+=(y-x+1)*k;
        for(int i=x;i<=y;++i)
            a[i]+=k;
        return;
    }
    sum[belong[x]]+=(r[belong[x]]-x+1)*k;
    for(int i=x;i<=r[belong[x]];++i)
        a[i]+=k;
    for(int i=belong[x]+1;i<=belong[y]-1;++i){
        tag[i]+=k;
        sum[i]+=block*k;
    }
    sum[belong[y]]+=(y-l[belong[y]]+1)*k;
    for(int i=l[belong[y]];i<=y;++i)
        a[i]+=k;
    return;
}

ll qsum(int x,int y){
    ll ans=0;
    if(belong[x]==belong[y]){
        ans+=(y-x+1)*tag[belong[x]];
        for(int i=x;i<=y;++i)
            ans+=a[i];
        return ans;
    }
    ans+=(r[belong[x]]-x+1)*tag[belong[x]];
    for(int i=x;i<=r[belong[x]];++i)
        ans+=a[i];
    for(int i=belong[x]+1;i<=belong[y]-1;++i)
        ans+=sum[i];
    ans+=(y-l[belong[y]]+1)*tag[belong[y]];
    for(int i=l[belong[y]];i<=y;++i)
        ans+=a[i];
    return ans;
}

int main()
{
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
    read(n);read(m);
    for(int i=1;i<=n;++i)
        read(a[i]);
    build();
    int op,x,y,k;
    for(int i=1;i<=m;++i){
        read(op);
        switch(op){
            case 1:{
                read(x);read(y);read(k);
                add(x,y,k);
                break;
            }
            case 2:{
                read(x);read(y);
                printf("%lld\n",qsum(x,y));
                break;
            }
        }
    }
//  fclose(stdin);
//  fclose(stdout);
    return 0;
}

3、树状数组

#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<ctime>
#include<iostream>
#include<string>
#include<vector>
#include<list>
#include<deque>
#include<stack>
#include<queue>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<complex>
#pragma GCC optimize ("O0")
using namespace std;
template<class T> inline T read(T&x)
{
    T data=0;
    int w=1;
    char ch=getchar();
    while(!isdigit(ch))
    {
        if(ch=='-')
            w=-1;
        ch=getchar();
    }
    while(isdigit(ch))
        data=10*data+ch-'0',ch=getchar();
    return x=data*w;
}
typedef long long ll;
const int INF=0x7fffffff;

const int MAXN=1e5+7;
int n;
ll sum1[MAXN],sum2[MAXN];

int lowbit(int x)
{
    return x&-x;
}

void add(int p,ll v)
{
    for(int i=p;i<=n;i+=lowbit(i))
    {
        sum1[i]+=v,sum2[i]+=p*v;
    }
}

void range_add(int l,int r,ll v)
{
    add(l,v);
    add(r+1,-v);
}

ll ask(int p)
{
    ll res=0;
    for(int i=p;i;i-=lowbit(i))
    {
        res+=(p+1)*sum1[i]-sum2[i];
    }
    return res;
}

ll range_ask(int l,int r)
{
    return ask(r)-ask(l-1);
}

/*void add(ll p, ll x){
    for(int i = p; i <= n; i += i & -i)
        sum1[i] += x, sum2[i] += x * p;
}
void range_add(ll l, ll r, ll x){
    add(l, x), add(r + 1, -x);
}
ll ask(ll p){
    ll res = 0;
    for(int i = p; i; i -= i & -i)
        res += (p + 1) * sum1[i] - sum2[i];
    return res;
}
ll range_ask(ll l, ll r){
    return ask(r) - ask(l - 1);
}*/
int main()
{
//  freopen(".in","r",stdin);
//  freopen(".out","w",stdout);
    int m;
    read(n);read(m);
    for(int i=1;i<=n;++i)
    {
        int a;
        read(a);
        range_add(i,i,a);
    }
    while(m--)
    {
        int opt;
        read(opt);
        if(opt==1)
        {
            int l,r;
            ll v;
            read(l);read(r);read(v);
            range_add(l,r,v);
        }
        else
        {
            int l,r;
            read(l);read(r);
            printf("%lld\n",range_ask(l,r));
        }
    }
//  fclose(stdin);
//  fclose(stdout);
    return 0;
}