洛谷p3372 线段树2

题意：区间操作中混合了加减操作跟乘操作

思路：只要设计出不同操作之间协作的方式（propagate)，区间合并的方式即可

总结：Node重载+中，返回值mod括号位置加错了。
mul应该初始化为1，初始化错了。
少见的线段树第一次提交直接ac。

int MOD;
struct lazyNode{
    long long add;
    long long mul;
    bool is_lazy;
    lazyNode(long long add_, long long mul_):add(add_), mul(mul_), is_lazy(true){}

    lazyNode():is_lazy(false), add(0ll), mul(1ll){}

    void operator |= (const lazyNode& other){
        if (this->is_lazy == false){
            this->add = other.add;
            this->mul = other.mul;
            this->is_lazy = true;
        }
        else{
            this->add = ((this->add) * other.mul % MOD + other.add) % MOD;
            this->mul = (this->mul * other.mul % MOD);
        }
    }

    bool operator != (const lazyNode& other){
        return this->is_lazy != other.is_lazy;
    }

};

struct Node{
    long long sum;
    Node():sum(0ll){}

    Node(long long value): sum(value){}

    Node operator +(const Node& other){
        return Node((this->sum + other.sum) % MOD);
    };

    void applyLazy(lazyNode& value, int length){
        this->sum = ((this->sum * value.mul) % MOD + value.add * length % MOD) % MOD;
    }
};


template<typename T, typename U>
class SegmentTree{
public:
    SegmentTree(const vector<T>& s): sz_(int(s.size() - 1)){
        st_.resize(4 * sz_);
        lazy_.resize(4 * sz_);
        build(s, 1, 1, sz_);
    }

    void update(int i, int j, lazyNode value){
        update(1, 1, sz_, i, j, value);
    }

    long long query(int i, int j){
        return query(1, 1, sz_, i, j).sum;
    }


private:
    vector<T> st_;
    vector<U> lazy_;
    int sz_;
    const U flag_{};

    void update(int p, int l, int r, int i, int j, lazyNode value){
        propagate(p, l, r);
        if (i > j){
            return;
        }
        if (l >= i && r <= j){
            lazy_[p] = value;
            propagate(p, l, r);
            return;
        }
        int mid = (l + r) >> 1;
        update(p << 1, l, mid, i, min(mid, j), value);
        update(p << 1 | 1, mid + 1, r, max(mid + 1, i), j, value);
        st_[p] = st_[p << 1] + st_[p << 1 | 1];
    };

    T query(int p, int l, int r, int i, int j){
        propagate(p, l, r);
        if (l >= i && r <= j){
            return st_[p];
        }
        int mid = (l + r) >> 1;
        if (j <= mid) {
            return query(p << 1, l, mid, i, j);
        }
        else if (i > mid) {
            return query(p << 1 | 1, mid + 1, r, i, j);
        }
        else {
            return (query(p << 1, l, mid, i, mid) + query(p << 1 | 1, mid + 1, r, mid + 1, j));
        }
    }

    void build(const vector<T>& s, int p, int l, int r){
        if (l == r){
            st_[p] = s[l];
        }
        else{
            int mid = (l + r) >> 1;
            build(s, p << 1, l, mid);
            build(s, p << 1 | 1, mid + 1, r);
            st_[p] = st_[p << 1] + st_[p << 1 | 1];
        }
    }

    void propagate(int p, int l, int r){
        if (lazy_[p] != flag_){
            st_[p].applyLazy(lazy_[p], r - l + 1);
            if (l != r){
                lazy_[p << 1] |= lazy_[p];
                lazy_[p << 1 | 1] |= lazy_[p];
            }
            lazy_[p] = flag_;
        }
    }
};


void solve(){
    int n, m;
    cin >> n >> m >> MOD;

    vector<Node> a(n + 1);
    for (int i = 1; i <= n; ++i){
        cin >> a[i].sum;
    }

    SegmentTree<Node, lazyNode> st(a);

    while (m --){
        int k, x, y;
        cin >> k >> x >> y;
        if (k == 1){
            long long v;
            cin >> v;
            st.update(x, y, lazyNode(0ll, v));
        }
        else if (k == 2){
            long long v;
            cin >> v;
            st.update(x, y, lazyNode(v, 1ll));
        }
        else{
            cout << st.query(x, y) << '\n';
        }
    }
}