优雅的暴力---数列分块入门

最新推荐文章于 2024-09-15 08:16:50 发布
最新推荐文章于 2024-09-15 08:16:50 发布
阅读量262 收藏
点赞数 1
分类专栏： # 数据结构 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/roadtohacker/article/details/121737468
版权

数列分块

概述

区间问题一般都十分灵活，可以用线段树来解决，虽然时间复杂度可以达到 O ( l o g ( n ) ) O(log(n)) O(log(n))，但是有时候不太好写，分块可以让时间复杂度达到 O ( n ) O(\sqrt n) O(n ​)，虽然不及线段树，但是应用范围也很广，也比较简单，很有学习的必要

  • 分块思想很简单，一般把一个区间分成 n \sqrt n n ​块，如下图，如果有剩余部分，这样我们就多加一块
    在这里插入图片描述
  • 然后比如说处理一个区间 [ L , R ] [L,R] [L,R]，如果是这样
    在这里插入图片描述
  • 那么我们对于 [ L , 2 ] [L,2] [L,2]和 [ 4 , R ] [4,R] [4,R]这两块暴力处理，中间两个大块的区间整体处理，这就是分块的思想，那么就介绍完了，具体实现过程见例题

数列分块九题

https://loj.ac/p?keyword=%E6%95%B0%E5%88%97%E5%88%86%E5%9D%97

1. 区间加，单点查询

  • 设每块的大小为 b l o c k block block，那么块数应该是 ⌈ n b l o c k ⌉ \lceil \frac{n}{block}\rceil ⌈blockn​⌉，然后我们使用 b e l o n g [ i ] belong[i] belong[i]记录 i i i节点在哪个块中， L [ i ] , R [ i ] L[i],R[i] L[i],R[i]分别表示 i i i块左端点和右端点位置，具体见代码，思路很清晰，这也是树状数组和线段树的入门题
  • 更新的时候注意需要检查是不是在一个块中，如果在一个块中那么直接暴力更新，否则两端暴力，中间完整部分按照块更新
  • 注意右端点要和 n n n取一个最小值，因为右端点可能越界，主要是最后一块的问题
#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    vector<int> a(n + 1), belong(n + 1);
    int block = sqrt(n);
    int tot = n / block;
    if(n % block) tot += 1;
    for(int i=1;i<=n;i++){
        cin >> a[i];
        belong[i] = (i - 1) / block + 1;
    }
    vector<int> L(tot + 1), R(tot + 1), lazy(tot + 1);
    for(int i=1;i<=tot;i++){
        L[i] = (i - 1) * block + 1;
        R[i] = min(n, i * block);
    }
    for(int i=0;i<n;i++){
        int opt, l, r, c;
        cin >> opt >> l >> r >> c;
        if(opt == 0){
            function<void(int, int, int)> modify = [&](int l, int r, int c){
                if(belong[l] == belong[r]){
                    for(int i=l;i<=r;i++){
                        a[i] += c;
                    }
                }else{
                    for(int i=l;i<=R[belong[l]];i++){
                        a[i] += c;
                    }
                    for(int i=L[belong[r]];i<=r;i++){
                        a[i] += c;
                    }
                    for(int i=belong[l]+1;i<=belong[r]-1;i++){
                        lazy[i] += c;
                    }                    
                }
            };
            modify(l, r, c);
        }else{
            function<int(int)> query = [&](int r){
                return a[r] + lazy[belong[r]];
            };
            cout << query(r) << '\n';
        }
    }
    return 0;
}

2. 区间加，区间小于某个数的数的个数

  • 这也是一个类型题，区间加我们可以暴力，那么怎么统计区间小于某个数的个数呢？处理方法是使用另外一个数组，维护区间的单调性，然后在这个数组里面二分找小于 c c c的数的个数，看起来好像很慢，每一次更新都要把暴力修改过的块赋值给 d d d数组，而且每次都要排个序，但是其实挺快的，时间复杂度 n n n\sqrt n nn ​，这题数据 5 e 4 5e4 5e4，没问题，可能 1 e 6 1e6 1e6就不太行了
  • 二分手写吧，很好写
#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    int block = sqrt(n);
    int tot = n / block;
    if(n % block) tot += 1;
    vector<int> a(n + 1), belong(n + 1), d(n + 1);
    for(int i=1;i<=n;i++){
        cin >> a[i];
        d[i] = a[i];
        belong[i] = (i - 1) / block + 1;
    }
    vector<int> L(tot + 1), R(tot + 1), lazy(tot + 1);
    for(int i=1;i<=tot;i++){
        L[i] = (i - 1) * block + 1;
        R[i] = min(n, i * block);
        sort(d.begin() + L[i], d.begin() + R[i] + 1);
    }
    for(int i=0;i<n;i++){
        int opt, l, r, c;
        cin >> opt >> l >> r >> c;
        if(opt == 0){
            function<void(int, int, int)> modify = [&](int l, int r, int c){
                if(belong[l] == belong[r]){
                    for(int i=l;i<=r;i++){
                        a[i] += c;
                    }
                    for(int i=L[belong[l]];i<=R[belong[l]];i++){
                        d[i] = a[i];
                    }sort(d.begin() + L[belong[l]], d.begin() + R[belong[l]] + 1);
                }else{
                    for(int i=l;i<=R[belong[l]];i++){
                        a[i] += c;
                    }
                    for(int i=L[belong[l]];i<=R[belong[l]];i++){
                        d[i] = a[i];
                    }sort(d.begin() + L[belong[l]], d.begin() + R[belong[l]] + 1);
                    for(int i=L[belong[r]];i<=r;i++){
                        a[i] += c;
                    }
                    for(int i=L[belong[r]];i<=R[belong[r]];i++){
                        d[i] = a[i];
                    }sort(d.begin() + L[belong[r]], d.begin() + R[belong[r]] + 1);
                    for(int i=belong[l]+1;i<=belong[r]-1;i++){
                        lazy[i] += c;
                    }
                }
            };
            modify(l, r, c);
        }else{
            function<int(int, int, int)> query = [&](int l, int r, int c){
                int ans = 0;
                if(belong[l] == belong[r]){
                    for(int i=l;i<=r;i++){
                        if(a[i] + lazy[belong[i]] < c) ans += 1;
                    }
                }else{
                    for(int i=l;i<=R[belong[l]];i++){
                        if(a[i] + lazy[belong[i]] < c) ans += 1;
                    }
                    for(int i=L[belong[r]];i<=r;i++){
                        if(a[i] + lazy[belong[i]] < c) ans += 1;
                    }
                    for(int i=belong[l]+1;i<=belong[r]-1;i++){
                        int x = L[i];
                        int y = R[i];
                        int res = 0;
                        while(x <= y){
                            int mid = (y - x >> 1) + x;
                            if(d[mid] + lazy[i] < c){
                                res = mid + 1 - L[i];
                                x = mid + 1;
                            }else{
                                y = mid - 1;
                            }
                        }
                        ans += res;
                    }
                }
                return ans;
            };
            cout << query(l, r, c * c) << '\n';
        }
    }
    return 0;
}

3. 区间加，求前驱

  • 上一次求前驱还是在学 t r e a p treap treap树的时候，虽然现在忘得差不多了，洛谷上好像有道二叉树的题也是求前驱等等这一套东西的，求前驱的方法很多，线段树、平衡树、普通二叉树都能做，现在我们试试使用分块来解决这个问题
  • 某个数的前驱就是小于这个数的最大值，那么我们仍然用第二题的思路，用一个有序数组，然后对于一整块的元素，在这个数组里面二分查找，两侧小块部分直接暴力，如果都找不到就返回 − 1 -1 −1，注意 l a z y lazy lazy标记别忘了
#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    int block = sqrt(n);
    int tot = n / block;
    if(n % block) tot += 1;
    vector<int> a(n + 1), belong(n + 1), d(n + 1);
    for(int i=1;i<=n;i++){
        cin >> a[i];
        d[i] = a[i];
        belong[i] = (i - 1) / block + 1;
    }
    vector<int> L(tot + 1), R(tot + 1), lazy(tot + 1);
    for(int i=1;i<=tot;i++){
        L[i] = (i - 1) * block + 1;
        R[i] = min(n, i * block);
        sort(d.begin() + L[i], d.begin() + R[i] + 1);
    }
    for(int i=0;i<n;i++){
        int opt, l, r, c;
        cin >> opt >> l >> r >> c;
        if(opt == 0){
            function<void(int, int, int)> modify = [&](int l, int r, int c){
                if(belong[l] == belong[r]){
                    for(int i=l;i<=r;i++){
                        a[i] += c;
                    }
                    for(int i=L[belong[l]];i<=R[belong[l]];i++){
                        d[i] = a[i];
                    }sort(d.begin() + L[belong[l]], d.begin() + R[belong[l]] + 1);
                }else{
                    for(int i=l;i<=R[belong[l]];i++){
                        a[i] += c;
                    }
                    for(int i=L[belong[l]];i<=R[belong[l]];i++){
                        d[i] = a[i];
                    }sort(d.begin() + L[belong[l]], d.begin() + R[belong[l]] + 1);
                    for(int i=L[belong[r]];i<=r;i++){
                        a[i] += c;
                    }
                    for(int i=L[belong[r]];i<=R[belong[r]];i++){
                        d[i] = a[i];
                    }sort(d.begin() + L[belong[r]], d.begin() + R[belong[r]] + 1);
                    for(int i=belong[l]+1;i<=belong[r]-1;i++){
                        lazy[i] += c;
                    }
                }
            };
            modify(l, r, c);
        }else{
            function<int(int, int, int)> query = [&](int l, int r, int c){
                int ans = INT_MIN;
                if(belong[l] == belong[r]){
                    for(int i=l;i<=r;i++){
                        if(a[i] + lazy[belong[i]] < c){
                            ans = max(a[i] + lazy[belong[i]], ans);
                        }
                    }
                }else{
                    for(int i=l;i<=R[belong[l]];i++){
                        if(a[i] + lazy[belong[i]] < c){
                            ans = max(ans, a[i] + lazy[belong[i]]);
                        }
                    }
                    for(int i=L[belong[r]];i<=r;i++){
                        if(a[i] + lazy[belong[i]] < c){
                            ans = max(ans, a[i] + lazy[belong[i]]);
                        }
                    }
                    for(int i=belong[l]+1;i<=belong[r]-1;i++){
                        int x = L[i];
                        int y = R[i];
                        while(x <= y){
                            int mid = (y - x >> 1) + x;
                            if(d[mid] + lazy[i] < c){
                                ans = max(ans, d[mid] + lazy[i]);
                                x = mid + 1;
                            }else{
                                y = mid - 1;
                            }
                        }
                    }
                }
                return (ans == INT_MIN ? -1 : ans);
            };
            cout << query(l, r, c) << '\n';
        }
    }
    return 0;
}

4. 区间加，区间求和

  • 用一个数组维护块内和，更新的时候同时更新这个数组，思路简单，细节需要注意，且需要开long long
#include <bits/stdc++.h>

using namespace std;

#define int long long
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    vector<int> a(n + 1), belong(n + 1);
    int block = sqrt(n);
    int tot = n / block;
    if(n % block) tot += 1;
    vector<int> L(tot + 1), R(tot + 1), sum(tot + 1), lazy(tot + 1);
    for(int i=1;i<=n;i++){
        cin >> a[i];
        belong[i] = (i - 1) / block + 1;
        sum[belong[i]] += a[i];
    }
    for(int i=1;i<=tot;i++){
        L[i] = (i - 1) * block + 1;
        R[i] = min(i * block, n);
    }
    for(int i=0;i<n;i++){
        int opt, l, r, c;
        cin >> opt >> l >> r >> c;
        if(opt == 0){
            function<void(int, int, int)> modify = [&](int l, int r, int c){
                if(belong[l] == belong[r]){
                    for(int i=l;i<=r;i++){
                        a[i] += c;
                        sum[belong[i]] += c;
                    }
                }else{
                    for(int i=l;i<=R[belong[l]];i++){
                        a[i] += c;
                        sum[belong[i]] += c;
                    }
                    for(int i=L[belong[r]];i<=r;i++){
                        a[i] += c;
                        sum[belong[i]] += c;
                    }
                    for(int i=belong[l]+1;i<=belong[r]-1;i++){
                        sum[i] += (R[i] - L[i] + 1) * c;
                        lazy[i] += c;
                    }
                }
            };
            modify(l, r, c);
        }else{
            function<int(int, int, int)> query = [&](int l, int r, int c){
                int ans = 0;
                if(belong[l] == belong[r]){
                    for(int i=l;i<=r;i++){
                        ans += a[i];
                        if(ans >= c) ans %= c;
                        ans += lazy[belong[i]];
                        if(ans >= c) ans %= c;
                    }
                }else{
                    for(int i=l;i<=R[belong[l]];i++){
                        ans += a[i];
                        if(ans >= c) ans %= c;
                        ans += lazy[belong[i]];
                        if(ans >= c) ans %= c;
                    }
                    for(int i=L[belong[r]];i<=r;i++){
                        ans += a[i];
                        if(ans >= c) ans %= c;
                        ans += lazy[belong[i]];
                        if(ans >= c) ans %= c;
                    }
                    for(int i=belong[l]+1;i<=belong[r]-1;i++){
                        ans += sum[i];
                        if(ans >= c) ans %= c;
                    }
                }
                return ans;
            };
            cout << query(l, r, c + 1) << '\n';
        }
    }
    return 0;
}

5. 区间开方，区间查询

  • 区间开方的的一个思路是区间开方的总次数会很少，因为一直开方取整下去不久就会变1， 1 e 9 1e9 1e9不停开方五次就会变1；如果原来是0那么不变，所以可以考虑维护一个区间最值，分块处理就是维护每个块的最值，如果发现块最值是 0 0 0或者 1 1 1，那么这个块就不用再开方了，因为不会再改变
  • 然后再维护一个块内和，后面的处理比较简单，关键在于开方维护这里，具体见代码
#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    int block = sqrt(n);
    int tot = n / block;
    if(n % block) tot += 1;
    vector<int> a(n + 1), belong(n + 1);
    vector<int> maxn(tot + 1), sum(tot + 1);
    for(int i=1;i<=n;i++){
        cin >> a[i];
        belong[i] = (i - 1) / block + 1;
        sum[belong[i]] += a[i];
        maxn[belong[i]] = max(maxn[belong[i]], a[i]);
    }
    vector<int> L(tot + 1), R(tot + 1);
    for(int i=1;i<=tot;i++){
        L[i] = (i - 1) * block + 1;
        R[i] = min(n, i * block);
    }
    for(int k=0;k<n;k++){
        int opt, l, r, c;
        cin >> opt >> l >> r >> c;
        if(opt == 0){
            function<void(int, int)> modify = [&](int l, int r){
                if(belong[l] == belong[r]){
                    if(maxn[belong[l]] == 0 || maxn[belong[l]] == 1) return;
                    for(int i=l;i<=r;i++){
                        int past = a[i];
                        a[i] = sqrt(a[i]);
                        sum[belong[i]] -= past - a[i];
                    }
                    int mx = 0;
                    for(int i=L[belong[l]];i<=R[belong[l]];i++){
                        mx = max(mx, a[i]);
                    }
                    maxn[belong[l]] = mx;
                }else{
                    if(maxn[belong[l]] != 0 && maxn[belong[l]] != 1){
                        for(int i=l;i<=R[belong[l]];i++){
                            int past = a[i];
                            a[i] = sqrt(a[i]);
                            sum[belong[i]] -= past - a[i];
                        }
                        int mx = 0;
                        for(int i=L[belong[l]];i<=R[belong[l]];i++){
                            mx = max(mx, a[i]);
                        }
                        maxn[belong[l]] = mx;
                    }
                    if(maxn[belong[r]] != 0 && maxn[belong[r]] != 1){
                        for(int i=L[belong[r]];i<=r;i++){
                            int past = a[i];
                            a[i] = sqrt(a[i]);
                            sum[belong[i]] -= past - a[i];
                        }
                        int mx = 0;
                        for(int i=L[belong[r]];i<=R[belong[r]];i++){
                            mx = max(mx, a[i]);
                        }
                        maxn[belong[r]] = mx;
                    }
                    for(int i=belong[l]+1;i<=belong[r]-1;i++){
                        if(maxn[i] == 0 || maxn[i] == 1) continue;
                        int mx = 0;
                        for(int j=L[i];j<=R[i];j++){
                            int past = a[j];
                            a[j] = sqrt(a[j]);
                            sum[i] -= past - a[j];
                            mx = max(mx, a[j]);
                        }
                        maxn[i] = mx;
                    }
                }
            };
            modify(l, r);
        }else{
            function<int(int, int)> query = [&](int l, int r){
                int ans = 0;
                if(belong[l] == belong[r]){
                    for(int i=l;i<=r;i++){
                        ans += a[i];
                    }
                }else{
                    for(int i=l;i<=R[belong[l]];i++){
                        ans += a[i];
                    }
                    for(int i=L[belong[r]];i<=r;i++){
                        ans += a[i];
                    }
                    for(int i=belong[l]+1;i<=belong[r]-1;i++){
                        ans += sum[i];
                    }
                }
                return ans;
            };
            cout << query(l, r) << '\n';
        }
    }
    return 0;
}

6. 单点插入，单点询问

  • 这个操作使用平衡树最简单。使用分块思路是设置每个块类型为vector，每次暴力插入，对吧超级暴力，但是这会带来一个问题，如果有某一块插入了过多的元素，那么分块就会退化成更加普通的暴力，解决这个问题的办法是对块的大小进行限制，如果超过了预定的大小，那么就重新分块，这个大小可以乱搞，但是比较理性的大小选择是 2 n \sqrt{2n} 2n ​，其中 n n n表示元素的数量，注意这里 n n n的大小是变化之中的
  • 这样分块的效果是，插入时间复杂度是 O ( n ) O(\sqrt{n}) O(n ​)，有 n n n次插入，某一个块插入次数为 n \sqrt{n} n ​的时候就进行重新排布，重新分块的时间复杂度是 O ( n ) O(n) O(n)的，这样均摊时间复杂度是 O ( n n ) O(n\sqrt{n}) O(nn ​)

未经过重新分块程序如下

#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    int block = sqrt(n);
    int tot = n / block;
    if(n % block) tot += 1;
    vector<vector<int> > b(tot + 1);
    vector<int> belong(n + 1);
    for(int i=1;i<=n;i++){
        int x;
        cin >> x;
        belong[i] = (i - 1) / block + 1;
        b[belong[i]].push_back(x);
    }
    int q = n;
    while(q--){
        int opt, l, r, c;
        cin >> opt >> l >> r >> c;
        if(opt == 0){
            function<void(int, int)> modify = [&](int l, int r){
                int pt = 1;
                int sz = b[pt].size();
                while(sz < l){
                    pt += 1;
                    sz += b[pt].size();
                }
                b[pt].insert(b[pt].begin() + l - (sz - b[pt].size()) - 1, r);
            };
            modify(l, r);
        }else{
            function<int(int)> query = [&](int r){
                int pt = 1;
                int sz = b[pt].size();
                while(sz < r){
                    pt += 1;
                    sz += b[pt].size();
                }
                return b[pt][r - (sz - b[pt].size()) - 1];
            };
            cout << query(r) << '\n';
        }
    }
    return 0;
}

重新分块程序如下

#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    int block = sqrt(n);
    int tot = n / block;
    if(n % block) tot += 1;
    vector<vector<int> > b(tot + 1);
    vector<int> belong(n + 1);
    for(int i=1;i<=n;i++){
        int x;
        cin >> x;
        belong[i] = (i - 1) / block + 1;
        b[belong[i]].push_back(x);
    }
    int q = n;
    function<void()> Rebuild = [&](){
        block = sqrt(n);
        vector<int> a(n + 1);
        int top = 0;
        for(int i=1;i<=tot;i++){
            for(auto j : b[i]){
                a[++top] = j;
            }
            b[i].clear();
        }
        tot = n / block;
        if(n % block) tot += 1;
        belong.resize(top + 1);
        b.resize(tot + 1);
        for(int i=1;i<=top;i++){
            belong[i] = (i - 1) / block + 1;
            b[belong[i]].push_back(a[i]);
        }
    };
    while(q--){
        int opt, l, r, c;
        cin >> opt >> l >> r >> c;
        if(opt == 0){
            function<void(int, int)> modify = [&](int l, int r){
                int pt = 1;
                int sz = b[pt].size();
                while(sz < l){
                    pt += 1;
                    sz += b[pt].size();
                }
                b[pt].insert(b[pt].begin() + l - (sz - b[pt].size()) - 1, r);
                n += 1;
                if(b[pt].size() > 2 * block) Rebuild();
            };
            modify(l, r);
        }else{
            function<int(int)> query = [&](int r){
                int pt = 1;
                int sz = b[pt].size();
                while(sz < r){
                    pt += 1;
                    sz += b[pt].size();
                }
                return b[pt][r - (sz - b[pt].size()) - 1];
            };
            cout << query(r) << '\n';
        }
    }
    return 0;
}
  • 从时间上看好像还变慢了，但是这样时间复杂度是对的，可能换用静态数组能更快一些

7. 区间乘法，区间加法，单点询问

  • 这也是一个高级数据结构的入门操作，加法我们之前已经处理过了，那么如果加法和乘法混合该怎么办呢？注意我们是单点询问，所以lazy标记是必须要有的，所以这里面我们需要两个lazy标记，分别表示加法和乘法
  • 这两种操作我们都需要考虑整块和非整块这两种情况，对于整块，如果是一个加法操作，那么我们直接加到addlazy上面即可，如果是一个乘法操作，我们不仅需要乘到mullazy上面，我们还需要乘到addlazy上面；对于非整块，我们肯定是要暴力更新，在这之前我们必须先把这一块的lazy标记都传递下来，先乘后加，因为加法的lazy标记我们已经乘法处理过了
#include <bits/stdc++.h>

using namespace std;

const int MOD = 1e4 + 7;
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    int block = sqrt(n);
    int tot = n / block;
    if(n % block) tot += 1;
    vector<int> a(n + 1);
    vector<int> belong(n + 1);
    for(int i=1;i<=n;i++){
        cin >> a[i];
        belong[i] = (i - 1) / block + 1;
    }
    vector<int> L(tot + 1), R(tot + 1);
    vector<int> addlazy(tot + 1), mulazy(tot + 1, 1);
    for(int i=1;i<=tot;i++){
        L[i] = (i - 1) * block + 1;
        R[i] = min(n, i * block);
    }   
    for(int i=0;i<n;i++){
        int opt, l, r, c;
        cin >> opt >> l >> r >> c;
        function<void(int)> Push_Down = [&](int k){
            for(int i=L[belong[k]];i<=R[belong[k]];i++){
                a[i] = (a[i] * mulazy[belong[k]] % MOD + addlazy[belong[k]]) % MOD;
            }
            mulazy[belong[k]] = 1;
            addlazy[belong[k]] = 0;
        };
        if(opt == 0){
            function<void(int, int, int)> add = [&](int l, int r, int c){
                Push_Down(l);
                for(int i=l;i<=min(R[belong[l]], r);i++){
                    a[i] = (a[i] + c) % MOD;
                }
                if(belong[l] == belong[r]) return;
                Push_Down(r);
                for(int i=belong[l]+1;i<=belong[r]-1;i++){
                    addlazy[i] = (addlazy[i] + c) % MOD;
                }
                for(int i=L[belong[r]];i<=r;i++){
                    a[i] = (a[i] + c) % MOD;
                }
            };
            add(l, r, c);
        }else if(opt == 1){
            function<void(int, int, int)> mul = [&](int l, int r, int c){
                Push_Down(l);
                for(int i=l;i<=min(R[belong[l]], r);i++){
                    a[i] = (a[i] * c) % MOD;
                }
                if(belong[l] == belong[r]) return;
                Push_Down(r);
                for(int i=belong[l]+1;i<=belong[r]-1;i++){
                    addlazy[i] = (addlazy[i] * c) % MOD;
                    mulazy[i] = (mulazy[i] * c) % MOD;
                }
                for(int i=L[belong[r]];i<=r;i++){
                    a[i] = (a[i] * c) % MOD;
                }
            };
            mul(l, r, c);
        }else{
            function<int(int)> query = [&](int r){
                return (a[r] * mulazy[belong[r]] % MOD + addlazy[belong[r]]) % MOD;
            };
            cout << query(r) << '\n';
        }
    }
    return 0;
}

8. 区间先查询数的个数，再全改为一个数

  • 显然如果全改为一个数，我们可以给一整块做一个标记，这样查询到这个块的时候我们就可以使用这个信息，直接查询到结果，思路也是比较简单
#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin >> n;
    vector<int> a(n + 1), belong(n + 1);
    int block = sqrt(n);
    int tot = n / block;
    if(n % block) tot += 1;
    for(int i=1;i<=n;i++){
        cin >> a[i];
        belong[i] = (i - 1) / block + 1;
    }
    vector<int> L(tot + 1), R(tot + 1);
    vector<int> vis(tot + 1, -1);
    for(int i=1;i<=tot;i++){
        L[i] = (i - 1) * block + 1;
        R[i] = min(n, i * block);
    }
    for(int i=0;i<n;i++){
        int l, r ,c;
        cin >> l >> r >> c;
        function<int(int, int, int)> query = [&](int l, int r, int c){
            int ans = 0;
            if(vis[belong[l]] != -1){
                for(int i=L[belong[l]];i<=R[belong[l]];i++){
                    a[i] = vis[belong[l]];
                }
            }
            for(int i=l;i<=min(r, R[belong[l]]);i++){
                if(a[i] == c) ans += 1;
                a[i] = c;
            }
            vis[belong[l]] = -1;
            if(belong[l] == belong[r]) return ans;
            if(vis[belong[r]] != -1){
                for(int i=L[belong[r]];i<=R[belong[r]];i++){
                    a[i] = vis[belong[r]];
                }
            }
            for(int i=L[belong[r]];i<=r;i++){
                if(a[i] == c) ans += 1;
                a[i] = c;
            }
            vis[belong[r]] = -1;
            for(int i=belong[l]+1;i<=belong[r]-1;i++){
                if(vis[i] == -1){
                    for(int j=L[i];j<=R[i];j++){
                        if(a[j] == c) ans += 1;
                    }
                }
                if(vis[i] == c){
                    ans += R[i] - L[i] + 1;
                }
                vis[i] = c;
            }
            return ans;
        };
        cout << query(l, r, c) << '\n';
    }
    return 0;
}

9. 求任意两点之间的区间众数

  • 假设一共有 t o t tot tot个块，我们使用 d p [ i ] [ j ] dp[i][j] dp[i][j]表示从块 i i i到 j j j的区间最小众数，这个可以预处理出来，做法就是块之间的暴力，使用一些离散化的技巧就可以实现，具体看代码，这个时间复杂度是 O ( n n ) O(n\sqrt n) O(nn ​)
  • 这样我们来考虑怎么高效求 [ l , r ] [l,r] [l,r]的区间众数，首先预处理出来每个数所在的块和每个块的左端点右端点这些信息，然后开一个桶，每个桶是一个数，桶的标号需要离散化处理，把相同的数的标号放在桶里，那么得到的这个桶内部标号是增序排列的，这样我们就可以使用二分来求出一个区间内有多少个某个数了，接下来我们使用块内暴力，块间记录的方法就可以解出这个题
  • 这个题卡时间，常规的块大小为 n \sqrt n n ​会 T T T一个点，对于块大小的选择可以多试试，选择 n 2 \frac{\sqrt n}{2} 2n ​​作为块的大小可以通过，或者也可以使用一些常数，比如100，也能通过这个题
  • 最后注意一下我们要求的是区间众数的最小值
#include <bits/stdc++.h>

using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    cin >> n;
    int block = sqrt(n) / 2;
    int tot = n / block;
    if(n % block) tot += 1;
    vector<int> a(n + 1);
    vector<int> belong(n + 1);
    unordered_map<int, int> mp;
    int tt = 0;
    vector<vector<int> > vs(n + 1);
    vector<int> val(1);
    vector<int> L(tot + 1);
    vector<int> R(tot + 1);
    for(int i=1;i<=n;i++){
        cin >> a[i];
        if(!mp.count(a[i])){
            mp[a[i]] = ++tt;
            val.push_back(a[i]);
        }
        a[i] = mp[a[i]];
        belong[i] = (i - 1) / block + 1;
        vs[a[i]].push_back(i);
    }
    vector<vector<int> > dp(tot + 1, vector<int> (tot + 1));
    function<int(int, int, int)> Get = [&](int l, int r, int x){
        return upper_bound(vs[x].begin(), vs[x].end(), r) - lower_bound(vs[x].begin(), vs[x].end(), l);
    };
    for(int i=1;i<=tot;i++){
        L[i] = (i - 1) * block + 1;
        R[i] = min(n, i * block);
        function<void(int)> init = [&](int x){
            vector<int> cnt(tt + 1);
            int mx = INT_MIN;
            int ans = 0;
            for(int j=(x - 1) * block + 1;j<=n;j++){
                cnt[a[j]] += 1;
                if(cnt[a[j]] > mx || (cnt[a[j]] == mx && val[a[j]] < val[ans])){
                    mx = cnt[a[j]];
                    ans = a[j];
                }
                dp[x][belong[j]] = ans;
            }
        };
        init(i);
    }
    for(int k=0;k<n;k++){
        int l, r;
        cin >> l >> r;
        function<int(int, int)> query = [&](int l, int r){
            if(belong[l] == belong[r]){
                int mx = 0;
                int ans = INT_MAX;
                for(int i=l;i<=r;i++){
                    int tmp = Get(l, r, a[i]);
                    if(tmp > mx || (tmp == mx && val[ans] > val[a[i]])){
                        mx = tmp;
                        ans = a[i];
                    }
                }
                return val[ans];
            }else{
                int ans = dp[belong[l] + 1][belong[r] - 1];
                int mx = Get(l, r, ans);
                for(int i=l;i<=R[belong[l]];i++){
                    int tmp = Get(l, r, a[i]);
                    if(tmp > mx || (tmp == mx && val[ans] > val[a[i]])){
                        mx = tmp;
                        ans = a[i];
                    }
                }
                for(int i=L[belong[r]];i<=r;i++){
                    int tmp = Get(l, r, a[i]);
                    if(tmp > mx || (tmp == mx && val[ans] > val[a[i]])){
                        mx = tmp;
                        ans = a[i];
                    }
                }
                return val[ans];
            }
        };
        cout << query(l, r) << '\n';
    }
    return 0;
}
Clarence Liu
关注
专栏目录
算法-数列分块入门 7（LibreOj-6283）.rar
09-16
《算法-数列分块入门 7（LibreOj-6283）》是针对计算机科学领域中的一种常用算法技巧——数列分块进行深入解析的教程。数列分块是一种优化线性结构查询的技术，常用于解决大规模数据处理问题，尤其是在动态维护和...
算法-数列分块入门 8（LibreOj-6284）.rar
09-16
《算法-数列分块入门 8（LibreOj-6284）》是针对编程算法学习者的一份重要资源，主要讲解了数列分块这一算法思想及其在解决实际问题中的应用。数列分块作为一种优化数据结构和算法效率的方法，在处理大规模数据时尤...
高中数学公式大全-3-数列
01-22
高中数学公式大全-3-数列 高中数学公式大全-3-数列是高中数学中的一个重要组成部分，涵盖了数列的基本概念、公式和应用。本节将详细介绍数列的同项公式、等差数列、等比数列、等比差数列、分期付款等知识点，并提供...
python-算法-斐波那契数列
04-13
算法学习-斐波那契数列
算法-数列分块入门 2（LibreOj-6278）.rar
09-16
这个压缩包文件“算法-数列分块入门 2（LibreOj-6278）.rar”包含了一份关于数列分块的教程，可能是为了帮助学习者理解并解决LibreOj上的第6278题。虽然没有具体的标签信息，但我们可以从标题和描述中推测，这份资料...
算法刷题：300. 最长递增子序列、674. 最长连续递增序列、718. 最长重复子数组、1143. 最长公共子序列
qq_61936886的博客
09-12 485
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。但dp[i][0] 和dp[0][j]要初始值，因为 为了方便递归公式dp[i][j] = dp[i - 1][j - 1] + 1;2.递推公式：当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;
算法知识点——常用输入输出数据的方式
5233的博客
09-12 282
除了换行之外，还会清空缓存区，而清空缓存区这件事情会耗时很久，因此为了提高速度，一般直接：cout << “\n”;2、n组输入输出(n不确定）1、n组输入输出(n确定）3、 复杂的输入输出。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1169
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
算法基础-约数
qq_65186476的博客
09-11 307
试除法求约数、约数个数、约数之和、最大公约数
【Hot100】LeetCode—64. 最小路径和
weixin_44382896的博客
09-12 466
64. 最小路径和。
算法练习题24——查找杨辉三角中的组合数
hello77的blogggg 祝你得偿所愿
09-12 573
逐项递推法适合处理较小的数据量，计算较为直观，但当杨辉三角行数较大时，效率较低。 二分查找法利用组合数的单调性，显著提高查找效率，适合处理较大的数据范围。这两种解法在不同场景下都可以使用，二分查找法尤其适合大规模数据下的查找问题。
算法练习题22——解码
hello77的blogggg 祝你得偿所愿
09-11 382
小明有一串很长的英文字母，其中可能包含大写和小写字母。在这串字母中，有很多字母是连续且重复的。为了压缩这串字母的表达形式，小明决定将连续相同的字母用“字母 + 出现次数”的形式表示。
二分系列(二分查找)9/12
2301_78191305的博客
09-12 961
排序数组->使用二分。第一个位置:>=；第二个位置:=(target+1)-1；所以直接写一个>=的函数。
18068 选择排序
huang1xiao1sheng的博客
09-11 426
输入10个整数，编写一个实现对数组进行选择排序的函数 #include int sort(int a[], int n) { int i,j,k,tmp; for(i=0;i
【算法篇】数组类（笔记）
CXDNW的博客
09-10 797
if (nums[middle] > target) right 更新为 middle，因为当前 nums[middle] 不等于 target，去 左区间 继续寻找，而寻找 区间是 左闭右开区间，所以 right 更新为 middle，即：下一个 查询区间不会去比较 nums[middle]。一个 for 循环滑动窗口的 起始位置，一个 for 循环为滑动窗口的终止位置，用两个 for 循环 完成了一个不断搜索区间的过程。：窗口的结束位置就是遍历数组的指针，也就是 for 循环里的索引。
选择排序
shylyly_的博客
09-13 1054
每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完
【算法】动态规划—编辑距离
qq_58023907的博客
09-13 737
给你两个单词 和 ， 请返回将 转换成 所使用的最少操作数 。你可以对一个单词进行如下三种操作： 编辑距离问题就是给定两个字符串 s1 和 s2，只能用三种操作把 s1 变成 s2，求最少的操作数。需要明确的是，不管是把 s1 变成 s2 还是反过来，结果都是一样的，所以下面就以 s1 变成 s2 举例。 解决两个字符串的动态规划问题，一般都是用两个指针 i, j 分别指向两个字符串的最后，然后一步步往前走，缩小问题的规模。 设两个字符串分别为 "rad"
Python 实现 LM 算法（Levenberg-Marquardt）
最新发布
qq_42568323的博客
09-15 1151
Levenberg-Marquardt（LM）算法是求解非线性最小二乘问题的著名方法。它结合了高斯牛顿法和梯度下降法的优点，广泛用于非线性曲线拟合、机器学习、最优参数估计等领域。LM 算法的一个主要特点是能够在问题接近线性时，像高斯牛顿法一样快速收敛；而在问题严重非线性时，它通过梯度下降法的机制避免了求解发散。它是一个调和局部曲率信息与梯度信息的混合算法。在本篇博客中，我们详细介绍了 Levenberg-Marquardt 算法的基本思想、数学原理以及其 Python 的面向对象实现。
CSP-J 算法基础 图论
m0_62599305的博客
09-15 863
图论是计算机科学与离散数学中非常重要的一个分支，广泛应用于网络流、最短路径、图的连通性等众多领域。在实际问题中，许多关系可以抽象成图的形式，比如交通路线、社交网络、通信网络等。图论的核心概念包括顶点和边，通过这些基本单元可以构建不同类型的图模型。对于 CSP-J 竞赛或算法基础学习，掌握图的基本算法是非常重要的。我们经常会遇到与图相关的问题，例如最短路径问题、图的遍历（深度优先搜索与广度优先搜索）、连通分量的求解、最小生成树、最大流问题等。
LOJ-6279-数列分块入门3(分块, 二分)
05-24
(分块) $O(n\sqrt n)$ 我们可以预处理出每一个块的信息，每个块又分为若干小块，每个小块中的数都小于等于块中的最大值，可以用二分查找确定小块中满足条件的数的个数，然后用根号分治处理。 时间复杂度 每次查询...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Clarence Liu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值