洛谷P2801 教主的魔法分块

最新推荐文章于 2025-08-03 15:32:57 发布

EM-LGH

最新推荐文章于 2025-08-03 15:32:57 发布

阅读量89

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/liyong1009s/article/details/83099344

本文介绍了一种基于块状划分的高效数据结构算法，用于处理大规模数据集上的区间更新和查询操作。通过将数据分为多个块并维护排好序的序列，可以实现快速的区间加法更新和查找大于等于特定值的元素数量。此算法适用于需要频繁更新和查询的场景，如在线游戏或实时数据分析。

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

我们将序列分成 $n\sqrt{n}$ 块，维护一个 $A [i]$ ， $a r r [i]$ ，即为原序列和排好序的序列。
这里的原序列指的是同一个快中的元素的相对位置不变，这样才可以进行修改。
Code:

#include<algorithm>
#include<cstdio>
#include<cmath>
#include<iostream>
using namespace std;
const int maxn = 1000000 + 3;
int n, q, block, belong[maxn];
long long arr[maxn], lazy[maxn], A[maxn];
struct Data_Structure
{
    inline int start(int i) { return (i - 1) * block + 1;}
    inline int end(int i) { return i * block;}
    inline void init()
    {
        scanf("%d%d",&n,&q);
        block = sqrt(n);
        for(int i = 1;i <= n; ++i) {
            scanf("%lld",&arr[i]);
            A[i] = arr[i];
            belong[i] = (i - 1) / block + 1;
        }
        for(int i = 1; end(i) <= n; ++i)  sort(arr + start(i), arr + min(end(i), n) + 1);
    }
    inline void update(int L, int R, int delta){
        for(int i = L; i <= min(end(belong[L]), R); ++i) A[i] += delta;                   
        for(int i = start(belong[L]); i <= min(n,end(belong[L])); ++i) arr[i] = A[i];
        sort(arr + start(belong[L]), arr + 1 + min(n, end(belong[L])));                                
        if(belong[L] != belong[R])
        {
            for(int i = start(belong[R]); i <= R; ++i) A[i] += delta;
            for(int i = start(belong[R]); i <= R; ++i) arr[i] = A[i];
            sort(arr + start(belong[R]), arr + 1 + min(end(belong[R]), n)) ;
        }
        for(int i = belong[L] + 1; i < belong[R] ; ++i) lazy[i] += delta;
    }
    inline int solve(int u,long long C)
    {
        int l = start(u), r = end(u), ans = 0;
        int R = r;
        C -= lazy[u];
        while(l <= r)
        {
            int mid = (l + r) >> 1;
            if(arr[mid] >= C) ans = mid, r = mid - 1;
            else l = mid + 1;
        }
        ans = ans == 0 ? 0 : R - ans + 1;
        return ans;
    }
    inline int query(int L, int R, long long C){
        int tmp = 0;
        for(int i = L; i <= min(end(belong[L]), R); ++i) if(arr[i] + lazy[belong[L]] >= C) ++tmp;
        if(belong[L] != belong[R])
        {
            for(int i = start(belong[R]); i <= R; ++i) if(arr[i] + lazy[belong[R]] >= C) ++tmp;
        }
        for(int i = belong[L] + 1; i < belong[R]; ++i) tmp += solve(i, C);
        return tmp;
    }
}T;
int main()
{
    T.init();
    for(int i = 1;i <= q; ++i)
    {
        char opt[10];
        int l, r, k;
        scanf("%s",opt);
        scanf("%d%d%d",&l,&r,&k);
        if(opt[0] == 'M') T.update(l, r, k);
        if(opt[0] == 'A') printf("%d\n", T.query(l, r, k));
    }
    return 0;
}