神器！ 线性变换线段树 —— 线段树入门及应用

在写这篇博客之前首先申明一下，这个线段树的名字是我的好队友 shu_mj 取的。由于实在很好用，对于新手容易上手所以写一篇博客造福老百姓。

然后说明一下这仅仅是一篇关于线段树入门的文章。

单点更新：

单点更新不需要标记整个线段树只需要自底向上的维护值(最小值，最大值，和等)就行了。实现难度较低，新手也能很快学会。

在线段树中每个节点的含义都是一个线段根节点表示的是1-n的线段，假设根节点标号是o，他的左子树标号为o<<1，右子树标号为o<<1|1相应的左子树表示的区间为1-m(m=(l+r)>>1)，而右子树表示的区间为m+1-r

这样我们用一颗高度为logn 的树即可表示整条线段了。

对于单点更新的线段树每个标记都能下放到最底层，由于每次下放标记最多沿着一路走所以每次操作的复杂度为logn的。

对于求和的时候我们把区间不断的拆分用线段树上的小区间（节点表示的区间）来拼成需要求和的完整区间，最后将这些节点上的标记累加起来即为答案。复杂度同样为logn的。

代码如下：

int num[LEN], sum[4*LEN], n;

void pushup(int o){
    sum[o] = sum[o<<1] + sum[o<<1|1];
}

void build(int l, int r, int o){
    if(l == r){
        //设初值
        return ;
    }
    int m = (l + r)/2;
    build(l, m, o<<1);
    build(m+1, r, o<<1|1);
    pushup(o);
}

void update(int l, int r, int o, int pos, int val){
    if(l == r) {
        sum[o] += val;
        return ;
    }
    int m = (l + r)/2;
    if(pos <= m) update(l, m, o<<1, pos, val);
    else update(m+1, r, o<<1|1, pos, val);
    pushup(o);
}

int query(int l, int r, int o, int L, int R){
    if(l >= L && r <= R) return sum[o];
    int m = (l + r) / 2, ret = 0;
    if(L <= m) ret += query(l, m, o<<1, L, R);
    if(R > m) ret += query(m+1, r, o<<1|1, L, R);
    return ret;
}

区间更新：

区间更新相比较单点更新来说就要难很多了。首先我们要设计一个懒惰标记，为什么要设计这个标记呢？

我们若是在每次更新线段树的时候都更新至最底层那么复杂度显然会退化成线性的，因此我们给每个节点上都添加了一个懒惰标记若是不访问以这个节点为根的子树，这个标记就停留在这个节点。等到需要访问以这个节点为根的子树的时候在把标记pushdown到他的左右孩子上。这样复杂度就维持了nlogn了。在统计的时候和单点更新类似，只是在访问孩子节点之前需要把懒惰标记下放。

线性变换线段树：

所谓线性变换，就是我们的线段树能处理ax+b这种操作。现在线段树的常用操作有add，mul，set无论是哪种我们都可以使用线性变换得到。

add v: 1*x+v mul v：v*x+0 set v: 0*x+v 

怎么样很方便吧。

这样一来我们就可以将这份线段树存为模板了，足以应付一般的线段树题目了。线性变换线段树由于维护了多余的信息多以时间效率可能不那么令人满意。

代码如下：

struct SegmentTree {
    ll _sum[4*LEN], _mul[4*LEN], _add[4*LEN];
    SegmentTree(){}
    
    void Display(int l, int r, int o, int d){
        if(l == r){
            for(int i=0; i<d; i++) cout << "	";
            cout << _sum[o] << "(" << l << ", " << r << ")" << endl;
            return ;
        }
        int m = (l + r) / 2;
        Display(l, m, o<<1, d+1);
        for(int i=0; i<d; i++) cout << "	";
        cout << _sum[o] << "(" << l << ", " << r << ")" << endl;
        Display(m+1, r, o<<1|1, d+1);
    }

    void init(){
        for(int i=0; i<4*LEN; i++){
            _mul[i] = 1; _add[i] = 0;
        }
    }

    void pushup(int o){
        _sum[o] = _sum[o<<1] + _sum[o<<1|1];
    }

    void push(int o, int l, int r, ll adval, ll muval){
        _sum[o] *= muval;
        _mul[o] *= muval;
        _add[o] *= muval;

        _sum[o] += (r-l+1) * adval;
        _add[o] += adval;
    }

    void pushdown(int o, int l, int r){
        int m = (l + r) / 2;
        push(o << 1, l, m, _add[o], _mul[o]);
        push(o << 1 | 1, m+1, r, _add[o], _mul[o]);
        _add[o] = 0; _mul[o] = 1;
    }

    void build(int l, int r, int o){
        if(l == r){
            scanf("%lld", &_sum[o]);
            return ;
        }
        int m = (l + r) / 2;
        build(l, m, o<<1);
        build(m+1, r, o<<1|1);
        pushup(o);
    }

    void update(int l, int r, int o, int L, int R, ll adval, ll muval){
        if(L <= l && R >= r){
            push(o, l, r, adval, muval);
            return ;
        }
        pushdown(o, l, r);
        int m = (l + r) / 2;
        if(L <= m) update(l, m, o<<1, L, R, adval, muval);
        if(R > m) update(m+1, r, o<<1|1, L, R, adval, muval);
        pushup(o);
    }

    ll query(int l, int r, int o, int L, int R){
        if(L <= l && R >= r){
            return _sum[o];
        }
        pushdown(o, l, r);
        int m = (l + r) / 2;
        ll ret = 0;
        if(L <= m) ret += query(l, m, o<<1, L, R);
        if(R > m) ret += query(m+1, r, o<<1|1, L, R);
        return ret;
    }
};

最后，我用了这一份模板ac了一道2013杭州邀请赛的纯线段树的题目在以前不用这份模板的时候我写了5600K的代码再ac，而使用了模板之后瞬间代码量减小2K+

代码如下：

#include <cstdio>
#include <algorithm>
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef pair<int, int> pii;
typedef pair<int, pii> piii;
const int MOD = 10007;
const int LEN = 100000+10;

void getsum(piii &a, piii b){
    a.first += b.first; a.first %= MOD;
    a.second.first += b.second.first; a.second.first %= MOD;
    a.second.second += b.second.second; a.second.second %= MOD;
}

struct SegmentTree {
    int _sum[4*LEN], _mul[4*LEN], _add[4*LEN], _sum2[4*LEN], _sum3[4*LEN];

    void init(){
        for(int i=0; i<4*LEN; i++){
            _mul[i] = 1; _add[i] = 0;
            _sum[i] = _sum2[i] = _sum3[i] = 0;
        }
    }

    void pushup(int o){
        _sum[o] = (_sum[o<<1] + _sum[o<<1|1]) % MOD;
        _sum2[o] = (_sum2[o<<1] + _sum2[o<<1|1]) % MOD;
        _sum3[o] = (_sum3[o<<1] + _sum3[o<<1|1]) % MOD;
    }

    void push(int o, int l, int r, int adval, int muval){
        _sum3[o] *= (muval * muval % MOD * muval % MOD);
        _sum2[o] *= (muval * muval % MOD);
        _sum[o] *= muval;
        _sum[o] %= MOD; _sum2[o] %= MOD; _sum3[o] %= MOD;
        _mul[o] *= muval;
        _add[o] *= muval;
        _mul[o] %= MOD; _add[o] %= MOD;
        
        _sum3[o] += (3*adval%MOD*_sum2[o]%MOD + 3*adval%MOD*adval%MOD*_sum[o]%MOD);
        _sum3[o] += ((r-l+1)*adval%MOD*adval%MOD*adval%MOD);
        _sum2[o] += (2*adval%MOD*_sum[o]%MOD + (r-l+1)*adval%MOD*adval%MOD);
        _sum[o] += (r-l+1) * adval;
        _sum3[o] %= MOD; _sum2[o] %= MOD; _sum[o] %= MOD;
        _add[o] += adval; _add[o] %= MOD;
    }

    void pushdown(int o, int l, int r){
        int m = (l + r) / 2;
        push(o << 1, l, m, _add[o], _mul[o]);
        push(o << 1 | 1, m+1, r, _add[o], _mul[o]);
        _add[o] = 0; _mul[o] = 1;
    }

    void build(int l, int r, int o){
        if(l == r){
            _sum[o] = _sum2[o] = _sum3[o] = 0;
            return ;
        }
        int m = (l + r) / 2;
        build(l, m, o<<1);
        build(m+1, r, o<<1|1);
        pushup(o);
    }

    void update(int l, int r, int o, int L, int R, int adval, int muval){
        if(L <= l && R >= r){
            push(o, l, r, adval, muval);
            return ;
        }
        pushdown(o, l, r);
        int m = (l + r) / 2;
        if(L <= m) update(l, m, o<<1, L, R, adval, muval);
        if(R > m) update(m+1, r, o<<1|1, L, R, adval, muval);
        pushup(o);
    }

    piii query(int l, int r, int o, int L, int R){
        if(L <= l && R >= r){
            return MP(_sum[o], MP(_sum2[o], _sum3[o]));
        }
        pushdown(o, l, r);    
        int m = (l + r) / 2;
        piii ret = MP(0, MP(0, 0));
        if(L <= m) getsum(ret, query(l, m, o<<1, L, R));
        if(R > m) getsum(ret, query(m+1, r, o<<1|1, L, R));
        return ret;
    }
};

SegmentTree sg;

int main()
{
    int n, m, op, L, R, val;
    while(scanf("%d%d", &n, &m) != EOF){
        if(!n && !m) break;
        sg.init(); sg.build(1, n, 1);
        for(int i=0; i<m; i++){
            scanf("%d%d%d%d", &op, &L, &R, &val);
            if(op == 1){
                sg.update(1, n, 1, L, R, val, 1);
            }else if(op == 2){
                sg.update(1, n, 1, L, R, 0, val);
            }else if(op == 3){
                sg.update(1, n, 1, L, R, val, 0);
            }else {
                piii ans = sg.query(1, n, 1, L, R);
                if(val == 1) printf("%d
", ans.first);
                else if(val == 2) printf("%d
", ans.second.first);
                else printf("%d
", ans.second.second);
            }
        }
    }
    return 0;
}