洛谷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& 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 st_;
vector 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& 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 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';
}
}
}