数列分块入门

已于 2022-08-15 13:01:09 修改
阅读量140 收藏
点赞数 1
文章标签： 算法 数据结构
于 2022-08-14 22:33:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/eyuhaobanga/article/details/126337130
版权

献上数列分块入门题单

传送门

数列分块->优雅的暴力，根据题目可以按照\sqrt{n}或者log(n)作为一个块的大小，不同分块方法时间复杂度的瓶颈不同

数列分块入门 1

区间加法，单点求值

AC代码：

#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
using namespace std;
using LL = long long;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n;
    cin >> n;
    vector<int> a(n + 1), add(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    int len = sqrt(n);
    function<int(int)> get = [&](int x) {
        return (x - 1) / len;
    };
    function<void(int, int, int)> update = [&](int l, int r, int c) {
        if (get(l) == get(r)) {
            for (int i = l; i <= r; i++) {
                a[i] += c;
            }
        }
        else {
            int i = l, j = r;
            while (get(i) == get(l)) {
                a[i++] += c;
            }
            while (get(j) == get(r)) {
                a[j--] += c;
            }
            for (int k = get(i); k <= get(j); k++) {
                add[k] += c;
            }
        }
    };
    function<int(int)> query = [&](int x) {
        return a[x] + add[get(x)];
    };
    for (int i = 0; i < n; i++) {
        char op;
        int l, r, c;
        cin >> op;
        cin >> l >> r >> c;
        if (op == '0') {
            update(l, r, c);
        }
        else {
            cout << query(r) << '\n';
        }
    }
 
    return 0;
}

数列分块入门 2

区间加法，区间查询小于某个值的元素个数

AC代码：

#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
using namespace std;
using LL = long long;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;
    int len = sqrt(n);
    vector<int> a(n + 1), add(n + 1), L(n + 1, 0x3f3f3f3f);
    vector<vector<int>> v(n + 1);
    auto get = [&](int x) {
        return x / len;
    };

    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        int x = get(i);
        L[x] = min(i, L[x]);
        v[x].push_back(a[i]);
    }

    for (int i = 0; i <= n / len; i++) {
        sort(v[i].begin(), v[i].end());
    }

    function<void(int)> resort = [&](int x) {
        v[x].clear();
        int i = L[x];

        while (get(i) == x and i <= n) {
            v[x].push_back(a[i++]);
        }

        sort(v[x].begin(), v[x].end());
    };
    function<void(int, int, int)> update = [&](int l, int r, int c) {
        if (get(l) == get(r)) {
            for (int i = l; i <= r; i++) {
                a[i] += c;
            }

            resort(get(l));
        } else {
            int i = l, j = r;

            while (get(i) == get(l)) {
                a[i++] += c;
            }

            while (get(j) == get(r)) {
                a[j--] += c;
            }

            resort(get(l)), resort(get(r));

            for (int k = get(i); k <= get(j); k++) {
                add[k] += c;
            }
        }
    };
    function<int(int, int, int)> query = [&](int l, int r, int c) {
        int ans = 0;

        if (get(l) == get(r)) {
            for (int i = l; i <= r; i++) {
                if (a[i] + add[get(i)] < c) {
                    ans++;
                }
            }
        } else {
            int i = l, j = r;

            while (get(i) == get(l)) {
                if (a[i++] + add[get(l)] < c) {
                    ans++;
                }
            }

            while (get(j) == get(r)) {
                if (a[j--] + add[get(r)] < c) {
                    ans++;
                }
            }

            for (int k = get(i); k <= get(j); k++) {
                ans += lower_bound(v[k].begin(), v[k].end(), c - add[k]) - v[k].begin();
            }
        }

        return ans;
    };

    for (int i = 0; i < n; i++) {
        char op;
        int l, r, c;
        cin >> op >> l >> r >> c;

        if (op == '0') {
            update(l, r, c);
        } else {
            cout << query(l, r, c * c) << '\n';
        }
    }

    return 0;
}

数列分块入门 3

区间加法，区间询问比某个值小的最大元素

AC代码：

#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
using namespace std;
using LL = long long;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n;
    cin >> n;
    int len = sqrt(n);
    vector<int> a(n + 1), add(n + 1), L(n + 1, 0x3f3f3f3f);
    vector<vector<int>> v(n + 1);
    auto get = [&](int x) {
        return x / len;
    };
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        int x = get(i);
        L[x] = min(i, L[x]);
        v[x].push_back(a[i]);
    }
    for (int i = 0; i <= n / len; i++) {
        sort(v[i].begin(), v[i].end());
    }
    function<void(int)> resort = [&](int x) {
        v[x].clear();
        int i = L[x];
        while (get(i) == x and i <= n) {
            v[x].push_back(a[i++]);
        }
        sort(v[x].begin(), v[x].end());
    };
    function<void(int, int, int)> update = [&](int l, int r, int c) {
        if (get(l) == get(r)) {
            for (int i = l; i <= r; i++) {
                a[i] += c;
            }
            resort(get(l));
        }
        else {
            int i = l, j = r;
            while (get(i) == get(l)) {
                a[i++] += c;
            }
            while (get(j) == get(r)) {
                a[j--] += c;
            }
            resort(get(l)), resort(get(r));
            for (int k = get(i); k <= get(j); k++) {
                add[k] += c;
            }
        }
    };
    function<int(int, int, int)> query = [&](int l, int r, int c) {
        int ans = -1;
        if (get(l) == get(r)) {
            for (int i = l; i <= r; i++) {
                if (a[i] + add[get(i)] < c) {
                    ans = max(ans, a[i] + add[get(i)]);
                }
            }
        }
        else {
            int i = l, j = r;
            while (get(i) == get(l)) {
                if (a[i++] + add[get(l)] < c) {
                    ans = max(ans, a[i - 1] + add[get(l)]);
                }
            }
            while (get(j) == get(r)) {
                if (a[j--] + add[get(r)] < c) {
                    ans = max(ans, a[j + 1] + add[get(r)]);
                }
            }
            for (int k = get(i); k <= get(j); k++) {
                int id = lower_bound(v[k].begin(), v[k].end(), c - add[k]) - v[k].begin();
                if (id - 1 >= 0 and id - 1 < v[k].size() and v[k][id - 1] < c - add[k]) {
                    ans = max(ans, v[k][id - 1] + add[k]);
                }
            }
        }
        return ans;
    };
    for (int i = 0; i < n; i++) {
        char op;
        int l, r, c;
        cin >> op >> l >> r >> c;
        if (op == '0') {
            update(l, r, c);
        }
        else {
            cout << query(l, r, c) << '\n';
        }
    }
 
    return 0;
}

数列分块入门 4

区间加法，区间求和

AC代码：

#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
using namespace std;
using LL = long long;
#define int long long
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n;
    cin >> n;
    int len = sqrt(n);
    vector<int> a(n + 1), add(n + 1), sum(n + 1);
    auto get = [&](int x) {
        return x / len;
    };
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        int x = get(i);
        sum[x] += a[i];
    }
    function<void(int, int, int)> update = [&](int l, int r, int c) {
        if (get(l) == get(r)) {
            for (int i = l; i <= r; i++) {
                a[i] += c;
                sum[get(l)] += c;
            }
        }
        else {
            int i = l, j = r;
            while (get(i) == get(l)) {
                a[i++] += c;
                sum[get(l)] += c;
            }
            while (get(j) == get(r)) {
                a[j--] += c;
                sum[get(r)] += c;
            }
            for (int k = get(i); k <= get(j); k++) {
                add[k] += c;
                sum[k] += c * len;
            }
        }
    };
    function<int(int, int, int)> query = [&](int l, int r, int c) {
        int ans = 0;
        if (get(l) == get(r)) {
            for (int i = l; i <= r; i++) {
                ans += a[i] + add[get(l)];
            }
        }
        else {
            int i = l, j = r;
            while (get(i) == get(l)) {
                ans += a[i++] + add[get(l)];
            }
            while (get(j) == get(r)) {
                ans += a[j--] + add[get(r)];
            }
            for (int k = get(i); k <= get(j); k++) {
                ans += sum[k];
            }
        }
        return ans;
    };
    for (int i = 0; i < n; i++) {
        char op;
        int l, r, c;
        cin >> op >> l >> r >> c;
        if (op == '0') {
            update(l, r, c);
        }
        else {
            c++;
            int ans = query(l, r, c) % c;
            cout << (ans + c) % c << '\n';
        }
    }
 
    return 0;
}

数列分块入门 5

区间开方，区间求和

在区间开方时，在计算a[i]比原先少了多少时，要将sqrt()强制转换为int，否则在计算过程中是按照double类型计算，而在赋值时按照int赋值，会出现误差

AC代码：

#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
using namespace std;
using LL = long long;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n;
    cin >> n;
    int len = sqrt(n);
    vector<int> a(n + 1), L(n + 1, 0x3f3f3f3f), sum(n + 1);
    vector<bool> flag(n + 1);
    auto get = [&](int x) {
        return x / len;
    };
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        int x = get(i);
        L[x] = min(i, L[x]);
        sum[x] += a[i];
    }
    function<void(int, int)> update = [&](int l, int r) {
        if (get(l) == get(r)) {
            for (int i = l; i <= r; i++) {
                int tmp = a[i] - (int)sqrt(a[i]);
                a[i] = sqrt(a[i]);
                sum[get(l)] -= tmp;
            }
        }
        else {
            int i = l, j = r;
            while (get(i) == get(l)) {
                int tmp = a[i] - (int)sqrt(a[i]);
                a[i] = sqrt(a[i]);
                sum[get(l)] -= tmp;
                i++;
            }
            while (get(j) == get(r)) {
                int tmp = a[j] - (int)sqrt(a[j]);
                a[j] = sqrt(a[j]);
                sum[get(r)] -= tmp;
                j--;
            }
            for (int k = get(i); k <= get(j); k++) {
                if (flag[k]) {
                    continue;
                }
                int res = 0;
                int x = L[k];
                while (get(x) == k and x <= n) {
                    int tmp = a[x] - (int)sqrt(a[x]);
                    a[x] = sqrt(a[x]);
                    res += tmp;
                    sum[k] -= tmp;
                    x++;
                }
                if (res == 0) {
                    flag[k] = true;
                }
            }
        }
    };
    function<int(int, int)> query = [&](int l, int r) {
        int ans = 0;
        if (get(l) == get(r)) {
            for (int i = l; i <= r; i++) {
                ans += a[i];
            }
        }
        else {
            int i = l, j = r;
            while (get(i) == get(l)) {
                ans += a[i++];
            }
            while (get(j) == get(r)) {
                ans += a[j--];
            }
            for (int k = get(i); k <= get(j); k++) {
                ans += sum[k];
            }
        }
        return ans;
    };
    for (int i = 0; i < n; i++) {
        char op;
        int l, r, c;
        cin >> op >> l >> r >> c;
        if (op == '0') {
            update(l, r);
        }
        else {
            cout << query(l, r) << '\n';
        }
    }
 
    return 0;
}

数列分块入门 6

单点插入，单点询问

如果连续插入使得一个块内特别大而其它块特别小，则要进行重构，使得所有块大小相对均匀

AC代码：

#include <bits/stdc++.h>
#define rep(i,a,n) for(int i=a;i<n;i++)
using namespace std;
using LL = long long;
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
 
    int n;
    cin >> n;
    int len = sqrt(n), cnt = 0;
    vector<int> a(n + 1), L(n + 1, 0x3f3f3f3f), sum(n + 1);
    vector<vector<int>> v(n + 1);
    auto get = [&](int x) {
        return x / len;
    };
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        int x = get(i);
        v[x].push_back(a[i]);
    }
    function<pair<int, int>(int)> query = [&](int r) {
        int k = 0;
        while (r > v[k].size()) {
            r -= v[k].size();
            k++;
        }
        return make_pair(k, r - 1);
    };
    function<void(int, int)> insert = [&](int l, int r) {
        pair<int, int> q = query(l);
        v[q.first].insert(v[q.first].begin() + q.second, r);
    };
    function<void(void)> rebuild = [&]() {
        vector<int> nxt;
        for (int i = 0; i <= n; i++) {
            if (v[i].size()) {
                for (auto j : v[i]) {
                    nxt.push_back(j);
                }
            }
            else {
                break;
            }
            v[i].clear();
        }
        len = sqrt(nxt.size());
        for (int i = 0; i < nxt.size(); i++) {
            int x = get(i);
            v[x].push_back(nxt[i]);
        }
    };
    for (int i = 0; i < n; i++) {
        char op;
        int l, r, c;
        cin >> op >> l >> r >> c;
        if (op == '0') {
            cnt++;
            insert(l, r);
            if (cnt % len == 0) {
                rebuild();
            }
        }
        else {
            pair<int, int> ans = query(r);
            cout << v[ans.first][ans.second] << '\n';
        }
    }
 
    return 0;
}

eyuhaobanga
关注
数列分块入门 1
weixin_34318956的博客
05-15 67
分块入门 分好块就能写。。 #include <bits/stdc++.h> #define INF 0x3f3f3f3f #define full(a, b) memset(a, b, sizeof a) using namespace std; typedef long long ll; inline int lowbit(int x){ return x & (-x); ...
A . 数列分块入门1
qq_52088931的博客
08-17 131
A . 数列分块入门1 [ 讨论 ] Description 给出一个长为n 的数列，以及 n 个操作，操作涉及区间加法，单点查值。 Input 第一行输入一个数字n。 第二行输入n个数字，第i个数字为ai，以空格隔开。 接下来输入n行询问，每行输入四个数字opt,l,r,c，以空格隔开。 若opt=0，表示将位于[l,r]的之间的数字都加c。 若opt=1，表示询问ar 的值（l和c忽略）。 Output 对于每次询问，输出一行一个数字表示答案。 Samples Input 复制 4 1 2 2 3 0
1 数列分块入门_LOJ 6277：数列分块入门 1（分块入门）
weixin_39993989的博客
12-20 116
#6277. 数列分块入门 1内存限制：256 MiB时间限制：100 ms标准输入输出题目类型：传统评测方式：文本比较题目描述给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。输入格式第一行输入一个数字n。第二行输入n个数字，第i个数字为ai，以空格隔开。接下来输入n行询问，每行输入四个数字opt、l、r、c，以空格隔开。若opt=0，表示将位于[l,...
数列分块入门1--LOJ
孤风的博客
09-03 602
数列分块入门 1 题目链接https://loj.ac/problem/6277 内存限制：256 MiB时间限制：100 ms 题目描述 给出一个长为 n 的数列，以及 n个操作，操作涉及区间加法，单点查值。 输入格式 第一行输入一个数字。 第二行输入 n 个数字，第 i 个数字为 ai，以空格隔开。 接下来输入n 行询问，每行输入四个数字opt,l,r,c以空格隔...
算法-数列分块入门 7（LibreOj-6283）.rar
09-16
《算法-数列分块入门 7（LibreOj-6283）》是针对计算机科学领域中的一种常用算法技巧——数列分块进行深入解析的教程。数列分块是一种优化线性结构查询的技术，常用于解决大规模数据处理问题，尤其是在动态维护和...
算法-数列分块入门 8（LibreOj-6284）.rar
09-16
《算法-数列分块入门 8（LibreOj-6284）》是针对编程算法学习者的一份重要资源，主要讲解了数列分块这一算法思想及其在解决实际问题中的应用。数列分块作为一种优化数据结构和算法效率的方法，在处理大规模数据时尤...
算法-数列分块入门 2（LibreOj-6278）.rar
09-16
这个压缩包文件“算法-数列分块入门 2（LibreOj-6278）.rar”包含了一份关于数列分块的教程，可能是为了帮助学习者理解并解决LibreOj上的第6278题。虽然没有具体的标签信息，但我们可以从标题和描述中推测，这份资料...
算法-数列分块入门 5（LibreOj-6281）.rar
09-16
这个压缩包文件“算法-数列分块入门 5（LibreOj-6281）.rar”包含了一份关于数列分块的详细教程，主要针对LibreOj上的第6281道题目进行解析。本文将深入探讨数列分块的基本概念、应用场景以及解题策略。 首先，数列...
算法-数列分块入门 6（LibreOj-6282）.rar
09-16
《算法-数列分块入门 6（LibreOj-6282）》是针对计算机算法领域中一种常用的技术——数列分块技术进行详细介绍的资源。数列分块是解决大规模数据处理和在线算法问题时的一种有效策略，尤其在面对动态查询和更新的...
数列分块入门【By hzwer】
Dust_heart的博客
04-13 2259
数列分块入门【By hzwer】 给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。 给出一个长为n的数列，以及n个操作，操作涉及区间加法，询问区间内小于某个值x的元素个数。 给出一个长为n的数列，以及n个操作，操作涉及区间加法，询问区间内小于某个值x的前驱（比其小的最大元素）。
【算法笔记】数列分块入门
最新发布
luhaoren2009的博客
08-03 205
分块不能说是一种数据结构，它是一种思想，无论是数列分块，块状链表，还是数论分块，莫队算法，都应用了分块的思想。本文主要介绍狭义上的分块，即数列分块。
数据结构——分块：数列分块入门
Lunar Arc的博客
03-14 360
数据结构——分块：数列分块入门数列分块入门1题目算法分析Code数列分块入门4题目算法分析Code反思与总结 最近在学习分块，在这里分享一下联系的几道习题。 关于何为分块，请阅读 这篇文章 以下是分块的经典联系题。 LOJ：数列分块入门1-9 下面来分享最近完成的数列分块入门1和数列分块入门4。 数列分块入门1 题目 算法分析 详细见 数据结构——分块入门 Code #include<iostream> #include<cstdio> #include<algorithm&
1 数列分块入门_数列分块入门1（区间加法）
weixin_39683734的博客
12-20 88
题解：对于区间的所有元素加c并要求单点的值。显然可以用线段树来求，但本篇要用新的方法来求。令：m为每一个块的大小，且m为根号n向下取整。每个块大小为m,共有n/m个块由于每次不完整的块大小较少，即每次操作时间复杂度为。又因根据均值不等式当时时间复杂度最少。所以每个块的大小为:。规定：m=sqrt(n)//每个块的大小pos[i] //i是第几个块sum[i] //第i个块的标记对于每一组操作,先暴...
1.数列分块入门 1
HeartFireY的博客
09-22 236
???? | Powered By HeartFireY | 分块例题 [#6277. 数列分块入门 1 - 题目 - LibreOJ (loj.ac)](https://loj.ac/p/6277) 首先将输入的序列分块，分为n\sqrt{n}n​个块，对于区间加的操作，我们对于区间内的元素分类操作： 对于区间内的整块，我们单独设置一个块标记； 对于区间内的不完整块，我们直接暴力单点加。 每mmm个元素分为一块，共有n/mn/mn/m块，每次区间加的操作会涉及O(n/m)O(n/m)O(n/m)个整块
LOJ-6279-数列分块入门3(分块, 二分)
05-24
题目描述 给定一个长度为n的序列a，有m次询问。每次询问给定l, r, k，要求区间[l, r]中第k小的数。 输入格式 第一行两个整数n,m。 接下来一行n个整数，表示序列a。 接下来m行，每行三个整数l,r,k。 输出格式 对于每个询问，输出一行一个数，表示区间[l, r]中第k小的数。 输入样例 5 3 1 3 2 4 5 1 5 2 2 4 1 3 5 3 输出样例 2 3 5 算法1 (分块) $O(n\sqrt n)$ 我们可以预处理出每一个块的信息，每个块又分为若干小块，每个小块中的数都小于等于块中的最大值，可以用二分查找确定小块中满足条件的数的个数，然后用根号分治处理。 时间复杂度 每次查询的时间复杂度是 $O(\sqrt n\log n)$ 的，总时间复杂度是 $O(n\sqrt n\log n)$ 的。 参考文献 算法竞赛进阶指南 C++ 代码 算法2 (二分答案) $O(n\log^2n)$ 我们二分答案，然后统计序列中小于等于这个答案的数的个数，统计方法可以用归并排序，在时间复杂度 $O(n\log n)$ 的时间内完成。 时间复杂度 每次查询的时间复杂度是 $O(n\log^2n)$ 的，总时间复杂度是 $O(mn\log^2n)$ 的。 参考文献 算法竞赛进阶指南 C++ 代码
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值