【树状数组区间修改区间求和】codevs 1082 线段树练习 3

http://codevs.cn/problem/1082/

【AC】

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn=2e5+2;
int n;
ll a[maxn];
ll c1[maxn];
ll c2[maxn];
int lowbit(int x)
{
    return x&-x;
}
void add(ll *c,int k,ll val)
{
    while(k<=n){
        c[k]+=val;
        k+=lowbit(k);
    }
}
ll query(ll *c,int k)
{
    ll ans=0;
    while(k)
    {
        ans+=c[k];
        k-=lowbit(k);
    }
    return ans;
}
ll solve(int x)
{
    ll ans=0;
    ans+=x*query(c1,x);
    ans-=query(c2,x);
    return ans; 
}
ll solve(int x,int y)
{
    return solve(y)-solve(x-1); 
}
int main()
{
    while(~scanf("%d",&n))
    {
        a[0]=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%I64d",&a[i]);
        //    cout<<a[i]<<endl;
            add(c1,i,a[i]-a[i-1]);
            add(c2,i,(i-1)*(a[i]-a[i-1]));
        } 
        int q;
        scanf("%d",&q);
        int tp;
        while(q--)
        {
            scanf("%d",&tp);
            if(tp==1)
            {
                int x,y;ll val;
                scanf("%d%d%I64d",&x,&y,&val);    
                add(c1,x,val);
                add(c1,y+1,-val);
                add(c2,x,1ll*(x-1)*val);
                add(c2,y+1,-1ll*y*val);
            }
            else
            {
                int x,y;
                scanf("%d%d",&x,&y);
                ll ans=solve(x,y);
                printf("%I64d
",ans);
            }
        }
    }
    return 0;
}

【原理】

原理是用了差分数组，转载自http://www.cnblogs.com/boceng/p/7222751.html

树状数组时间复杂度为O(MlogN)， 实际用的时候优于线段树，且写得少。

神牛是引入了差分数组，要维护的差分数组ks[i] = a[i] - a[i-1]; 可以容易得到a[i] = ks[1] + ks[2] + ... + ks[i]; 即前i项和，为方便记为sigma(ks, i)，已经可以看到树状数组的影子了，所以求区间和随之得到

a[1] + a[2] + .. + a[n] = sigma(ks, 1) + sigma(ks, 2) + ... + sigma(ks, n);

  = n*ks[1] + (n-1)*ks[2] + ... + 2*ks[n-1] + 1*ks[n];

       =  n*(ks[1] + ks[2] +...+ ks[n]) - (0*ks[1] + 1*ks[2] + ... + (n-1)*ks[n]);

所以可以得到 sum[n] =n * sigma(ks, n)  - (0*ks[1] + 1*ks[2] + ... + (n-1)*ks[n]);

令jk[i] = (i-1) * ks[i];

则 sum[n] = n * sigma(ks, n) - sigma(jk, n);

之后便是构造两个树状数组；

int lowbit(int k){
    return k & -k;
}
void add(int n, int *c, int k, int va){
    while(k <= n){
        c[k] += va;
        k += lowbit(k);
    }
}

//-------------------------------------

for(i = 1; i <= n; ++i){
        add(n, c1, i, jk[i]-jk[i-1]);
        add(n, c2, i, (i-1)*(jk[i]-jk[i-1]));
    }

然后进行查询求和

int sigma(int *c, int k){
    int sum = 0;
    while(k){
        sum += c[k];
        k -= lowbit(k);
    }
    return sum;
}
int getSum(int s, int t){
    return (t*sigma(c1, t)-sigma(c2, t)) - ((s-1)*sigma(c1, s-1)-sigma(c2, s-1));
}

进行单点查询时，只需两个参数均传入该点。

在进行区间更新的时候，神牛市通过两次维护c1，两次c2得到的，但本人推测了几种情况，都不能很好的解释这么做的原因，

void update(int s, int t, int va){
    add(c1, s, va);
    add(c1, t+1, -va);
    add(c2, s, va*(s-1));
    add(c2, t+1, -va*t);
}