树状数组演示用例

本文参考树状数组详解

单点更新，单点查询

其实没啥好讲的，就是数组的更新与查询操作，因此直接pass掉。
我之所以还把这个章节放在这里，是为了和树状数组其他类型的查询和更新操作相区别。

单点更新，区间查询

从上面的这棵树上可以看出：

C[1] = A[1];
C[2] = A[1] + A[2];
C[3] = A[3];
C[4] = A[1] + A[2] + A[3] + A[4];
C[5] = A[5];
C[6] = A[5] + A[6];
C[7] = A[7];
C[8] = A[1] + A[2] + A[3] + A[4] + A[5] + A[6] + A[7] + A[8]

总结出规律可得：
C[i] = A[i - 2^k+1] + A[i - 2^k+2] + … + A[i]; //k为i的二进制中从最低位到高位连续零的长度(例如i = 8(1000)时候，k = 3)
而sum[i] = C[i] + C[i-Lowbit(i)] + C[i-Lowbit(i)-Lowbit(i-Lowbit(i))] …; (sum[i]是指前i项和);
tips:

2^k = i&(-i)
原因：
$$x\&(-x)=\{\begin{array}{rcl}能整除x的最大的2的幂& & \\ (可以因此得知x的二进制表示后面跟了几个0)& & x是偶数\\ 1& & x是奇数\end{array}$$

int n;
int a[1005],c[1005]; //对应原数组和树状数组

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

void updata(int i,int k){    //在i位置加上k
    while(i <= n){
        c[i] += k;
        i += lowbit(i);
    }
}

int getsum(int i){        //求A[1...i]的和,即sum[i]
    int res = 0;
    while(i > 0){
        res += c[i];
        i -= lowbit(i);
    }
    return res;
}

int main(){
    int t;
    cin>>t;
    for(int tot = 1; tot <= t; tot++){
        cout << "Case " << tot << ":" << endl;
        memset(a, 0, sizeof a);
        memset(c, 0, sizeof c);
        cin>>n;
        for(int i = 1; i <= n; i++){
            cin>>a[i];
            updata(i,a[i]);   //输入初值的时候，也相当于更新了值
        }

        string s;
        int x,y;
        while(cin>>s && s[0] != 'E'){
            cin>>x>>y;
            if(s[0] == 'Q'){    //求和操作
                int sum = getsum(y) - getsum(x-1);    //x-y区间和也就等于1-y区间和减去1-(x-1)区间和
                cout << sum << endl;
            }
            else if(s[0] == 'A'){
                updata(x,y);
            }
            else if(s[0] == 'S'){
                updata(x,-y);    //减去操作，即为加上相反数
            }
        }

    }
    return 0;
}

区间更新，单点查询

题目描述：

这就是第一个问题，如果题目是让你把x-y区间内的所有值全部加上k或者减去
k，然后查询操作是问某个点的值。

思路导引：

这种时候该怎么做呢。如果是像上面的树状数组来说，就必须把x-y区间内每个值都更新，这样的复杂度肯定是不行的，这个时候，就不能再用数据的值建树了，这里我们引入差分，利用差分建树。

思路解释：

先设置A[0] = 0;
则有$$A[i]=\sum _{j=1}^{n}D[j](D[j]=A[i]-A[i-1])[前面i项的差值和]$$
例如对于下面这个数组
A[] = 1 2 3 5 6 9
D[] = 1 1 1 2 1 3
如果我们将A[1…4]区间内的元素都加上2，则变成了
A[] = 1 4 5 7 8 9
D[] = 1 3 1 2 1 1
可以看到A[2…4]区间内元素差值不变,但是区间端点D[1]与D[5]有改变。
因此，思路就变成只需要将区间的端点即D[1]和D[5]的值统统加上k即可。

int n,m;
int a[50005] = {0},c[50005]; //对应原数组和树状数组

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

void updata(int i,int k){    //在i位置加上k
    while(i <= n){
        c[i] += k;
        i += lowbit(i);
    }
}

int getsum(int i){        //求D[1...i]的和，即A[i]值
    int res = 0;
    while(i > 0){
        res += c[i];
        i -= lowbit(i);
    }
    return res;
}

int main(){
    cin>>n;
    for(int i = 1; i <= n; i++){
        cin>>a[i];
        updata(i,a[i] - a[i-1]);   //输入初值的时候，也相当于更新了值
    }
    
    //[x,y]区间内加上k
    updata(x,k);    //A[x] - A[x-1]增加k
    updata(y+1,-k);        //A[y+1] - A[y]减少k
    
    //查询i位置的值
    int sum = getsum(i);

    return 0;
}

区间更新，区间查询

思路导引：

上面我们说的差值建树状数组，得到的是某个点的值，那如果我既要区间更新，又要区间查询怎么办。这里我们还是利用差分。

思路解释：
$$\sum _{i=1}^{n}A[i]=\sum _{i=1}^n\sum _{j=1}^{i}D[j]$$
则A[1] + A[2] + A[3] + … + A[n]
= (D[1]) + (D[1]+D[2]) + … + (D[1]+D[2]+…+D[n])
= nD[1] + (n-1)D[2] +… +D[n]
= n * (D[1]+D[2]+…+D[n]) - (0D[1]+1D[2]+…+(n-1)*D[n])
因此上式变为
$$\sum _{i=1}^{n}A[i]=n\ast \sum _{i=1}^{n}D[i]-\sum _{i=1}^n(D[i]\ast (i-1))$$
所以显而易见
我们需要计算sum1[i] = D[i]以及sum2[i] = (D[i] * (i - 1))
然后先依次计算$$D1=\sum _{i=1}^{n}sum1[i]和D2=\sum _{i=1}^{n}sum2[i]$$ 。之后再计算n * D1 - D2即可得A[i] 的前i项和 [此处其实退化成了(单点更新，区间查询)]

int n,m;
int a[50005] = {0};
int sum1[50005];    //(D[1] + D[2] + ... + D[n])
int sum2[50005];    //(1*D[1] + 2*D[2] + ... + n*D[n])

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

void updata(int i,int k){
    int x = i;    //因为x不变，所以得先保存i值
    while(i <= n){
        sum1[i] += k;
        sum2[i] += k * (x-1);
        i += lowbit(i);
    }
}

int getsum(int i){        //求前缀和
    int res = 0, x = i;
    while(i > 0){
        res += x * sum1[i] - sum2[i];
        i -= lowbit(i);
    }
    return res;
}

int main(){
    cin>>n;
    for(int i = 1; i <= n; i++){
        cin>>a[i];
        updata(i,a[i] - a[i-1]);   //输入初值的时候，也相当于更新了值
    }

    //[x,y]区间内加上k
    updata(x,k);    //A[x] - A[x-1]增加k
    updata(y+1,-k);        //A[y+1] - A[y]减少k

    //求[x,y]区间和
    int sum = getsum(y) - getsum(x-1);
    return 0;
}