回顾树状数组

　　树状数组是一种常用的数据结构，能够在O(log₂n)的时间内进行单点修改和求前缀和。因为代码量小、常熟小往往在某些应用中快于线段树(当然有些问题是不能呢用树状数组完成的)。

最基本的树状数组

　　方法1:用一个数组，O(1)修改, O(n)查询

　　方法2:求前缀和，O(n)修改，O(1)查询

　　以上两种方法卡一卡就TLE了。

　　树状数组就平衡了一下这两种方法，修改的时候多修改一点，查询的时候多算一点。

　　为了清楚地明白树状数组是如何运作的，我们实现定义 lowbit(x) 是写成2进制后的x中最后一位1。例如(10)₁₀ = (1010)₂，则lowbit(10) = (10)₂ = (2)₁₀.

　　树状数组本质上就是一个长度为n的数组，但是它的每一个位置管辖另一些位置(就是它们的和)，对于一个节点i，它的数据同时会被加在节点(i + lowbit(i))上。例如下面这幅图。

　　至于计算这个lowbit通常是用这么一个快捷的方法:

#define lowbit(x) ((x) & (-x))

　　对于修改操作，就不断去更新管辖当前节点的节点，直到超出范围。

inline void add(int idx, LL val) {
    for(; idx <= s; idx += lowbit(idx))
        a[idx] += val;
}

　　现在证明修改操作是O(log₂n)的。

　　1) 当 idx 写成2进制后，1的个数不为1时，每次 idx += lowbit(idx) 时，至少有1个1进位，显然至多log₂idx次这样的操作idx写成二进制后就只有1个1了（1　　　　的个数只会减少不会增加）

　　2) 当 idx 写成2进制后，1的个数为1时，显然lowbit(idx) = idx，所以每次加倍，但是又不能超过n，最多进行log₂n次这样的操作。

　　所以修改操作的时间复杂度时O(log₂n)。

　　观察上面，可以发现一个有趣的结论，树状数组的一个节点i存的值，恰好是原数组中lowbit(i)个连续的元素和的和。

　　所以求前缀和的操作，就向前依次去加它没有算到的原数组的数(不是暴力，是直接加树状数组中节点的值)

inline LL getSum(int idx) {
    LL rt = 0;
    for(; idx; idx -= lowbit(idx))
        rt += a[idx];
    return rt;
}

　　对于求任意一段区间的和就前缀和减减就好了。

各种乱搞的树状数组

支持区间修改单点查询的树状数组

　　这个似乎不是树状数组的本职工作，但还是可以做的。

　　差分是一个离线的"算法"吧，能够支持O(1)修改，O(n)查询(但是只能在最后查询)。

　　差分数组满足一个性质，就是位置i的前缀和是在它真正的值。(差分数组秋求前缀和后得到的是原数组)

　　不懂差分数组的就看张图吧:

　　（差分数组的前缀和就是原数组）

　　既然差分数组能够快速地进行区间修改(本质上时单点修改)，求单点是靠求前缀和实现。而树状数组支持单点修改和快速求前缀和，于是用树状数组维护差分数组就能快速做到单点查询和区间修改。

支持区间修改区间查询的树状数组

　　也许你认为线段树可以完成，但是对于这种水题不想出动线段树(懒得写)，这时就可以考虑一下树状数组。

　　树状数组可以优秀地利用差分来求单点，所以先考虑暴力用差分求前缀和(考虑差分数组每个位置被计算的次数)。

　　

　　这个还可以化简原式。然后发现这两个都可以用树状数组维护，然后对于任意区间减一减就好了。

Code

/**
 * Codevs
 * Problem#1082
 * Accepted
 * Time:430ms
 * Memory:11240k
 */
#include <iostream>
#include <cstdio>
#include <ctime>
#include <cmath>
#include <cctype>
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <algorithm>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <vector>
#include <stack>
#ifndef WIN32
#define Auto "%lld"
#else
#define Auto "%I64d"
#endif
using namespace std;
typedef bool boolean;
const signed int inf = (signed)((1u << 31) - 1);
const signed long long llf = (signed long long)((1ull << 63) - 1);
const double eps = 1e-6;
const int binary_limit = 128;
#define smin(a, b) a = min(a, b)
#define smax(a, b) a = max(a, b)
#define max3(a, b, c) max(a, max(b, c))
#define min3(a, b, c) min(a, min(b, c))
template<typename T>
inline boolean readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && x != -1);
    if(x == -1) {
        ungetc(x, stdin);    
        return false;
    }
    if(x == '-'){
        x = getchar();
        aFlag = -1;
    }
    for(u = x - '0'; isdigit((x = getchar())); u = (u * 10) + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
    return true;
}

#define LL long long
#define lowbit(x) (x & (-x))

typedef class IndexedTree {
    public:
        LL* a;
        int s;
        IndexedTree():a(NULL), s(0) {        }
        IndexedTree(int n):s(n) {
            a = new LL[(n + 1)];
            memset(a, 0, sizeof(LL) * (n + 1));
        }
        
        inline void add(int idx, LL val) {
            for(; idx <= s; idx += lowbit(idx))
                a[idx] += val;
        }
        
        inline LL getSum(int idx) {
            LL rt = 0;
            for(; idx; idx -= lowbit(idx))
                rt += a[idx];
            return rt;
        }
}IndexedTree;

typedef class SegmentableIndexedTree {
    public:
        LL *a;
        LL *ps;                    // prefix sum
        IndexedTree s;            // sum
        IndexedTree us;            // unique sum
        
        SegmentableIndexedTree():a(NULL) {        }
        SegmentableIndexedTree(int n, LL *a):a(a) {
            s = IndexedTree(n + 1);
            us = IndexedTree(n + 1);
            ps = new LL[(n + 1)];
            ps[0] = 0;
            for(int i = 1; i <= n; i++)
                ps[i] = ps[i - 1] + a[i];
        }
        
        inline void add(int l, int r, LL val) {
            s.add(l, val), us.add(l, l * val);
            s.add(r + 1, -val), us.add(r + 1, -(r + 1) * val);
        }
        
        inline LL getSum(int idx) {
            return (idx + 1) * s.getSum(idx) - us.getSum(idx);
        }
        
        inline LL getSum(int l, int r) {
            return ps[r] - ps[l - 1] + getSum(r) - getSum(l - 1);
        }
}SegmentableIndexedTree;

int n, m;
LL *a;
SegmentableIndexedTree sit;

inline void init() {
    readInteger(n);
    a = new LL[(n + 1)];
    for(int i = 1; i <= n; i++)
        readInteger(a[i]);
}

inline void solve() {
    int opt, l, r, x;
    sit = SegmentableIndexedTree(n, a);
    readInteger(m);
    while(m--) {
        readInteger(opt);
        readInteger(l);
        readInteger(r);
        if(opt == 1) {
            readInteger(x);
            sit.add(l, r, x);
        } else {
            printf(Auto"
", sit.getSum(l, r));
        }
    }
}

int main() {
    init();
    solve();
    return 0;
}