洛谷P3373线段树

洛谷P3373

线段树模板题，主要对懒标的处理要求比较高。
有三种操作：

1. 区间加法
2. 区间乘法
3. 区间求和查询

tips：我们对一个区间进行乘k操作的时候，他之前可能存在加法lazy还没pushdown，这时候，加法lazy和乘法lazy都需要乘k。因为这个lazy是为儿子节点准备的，儿子还没进行加法操作，这次的乘法肯定也会作用于前面的加法。

另外，线段树的一些基本知识点漏洞这次也暴露了出来： pushdown操作，我们知道，每个结点的懒标都是为儿子结点准备的，所以在查询/修改到x结点的时候不需要pushdown，即将查询/修改x的儿子结点的时候才需要pushdown。

AC代码：

long long a[100010];
long long mod;
long long n, m;
struct node
{
     
    long long k, l, r, sum, lazy1, lazy2; //lazy1 乘法懒标，lazy2加法懒标
} tr[400040];

void update(long long k)
{
     
    tr[k].sum = (tr[k * 2].sum + tr[k * 2 + 1].sum) % mod;
}
void build(long long k, long long l, long long r)
{
     
    tr[k].l = l;
    tr[k].r = r;
    tr[k].lazy1 = 1;
    tr[k].lazy2 = 0;
    if (tr[k].l == tr[k].r)
    {
     
        tr[k].sum = a[l] % mod;
        return;
    }
    long long mid = l + r >> 1;
    build(k * 2, l, mid);
    build(k * 2 + 1, mid + 1, r);
    update(k);
}

inline void pushdown(long long k)
{
     
    tr[k * 2].sum = (tr[k * 2].sum * tr[k].lazy1 + (tr[k * 2].r - tr[k * 2].l + 1) * tr[k].lazy2) % mod;
    tr[k * 2 + 1].sum = (tr[k * 2 + 1].sum * tr[k].lazy1 + (tr[k * 2 + 1].r - tr[k * 2 + 1].l + 1) * tr[k].lazy2) % mod;
    tr[k * 2].lazy1 = (tr[k * 2].lazy1 * tr[k].lazy1) % mod;
    tr[k * 2 + 1].lazy1 = (tr[k * 2 + 1].lazy1 * tr[k].lazy1) % mod;
    tr[k * 2].lazy2 = (tr[k].lazy1 * tr[k * 2].lazy2 + tr[k].lazy2) % mod;
    tr[k * 2 + 1].lazy2 = (tr[k].lazy1 * tr[k * 2 + 1].lazy2 + tr[k].lazy2) % mod;
    tr[k].lazy1 = 1;
    tr[k].lazy2 = 0;
}

void change(long long k, long long l, long long r, long long opt, long long val)
{
     
    if (tr[k].l == l && tr[k].r == r)
    {
     
        if (opt == 1)
        {
     
            tr[k].sum = (tr[k].sum * val) % mod;
            tr[k].lazy1 = (tr[k].lazy1 * val) % mod;
            tr[k].lazy2 = (tr[k].lazy2 * val) % mod; //！做乘法的时候对lazy1和lazy2都要改变
        }
        else
        {
     
            tr[k].sum = (tr[k].sum + val * (tr[k].r - tr[k].l + 1)) % mod;
            tr[k].lazy2 = (tr[k].lazy2 + val) % mod;
        }
        return;
    }
    pushdown(k);
    long long mid = tr[k].l + tr[k].r >> 1;
    if (r <= mid)
    {
     
        change(k * 2, l, r, opt, val);
    }
    else if (l > mid)
    {
     
        change(k * 2 + 1, l, r, opt, val);
    }
    else
    {
     
        change(k * 2, l, mid, opt, val);
        change(k * 2 + 1, mid + 1, r, opt, val);
    }
    update(k);
}

long long query(long long k, long long l, long long r)
{
     
    if (l == tr[k].l && r == tr[k].r)
        return tr[k].sum;
    pushdown(k);

    long long mid = (tr[k].l + tr[k].r) >> 1;
    if (r <= mid)
        return query(k * 2, l, r);
    else if (l > mid)
        return query(k * 2 + 1, l, r);
    else
        return (query(k * 2, l, mid) + query(k * 2 + 1, mid + 1, r)) % mod;
}

void test(long long k)
{
     
    pushdown(k);
    printf("%lld %lld %lld %lld\n", k, tr[k].l, tr[k].r, tr[k].sum);
    if (tr[k].l != tr[k].r)
    {
     
        test(k * 2);
        test(k * 2 + 1);
    }
    return;
}
int main()
{
     
    scanf("%lld %lld %lld", &n, &m, &mod);
    for (long long i = 1; i <= n; i++)
        scanf("%lld", &a[i]);
    build(1, 1, n);
    while (m--)
    {
     
        long long opt;
        scanf("%lld", &opt);
        if (opt == 1)
        {
     
            long long a, b, c;
            scanf("%lld %lld %lld", &a, &b, &c);
            change(1, a, b, opt, c);
        }
        else if (opt == 2)
        {
     
            long long a, b, c;
            scanf("%lld %lld %lld", &a, &b, &c);
            change(1, a, b, opt, c);
        }
        else
        {
     
            long long a, b;
            scanf("%lld %lld", &a, &b);
            printf("%lld\n", query(1, a, b));
        }
    }
    return 0;
}