指针线段树模板

#include <iostream>
#include <string>
#include <queue>
#include <vector>
using namespace std;

template<class msgT>class segT {
    /// segT 是支持单点修改区间查询的线段树
    /// msgT 是 segT 的结点信息类型
    /// 需要支持 operator + 从而进行信息合并
private:
    queue<int> opes;
    struct nodeT {
        /// nodeT 是线段树的节点数据类型
        msgT msg;
        nodeT* lch;
        nodeT* rch;
        nodeT() {
            lch = rch = NULL;/// 默认没有左右子树
        }
    };
    nodeT* root;
    int L, R;

    void maintain(nodeT* root) { /// 信息合并
        if(root -> lch && root -> rch) {
            root -> msg = root -> lch -> msg + root -> rch -> msg;
        }
    }
    void build(msgT* A, nodeT* rt, int l, int r) { /// 递归构造线段树
        //cout << " build " << l << " " << r << endl;
        if(l == r) {
            rt -> msg = A[l];
            rt -> lch = rt -> rch = NULL;
        }else {
            int mid = (l + r) >> 1;
            rt -> lch = new nodeT;
            rt -> rch = new nodeT;
            build(A, rt -> lch, l,   mid);
            build(A, rt -> rch, mid+1, r);
            maintain(rt); /// 信息合并
        }
    }
    msgT & reach(nodeT* rt, int l, int r, int x) { /// 返回某个点的 msg 的引用
        if(l == r) {
            opes.push(x); /// 记录操作序列
            return rt ->msg;
        }else {
            int mid = (l + r) >> 1;
            if(x <= mid) {
                return reach(rt -> lch, l, mid, x);
            }else {
                return reach(rt -> rch, mid+1, r, x);
            }
        }
    }
    vector<msgT> vec;
    void touch(nodeT* rt, int l, int r, int x) { /// 对某个位置对应的链进行 maintain
        if(l == r) {
            return;
        }else {
            int mid = (l + r) >> 1;
            if(x <= mid) {
                touch(rt -> lch, l, mid, x); /// 递归 touch
            }else {
                touch(rt -> rch, mid+1, r, x);
            }
            maintain(rt);
        }
    }
    void delt() { /// 处理所有没有修改完的 touch
        while(!opes.empty()) {
            int x = opes.front(); opes.pop();
            touch(root, L, R, x);
        }
        //cout << " delt done." << endl;
    }

    void loadseg(nodeT* rt, int L, int R, int l, int r) { /// 装载一个区间进入 vec
        if(r < L || R < l) return;
        if(l <= L && R <= r) {
            vec.push_back(rt -> msg);
            //cout << " push_back " << L << " " << R << endl;
            return;
        }
        int mid = (L + R) >> 1;
        loadseg(rt -> lch, L,   mid, l, r);
        loadseg(rt -> rch, mid+1, R, l, r); /// 装在区间
    }

    void rebuild(nodeT* rt) { /// 递归回收储存空间
        if(rt -> lch) rebuild(rt -> lch);
        if(rt -> rch) rebuild(rt -> rch);
        delete rt;
    }
public:
    segT() { /// 默认构造函数，构造空线段树
        root = NULL;
        L = R = 0;
    }
    segT(msgT * A, int l, int r) { /// A 是线段树复刻的原数组
        root = new nodeT;
        L = l;
        R = r;
        build(A, root, l, r); /// 通过新申请的根节点构造线段树
    }
    msgT& operator[](int index) { /// 亲民的单调修改/查询
        delt();
        return reach(root, L, R, index);
    }
    msgT operator()(int l, int r) { /// 亲民的区间和查询
        delt();
        vec.clear();
        loadseg(root, L, R, l, r);
        //cout << " load done." << endl;
        for(int i = (int)vec.size() - 1; i >= 1; i --) {
            vec[i - 1] = vec[i - 1] + vec[i]; /// 把后半装载到前半上
        }
        return vec[0];
    }

    ~segT() { /// 析构函数
        if(root != NULL) {
            rebuild(root);
        }
    }
};

int A[1000 + 1], n;

int main()
{
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> A[i];
    segT<int>* seg = new segT<int>(A, 1, n);
    cout << " build done." << endl;
    while(1) {
        int ope; cin >> ope;
        if(ope == 1) {
            /// 修改操作
            int pos, val; cin >> pos >> val;
            (*seg)[pos] = val;
            cout << " done." << endl;
        }else{
            int l, r; cin >> l >> r;
            cout << " ans = " << (*seg)(l, r) << endl;
        }
        //for(int i = 1; i  <= n; i ++) {
        //    cout << (*seg)(i, i) << " "; /// 输出外延序列
        //}
        //cout << endl;
    }
    return 0;
}