日常刷题2025-2-20

合集 - 日常刷题(44)

1.日常刷题2025-3-1603-162.日常训练2025-1-201-023.日常训练2025-1-301-034.日常训练2025-1-501-055.日常训练2025-1-801-086.日常训练2025-1-1101-117.日常训练2025-1-1201-128.日常训练2025-1-1301-139.日常训练2025-1-1401-1410.日常训练2025-1-1501-1511.日常训练2025-1-1601-1612.日常训练2025-1-1701-1713.日常训练2025-1-1801-1814.日常训练2025-1-1901-1915.日常训练2025-1-2101-2116.日常训练2025-1-2201-2217.日常刷题2025-1-2301-2318.日常训练2025-1-2401-2419.日常刷题2025-1-2501-2520.日常刷题02-0121.日常刷题2025-2-602-0622.日常刷题2025-2-902-0923.日常刷题2025-2-1402-1424.日常刷题2025-2-1502-1525.日常刷题2025-2-1702-17

26.日常刷题2025-2-2002-20

27.日常刷题2025-2-2102-2128.日常刷题2025-2-2202-2229.日常刷题2025-2-2402-2430.日常刷题2025-2-2602-2631.日常刷题2025-2-2702-2732.日常刷题2025-2-2802-2833.日常刷题2025-3-103-0134.日常刷题2025-3-203-0235.日常刷题2025-3-303-0336.日常刷题2025-3-503-0537.日常刷题2025-3-603-0638.日常刷题2025-3-703-0739.日常刷题2025-3-803-0840.日常刷题2025-3-903-0941.日常刷题2025-3-1003-1042.日常刷题2023-3-1103-1143.日常刷题2025-3-1303-1344.非常棒的二分和DP03-15

收起

日常刷题2025-2-20

lz的序列问题

思路：常规线段树

比较常规的线段树。

代码

#include <bits/stdc++.h>
#define lson (rt << 1)
#define rson (rt << 1 | 1)
 
using i64 = long long;
 
const int mod = 1000000007;
 
int a[200005];
struct node {
    i64 v, rmx, lz;
}tr[200005 << 2];
 
i64 ksm(i64 a, i64 b) {
    i64 res = 1;
    while(b) {
        if (b & 1) {
            res = res * a % mod;
        }
        b >>= 1;
        a = a * a % mod;
    }
 
    return res;
}
 
node mer(node x, node y) {
    if (x.v == 0) return y;
    node res = {0, 0, 0};
    res.v = x.rmx * y.v % mod + x.v;
    res.v %= mod;
    res.rmx = x.rmx * y.rmx % mod;
    return res;
}
 
void push_down(int rt, int l, int r) {
    if (tr[rt].lz) {
        int mid = l + r >> 1;
        int x = tr[rt].lz;
        
        tr[lson].lz = x;
        tr[rson].lz = x;
 
        if (tr[rt].lz == 1) {
            tr[lson].v = mid - l + 1;
            tr[rson].v = r - mid;
 
            tr[lson].rmx = 1;
            tr[rson].rmx = 1;
        }
        else {
            tr[lson].v = (ksm(x, mid - l + 1) - 1) * x % mod * ksm(x - 1, mod - 2) % mod;
            tr[rson].v = (ksm(x, r - mid) - 1) * x % mod * ksm(x - 1, mod - 2) % mod;
 
            tr[lson].rmx = ksm(x, mid - l + 1);
            tr[rson].rmx = ksm(x, r - mid);
        }
        
        tr[rt].lz = 0;
    }
}
 
void build(int rt, int l, int r) {
    if (l == r) {
        tr[rt].v = a[l];
        tr[rt].rmx = a[l]; 
        return;
    }
 
    int mid = l + r >> 1;
    build(lson, l, mid);
    build(rson, mid + 1, r);
    tr[rt] = mer(tr[lson], tr[rson]);
}
 
void update(int rt, int l, int r, int L, int R, int x) {
    if (l >= L && r <= R) {
        tr[rt].lz = x;
        if (x == 1) {
            tr[rt].v = r - l + 1;
            tr[rt].rmx = 1;
        }
        else {
            tr[rt].v = (ksm(x, r - l + 1) - 1) * x % mod * ksm(x - 1, mod - 2) % mod;
            tr[rt].rmx = ksm(x, (r - l + 1));
        }
        return;
    }
 
    push_down(rt, l, r);
 
    int mid = l + r >> 1;
    if (mid >= L)
        update(lson, l, mid, L, R, x);
    if (mid < R) {
        update(rson, mid + 1, r, L, R, x);
    }
    tr[rt] = mer(tr[lson], tr[rson]);
}
 
node query(int rt, int l, int r, int L, int R) {
    if (l >= L && r <= R) {
        return tr[rt];
    }
 
    push_down(rt, l, r);
    node res = {0, 0, 0};
 
    int mid = l + r >> 1;
    if (mid >= L) {
        res = mer(res, query(lson, l, mid, L, R));
    }
    if (mid < R){
        res = mer(res, query(rson, mid + 1, r, L, R));
    }
    return res;
}
 
void solve() {
    int n, m;
    std::cin >> n >> m;
 
    for (int i = 1; i <= n; i++) {
        std::cin >> a[i];
    }
 
    build(1, 1, n);
 
    while (m--) {
        int op;
        std::cin >> op;
        if (op == 1) {
            int l, r, x;
            std::cin >> l >> r >> x;
            update(1, 1, n, l, r, x);
        }
        else {
            int l, r;
            std::cin >> l >> r;
            std::cout << query(1, 1, n, l, r).v << '\n';
        }
    }
}
 
signed main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    std::cout.tie(0);
 
    int t = 1;
    // std::cin >> t;
    while (t--) {
        solve();
    }
 
    return 0;
}