LOJ#6283. 数列分块入门 7

最新推荐文章于 2024-01-01 10:06:17 发布

转载最新推荐文章于 2024-01-01 10:06:17 发布 · 42 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：http://www.cnblogs.com/Jiaaaaaaaqi/p/9376693.html

本文介绍了一种基于块的区间更新策略，通过预处理将数组分为若干块，并使用懒惰传播来优化区间加法与乘法操作。该方法通过减少重复计算提高效率，适用于需要频繁进行区间操作的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

对于每个区间先乘在加，如果我修改的是部分的块，我就需要把现这个块的add和mul标记全部放下去，然后再更新。

#include<map>
#include<set>
#include<ctime>
#include<cmath>
#include<stack>
#include<queue>
#include<string>
#include<vector>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define first fi
#define second se
#define lowbit(x) (x & (-x))

typedef unsigned long long int ull;
typedef long long int ll;
const double pi = 4.0*atan(1.0);
const int inf = 0x3f3f3f3f;
const int maxn = 100005;
const int maxm = 100000;
const int mod = 10007;
using namespace std;

int n, m, tol, T;
int block;
int a[maxn];
int add[maxn];
int mul[maxn];
int belong[maxn];

void init() {
    memset(a, 0, sizeof a);
    memset(add, 0, sizeof add);
    memset(mul, 0, sizeof mul);
    memset(belong, 0, sizeof belong);
}

int L(int x) {
    return (x-1)*block + 1;
}

int R(int x) {
    return min(n, x*block);
}

void update1(int l, int r, int c) {
    for(int i=L(belong[l]); i<=R(belong[l]); i++) {
        a[i] = a[i] * mul[belong[i]] % mod + add[belong[i]];
        a[i] %= mod;
    }
    add[belong[l]] = 0;
    mul[belong[l]] = 1;
    for(int i=l; i<=min(r, R(belong[l])); i++) {
        a[i] += c;
        a[i] %= mod;
    }
    if(belong[l] == belong[r])    return ;
    if(belong[l] != belong[r]) {
        for(int i=L(belong[r]); i<=R(belong[r]); i++) {
            a[i] = a[i] * mul[belong[i]] % mod + add[belong[i]];
            a[i] %= mod;
        }
        add[belong[r]] = 0;
        mul[belong[r]] = 1;
        for(int i=L(belong[r]); i<=r; i++) {
            a[i] += c;
            a[i] %= mod;
        }
    }
    for(int i=belong[l]+1; i<belong[r]; i++) {
        add[i] += c;
        add[i] %= mod;
    }
}

void update2(int l, int r, int c) {
    for(int i=L(belong[l]); i<=R(belong[l]); i++) {
        a[i] = a[i] * mul[belong[i]] % mod + add[belong[i]];
        a[i] %= mod;
    }
    add[belong[l]] = 0;
    mul[belong[l]] = 1;
    for(int i=l; i<=min(r, R(belong[l])); i++) {
        a[i] *= c;
        a[i] %= mod;
    }
    if(belong[l] == belong[r])    return ;
    if(belong[l] != belong[r]) {
        for(int i=L(belong[r]); i<=R(belong[r]); i++) {
            a[i] = a[i] * mul[belong[i]] % mod + add[belong[i]];
            a[i] %= mod;
        }
        add[belong[r]] = 0;
        mul[belong[r]] = 1;
        for(int i=L(belong[r]); i<=r; i++) {
            a[i] *= c;
            a[i] %= mod;
        }
    }
    for(int i=belong[l]+1; i<belong[r]; i++) {
        add[i] *= c;
        mul[i] *= c;
        add[i] %= mod;
        mul[i] %= mod;
    }
}

int main() {
    while(~scanf("%d", &n)) {
        init();
        block = sqrt(n);
        for(int i=1; i<=n; i++) {
            scanf("%d", &a[i]);
            belong[i] = (i-1) / block + 1;
            mul[i] = 1;
        }
        m = n;
        while(m--) {
            int op, l, r, c;
            scanf("%d%d%d%d", &op, &l, &r, &c);
            if(op == 0) {
                update1(l, r, c%mod);
            } else if(op == 1) {
                update2(l, r, c%mod);
            } else {
                int ans = a[r]*mul[belong[r]]%mod + add[belong[r]]%mod;
                printf("%d\n", ans%mod);
            }
           // for(int i=1; i<=n; i++)    printf("%d%c", a[i]*mul[belong[i]]%mod + add[belong[i]]%mod, i==n ? '\n' : ' ');
        }
    }
    return 0;
}

View Code

转载于:https://www.cnblogs.com/Jiaaaaaaaqi/p/9376693.html