线段树模板

线段树的类

class Segment_tree
{
public:
    Segment_tree(int size, int a[]) 
    {
        arr = new int[size];
        tree = new int[size << 2];
        for (int i = 0; i < size; ++i) {
            arr[i] = a[i];
        }
        build_tree(arr, tree, 0, 0, size - 1);
        //从0节点开始建树，0节点涵盖的范围是0到size - 1;
    }

    void build_tree(int arr[], int tree[], int node, int start, int end)
    {
        //使用递归构建线段树，node是当前要建立的节点，start和end为当前节点所表示的范围
        if (start == end) {
            tree[node] = arr[start];
            return;
        }
        int left_node = 2 * node + 1;
        int right_node = 2 * node + 2;
        int mid = (start + end) / 2;
        build_tree(arr, tree, left_node, start, mid);
        build_tree(arr, tree, right_node, mid + 1, end);
        tree[node] = tree[left_node] + tree[right_node];
    }

    void update_tree(int arr[], int tree[], int node, int start, int end, int idx, int val) {
        //node为当前正在搜索的节点，进入第一层递归的时候node都是0节点
        //idx为要修改的节点在arr中的编号
        //start和end是当前正在搜索的区间，默认都是0 - size - 1
        if (start == end) {
            arr[idx] = val;
            tree[node] = val;
            return;
        }
        int mid = (start + end) / 2;
        int left_node = 2 * node + 1;
        int right_node = 2 * node + 2;
        update_tree(arr, tree, left_node, start, mid, idx, val);
        update_tree(arr, tree, right_node, mid + 1, end, idx, val);
        tree[node] = tree[left_node] + tree[right_node];
    }

    int query_tree(int arr[], int tree[], int node, int start, int end, int L, int R) {
        //start和end是当前正在搜索的区间，默认都是0 - size - 1
        //L R 为目标查询区间
        if (end < L or start > R)
            return 0;
        else if (start == end)
            return tree[node];
        else if (start >= L and end <= R)
            //当前查询的区间位于目标区间之中，可以直接返回值
            return tree[node];
        int mid = (start + end) / 2;
        int left_node = 2 * node + 1;
        int right_node = 2 * node + 2;
        //
        int sum_left = query_tree(arr, tree, left_node, start, mid, L, R);
        int sum_right = query_tree(arr, tree, right_node, mid + 1, end, L, R);
        return sum_left + sum_right;
    }
private:
    int* arr;
    int* tree;
};

#include <iostream>

using namespace std;
using ll = long long;
using p = pair<int, int>;
const int maxn(1e5 + 10);

struct node {
    int l, r;
    ll sum, lz;
} tree[maxn << 2];

template<typename T = int>
inline const T read()
{
    T x = 0, f = 1;
    char ch = getchar();
    while (ch < '0' || ch > '9') {
        if (ch == '-') f = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 3) + (x << 1) + ch - '0';
        ch = getchar();
    }
    return x * f;
}

template<typename T>
inline void write(T x, bool ln)
{
    if (x < 0) {
        putchar('-');
        x = -x;
    }
    if (x > 9) write(x / 10, false);
    putchar(x % 10 + '0');
    if (ln) putchar(10);
}

inline int ls(int cur)
{
    return cur << 1;
}

inline int rs(int cur)
{
    return cur << 1 | 1;
}

void push_up(int cur)
{
    tree[cur].sum = tree[ls(cur)].sum + tree[rs(cur)].sum;
}

void push_down(int cur)
{
    if (tree[cur].lz) {
        tree[ls(cur)].sum += (tree[ls(cur)].r - tree[ls(cur)].l + 1) * tree[cur].lz;
        tree[rs(cur)].sum += (tree[rs(cur)].r - tree[rs(cur)].l + 1) * tree[cur].lz;
        tree[ls(cur)].lz += tree[cur].lz;
        tree[rs(cur)].lz += tree[cur].lz;
        tree[cur].lz = 0;
    }
}

void build(int cur, int l, int r)
{
    tree[cur].l = l;
    tree[cur].r = r;
    tree[cur].lz = 0;
    if (l == r) {
        tree[cur].sum = read();
        return;
    }
    int mid = (l + r) >> 1;
    build(ls(cur), l, mid);
    build(rs(cur), mid + 1, r);
    push_up(cur);
}

void update(int cur, int l, int r, int v)
{
    if (tree[cur].l == l and tree[cur].r == r) {
        tree[cur].sum += (r - l + 1) * v;
        tree[cur].lz += v;
        return;
    }
    push_down(cur);
    int mid = (tree[cur].l + tree[cur].r) >> 1;
    if (r <= mid) {
        update(ls(cur), l, r, v);
    } else if (l > mid) {
        update(rs(cur), l, r, v);
    } else {
        update(ls(cur), l, mid, v);
        update(rs(cur), mid + 1, r, v);
    }
    push_up(cur);
}

ll query(int cur, int l, int r)
{
    if (tree[cur].l == l and tree[cur].r == r) {
        return tree[cur].sum;
    }
    push_down(cur);
    int mid = (tree[cur].l + tree[cur].r) >> 1;
    if (r <= mid) return query(ls(cur), l, r);
    if (l > mid) return query(rs(cur), l, r);
    return query(ls(cur), l, mid) + query(rs(cur), mid + 1, r);
}

int main()
{
#ifdef ONLINE_JUDGE
#else
    freopen("input.txt", "r", stdin);
#endif
    int n = read(), m = read();
    build(1, 1, n);
    while (m--) {
        int t = read(), x = read(), y = read();
        if (t == 1) {
            int k = read();
            update(1, x, y, k);
        } else {
            write(query(1, x, y), true);
        }
    }
    return 0;
}