【分块入门】LOJ 数列分块入门 1 - 9 (学习更新……)

最新推荐文章于 2022-04-25 21:39:41 发布
置顶 最新推荐文章于 2022-04-25 21:39:41 发布
阅读量2k 收藏 2
点赞数
分类专栏： # 分块 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44049850/article/details/103999581
版权

dl题解 _「分块」数列分块入门1 – 9 by hzwer

LOJ #6277. 数列分块入门 1

  • 题意：给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。
  • 时间限制：100ms

分块

  • 我们将整个数列划分为很多块，暂且分为n / m块，用block[ i ]记录第 i 个数据arr[ i ]对应的块的个数。O(n)【数据读入时就可以操作完成，block[ i ] = (i - 1) / m + 1】
  • 如果操作的区间涉及我们划分的“一整块”，那么我们可以直接用一个标记数组lazy[ ]来记录该“块”的add值。最大O(n / m)
  • 而操作区间两侧的“非完整的块”，至多有2m个元素，那么就直接暴力更新每个数据的值。最大O(m)
  • 所以区间操作的复杂度就是O(m) + O(n / m)，根据均值不等式：a + b >= 2sqrt(ab)，可以得到当m = sqrt(n)时，复杂度最优
  • 因为只有单点查询，所以某个点的答案就是arr[ i ] + lazy[ block[ i ] ]。O(1)
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define INF 0x3f3f3f3f
#define lowbit(x) x & (-x)

#define MID (l + r ) >> 1
#define lsn rt << 1
#define rsn rt << 1 | 1
#define Lson lsn, l, mid
#define Rson rsn, mid + 1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define eps  1e-6

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxN = 5e4 + 5;
int n, m, arr[maxN];
int block[maxN];
int lazy[maxN];
void add(int l, int r, int val)
{
    if(block[l] == block[r])//在一个块内，暴力
    {
        for(int i = l; i <= r; i ++ )
            arr[i] += val;
    }
    else
    {
        for(int i = l; i <= block[l] * m; i ++ )//非整块的左边，暴力
            arr[i] += val;
        for(int i = (block[r] - 1) * m + 1; i <= r; i ++ )//非整块的右边，暴力
            arr[i] += val;
        for(int i = block[l] + 1; i <= block[r] - 1; i ++ )//中间整块，标记数组记上
            lazy[i] += val;
    }
}
int main()
{
    scanf("%d", &n); m = sqrt(n);
    for(int i = 1; i <= n; i ++ )
    {
        scanf("%d", &arr[i]);
        block[i] = (i - 1) / m + 1;
    }
    for(int i = 1; i <= n; i ++ )
    {
        int op, l, r, c; scanf("%d%d%d%d", &op, &l, &r, &c);
        if(op == 0)//加
            add(l, r, c);
        else
            printf("%d\n", arr[r] + lazy[block[r]]);
    }
    return 0;
}

 LOJ #6278. 数列分块入门 2

  • 题意：给出一个长为 n 的数列，以及 n 个操作，操作涉及区间加法，询问区间内小于某个值 x 的元素个数。
  • 思路：500ms

分块

  • 同样的，我们将整个区间划分为\sqrt{n}个区间，每个区间有\sqrt{n}个元素。
  • 对于查询操作：因为我们要找区间内小于某个值x的元素，那我们就想了，如果每个块都是有序的，那么我们直接lower_bound就O(\sqrt{n}log\sqrt{n})找到“整块”中满足条件的个数。于是我们想到要给划分的块块内排序。所有块排序复杂度：O(\sqrt{n}\sqrt{n}log\sqrt{n})
  • 那么对于“非完整块”，我们还是直接暴力查找。O(\sqrt{n})
  • 对于修改操作：我们需要考虑，进行加的操作的时候，可以会改变“块”内的有序性。所以我们我们需要对这些“非完整块”进行重新排序。
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define INF 0x3f3f3f3f
#define lowbit(x) x & (-x)

#define MID (l + r ) >> 1
#define lsn rt << 1
#define rsn rt << 1 | 1
#define Lson lsn, l, mid
#define Rson rsn, mid + 1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define eps  1e-6

using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxN = 5e4 + 5;
inline int read()
{
    int x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}
int n, m;
int arr[maxN], block[maxN], lazy[maxN];
vector<int>vt[maxN];
void reset(int x)
{
    vt[x].clear();
    for(int i = (x - 1) * m + 1; i <= x * m; i ++ )
        vt[x].push_back(arr[i]);
    sort(vt[x].begin(), vt[x].end());
}
void add(int l, int r, int val)
{
    if(block[l] == block[r])
    {
        for(int i = l; i <= r; i ++ )
            arr[i] += val;
        reset(block[l]);
    }
    else
    {
        for(int i = l; i <= block[l] * m; i ++ )
            arr[i] += val;
        reset(block[l]);
        for(int i = (block[r] - 1) * m + 1; i <= r; i ++ )
            arr[i] += val;
        reset(block[r]);
        for(int i = block[l] + 1; i <= block[r] - 1; i ++ )
            lazy[i] += val;
    }
}
int query(int l, int r, int val)
{
    int ans = 0;
    if(block[l] == block[r])
    {
        for(int i = l; i <= r; i ++ )
            if(arr[i] + lazy[block[i]] < val)
                ans ++;
    }
    else
    {
        for(int i = l; i <= block[l] * m; i ++ )
            if(arr[i] + lazy[block[i]] < val)
                ans ++;
        for(int i = (block[r] - 1) * m + 1; i <= r; i ++ )
            if(arr[i] + lazy[block[i]] < val)
                ans ++;
        for(int i = block[l] + 1; i <= block[r] - 1; i ++ )
            ans += lower_bound(vt[i].begin(), vt[i].end(), val - lazy[i]) - vt[i].begin();
    }
    return ans;
}
int main()
{
    n = read(); m =sqrt(n);
    for(int i = 1; i <= n; i ++ )
    {
        arr[i] = read();
        block[i] = (i - 1) / m + 1;
        vt[block[i]].push_back(arr[i]);
    }
    for(int i = 1; i <= block[n]; i ++ )
        sort(vt[i].begin(), vt[i].end());
    for(int i = 1; i <= n; i ++ )
    {
        int op, l, r, c; op = read(); l = read(); r = read(); c = read();
        if(op == 0) add(l, r, c);
        else printf("%d\n", query(l, r, c * c));
    }
    return 0;
}

类似题：HDU 4417 Super Mario

LOJ #6279. 数列分块入门 3

  • 题意：给出一个长为 n 的数列，以及 n 个操作，操作涉及区间加法，询问区间内小于某个值 x 的前驱（比其小的最大元素）。
  • 跟上个题差不多，稍微改一下二分即可。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll ;

ll read()
{
    ll x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

const int maxN = 100005;
ll n, m, a[maxN], block[maxN], lazy[maxN];
vector<ll>vt[maxN];

void reset(ll x) {
    vt[x].clear();
    for(ll i = (x - 1) * m + 1; i <= x * m; ++ i ) {
        vt[x].emplace_back(a[i]);
    }
    sort(vt[x].begin(), vt[x].end());
}

void add(ll l, ll r, ll val) {
    if(block[l] == block[r]) {
        for(ll i = l; i <= r; ++ i ) {
            a[i] += val;
        }
        reset(block[l]);
    } else {
        for(ll i = l; i <= block[l] * m; ++ i ) {
            a[i] += val;
        }
        reset(block[l]);
        for(ll i = (block[r] - 1) * m + 1; i <= r; ++ i ) {
            a[i] += val;
        }
        reset(block[r]);
        for(ll i = block[l] + 1; i <= block[r] - 1; ++ i ) {
            lazy[i] += val;
        }
    }
}

ll query(ll l, ll r, ll val) {
    ll ans = INT64_MIN;
    if(block[l] == block[r]) {
        for(ll i = l; i <= r; ++ i ) {
            if(a[i] + lazy[block[l]] < val) {
                ans = max(ans, a[i] + lazy[block[l]]);
            }
        }
    } else {
        for(ll i = l; i <= block[l] * m; ++ i ) {
            if(a[i] + lazy[block[l]] < val) {
                ans = max(ans, a[i] + lazy[block[l]]);
            }
        }
        for(ll i = (block[r] - 1) * m + 1; i <= r; ++ i ) {
            if(a[i] + lazy[block[r]] < val) {
                ans = max(ans, a[i] + lazy[block[r]]);
            }
        }
        for(ll i = block[l] + 1; i <= block[r] - 1; ++ i ) {
            ll id = lower_bound(vt[i].begin(), vt[i].end(), val - lazy[i]) - vt[i].begin();
            if(id) ans = max(ans, vt[i][id - 1] + lazy[i]);
        }
    }
    return ans == INT64_MIN ? -1 : ans;
}

int main()
{
    n = read(); m = sqrt(n);
    for(ll i = 1; i <= n; ++ i ) {
        a[i] = read();
        block[i] = (i - 1) / m + 1;
        vt[block[i]].emplace_back(a[i]);
    }
    for(ll i = 1; i <= block[n]; ++ i ) {
        sort(vt[i].begin(), vt[i].end());
    }
    for(ll i = 1; i <= n; ++ i ) {
        ll op, l, r, c;
        op = read(), l = read(), r = read(), c = read();
        if(!op) { //加
            add(l, r, c);
        } else { //query
            cout << query(l, r, c) << endl;
        }
    }
    return 0;
}

LOJ #6280. 数列分块入门 4

  • 题意：给出一个长为 n 的数列，以及 n 个操作，操作涉及区间加法，区间求和。
  • 思路：定义sum[ ]数组表示对应“块”的元素和。分块后进行加操作时，区间中的整块就用lazy[ ]标记，非整块就直接暴力遍历每个元素加，同时元素所在块的sum[ ]也要加上对应的值。区间求和查询时，对于非整块直接暴力查询加上a[i]+lazy[block[ ]]，对于整块则加上sum[i] + lazy[i] * m。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll ;

ll read()
{
    ll x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

const int maxN = 100005;
ll n, m, a[maxN];
ll block[maxN], lazy[maxN], sum[maxN];

void add(ll l, ll r, ll val) {
    if(block[l] == block[r]) {
        for(int i = l; i <= r; ++ i ) {
            a[i] += val;
        }
        sum[block[l]] += val * (r - l + 1);
    } else {
        for(int i = l; i <= block[l] * m; ++ i ) {
            a[i] += val;
        }
        sum[block[l]] += val * (block[l] * m - l + 1);
        for(int i = (block[r] - 1) * m + 1; i <= r; ++ i ) {
            a[i] += val;
        }
        sum[block[r]] += val * (r - ((block[r] - 1) * m + 1) + 1);
        for(int i = block[l] + 1; i <= block[r] - 1; ++ i ) {
            lazy[i] += val;
        }
    }
}

ll query(ll l, ll r, ll mod) {
    ll ans = 0;
    if(block[l] == block[r]) {
        for(int i = l; i <= r; ++ i ) {
            ans += a[i] + lazy[block[l]], ans %= mod;
        }
    } else {
        for(int i = l; i <= block[l] * m; ++ i ) {
            ans += a[i] + lazy[block[l]], ans %= mod;
        }
        for(int i = (block[r] - 1) * m + 1; i <= r; ++ i ) {
            ans += a[i] + lazy[block[r]], ans %= mod;
        }
        for(int i = block[l] + 1; i <= block[r] - 1; ++ i ) {
            ans += sum[i] + lazy[i] * m, ans %= mod;
        }
    }
    return ans;
}

int main()
{
    n = read(); m = sqrt(n);
    for(int i = 1; i <= n; ++ i ) {
        a[i] = read();
        block[i] = (i - 1) / m + 1;
        sum[block[i]] += a[i];
    }
    for(int i = 1; i <= n; ++ i ) {
        ll op, l, r, c;
        op = read(), l = read(), r = read(), c = read();
        if(!op) { //add
            add(l, r, c);
        } else { //query
            cout << query(l, r, c + 1) << endl;
        }
    }
    return 0;
}

LOJ #6281. 数列分块入门 5

  • 题意：给出一个长为n的数列，以及n个操作，操作涉及区间开方，区间求和。
  • 思路：开方确实不好搞，但是众所周知分块是优雅的暴力。我们知道2^32最多能开方6次就变成了1，所以我们可以记录一个“块”是否都是1 / 0，如果是的话那么我们不需要再对其进行开方，因为结果不会变了；否则的话我们直接遍历对每个元素进行开方。当然对于非整块我们直接遍历即可。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll ;

ll read()
{
    ll x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

const int maxN = 100005;
ll n, m, a[maxN], block[maxN], flag[maxN], sum[maxN];

void SQRT(ll l, ll r) {
    if(block[l] == block[r]) {
        if(!flag[block[l]]) {
            for(int i = l; i <= r; ++ i ) {
                sum[block[l]] -= a[i];
                a[i] = sqrt(a[i]);
                sum[block[l]] += a[i];
            }
        }
    } else {
        for(int i = l; i <= block[l] * m; ++ i ) {
            sum[block[l]] -= a[i];
            a[i] = sqrt(a[i]);
            sum[block[l]] += a[i];
        }
        for(int i = (block[r] - 1) * m + 1; i <= r; ++ i ) {
            sum[block[r]] -= a[i];
            a[i] = sqrt(a[i]);
            sum[block[r]] += a[i];
        }
        for(int i = block[l] + 1; i <= block[r] - 1; ++ i ) {
            if(!flag[i]) {
                flag[i] = 1; sum[i] = 0;
                for(int j = (i - 1) * m + 1; j <= i * m; ++ j ) {
                    a[j] = sqrt(a[j]);
                    sum[i] += a[j];
                    if(a[j] > 1) flag[i] = 0;
                }
            }
        }
    }
}

ll query(ll l, ll r) {
    ll ans = 0;
    if(block[l] == block[r]) {
        for(int i = l; i <= r; ++ i ) {
            ans += a[i];
        }
    } else {
        for(int i = l; i <= block[l] * m; ++ i ) {
            ans += a[i];
        }
        for(int i = (block[r] - 1) * m + 1; i <= r; ++ i ) {
            ans += a[i];
        }
        for(int i = block[l] + 1; i <= block[r] - 1; ++ i ) {
            ans += sum[i];
        }
    }
    return ans;
}

int main()
{
    n = read(); m = sqrt(n);
    for(int i = 1; i <= n; ++ i ) {
        a[i] = read();
        block[i] = (i - 1) / m + 1;
        sum[block[i]] += a[i];
    }
    for(int i = 1; i <= n; ++ i ) {
        ll op, l, r, c;
        op = read(), l = read(), r = read(), c = read();
        if(!op) SQRT(l, r);
        else cout << query(l, r) << endl;
    }
    return 0;
}

LOJ #6282. 数列分块入门 6 

  • 题意：给出一个长为 n 的数列，以及 n 个操作，操作涉及单点插入，单点询问，数据随机生成。
  • 思路：涉及插入操作，所以每个"块"开一个动态数组即可。但是这就涉及到一个问题，如果大量单点插入到一个块中使得该块远远大于\sqrt{n}，那么我们对块进行暴力的时候就不能保证复杂度了。所以当一个块中的数目大于2\sqrt{n}时，我们就对所有数据进行重构，即重新分块，重构的复杂度为O(n)，最多重构\sqrt{n}次，复杂度还是可以的。
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll ;

ll read()
{
    ll x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

const int maxN = 200005;
ll n, m, newN, up, a[maxN];
vector<ll>vt[maxN];

pair<ll, ll> find(ll pos) {
    ll x = 1;
    while(pos > vt[x].size()) {
        pos -= vt[x ++ ].size();
    }
    return make_pair(x, pos - 1);
}

void rebuild() {
    for(int i = 1; i <= up; ++ i ) {
        for(vector<ll>::iterator it = vt[i].begin(); it != vt[i].end(); ++ it ) {
            a[++ newN] = *it;
        }
        vt[i].clear();
    }
    m = sqrt(newN), up = (newN - 1) / m + 1;
    for(int i = 1; i <= newN; ++ i ) {
        vt[(i - 1) / m + 1].emplace_back(a[i]);
    }
    newN = 0;
}

void Insert(ll pos, ll val) {
    pair<ll, ll> p = find(pos);
    vt[p.first].insert(vt[p.first].begin() + p.second, val);
    if(vt[p.first].size() > 2 * m) rebuild();
}

int main()
{
    n = read(), m = sqrt(n), up = (n - 1) / m + 1;
    for(int i = 1; i <= n; ++ i ) {
        a[i] = read();
        vt[(i - 1) / m + 1].emplace_back(a[i]);
    }
    for(int i = 1; i <= n; ++ i ) {
        ll op, l, r, c;
        op = read(), l = read(), r = read(), c = read();
        if(op == 0) { // 第l前插入r
            Insert(l, r);
        } else { // 查询a[r]
            pair<ll, ll> ans = find(r);
            cout << vt[ans.first][ans.second] << endl;
        }
    }
    return 0;
}

 

LOJ #6283. 数列分块入门 7

  • 题意：给出一个长为 n 的数列，以及 n 个操作，操作涉及区间乘法，区间加法，单点询问。
  • 思路：
  1. 对于整块，在已经*m, +a的前提下，①+a2：m = m; a = a + a2 ②*m2：m = m * m2; a = a * m2.
  2. 对于非整块，铁定是不能对部分这个非整块中的元素进行单独的操作的，所以我们需要将该非整块所在的整块之前的lazy标记全都处理掉，然后再单元素处理。【这时候就需要注意块的右端点，因为最后一个块可能不是长度为m的块，取min(n, )即可】
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll ;

ll read()
{
    ll x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

const int maxN = 100005;
const ll mod = 10007;

ll n, m, a[maxN], block[maxN], lazy_add[maxN], lazy_mul[maxN];
void update(ll x) { //注意块的右端点！！！！
    for(int i = (x - 1) * m + 1; i <= min(x * m, n); ++ i ) {
        a[i] = a[i] * lazy_mul[x] % mod + lazy_add[x], a[i] %= mod;
    }
    lazy_mul[x] = 1, lazy_add[x] = 0;
}
void add(ll l, ll r, ll val) {
    if(block[l] == block[r]) {
        update(block[l]);
        for(int i = l; i <= r; ++ i ) {
            a[i] += val, a[i] %= mod;
        }
    } else {
        update(block[l]);
        for(int i = l; i <= block[l] * m; ++ i ) {
            a[i] += val, a[i] %= mod;
        }
        update(block[r]);
        for(int i = (block[r] - 1) * m + 1; i <= r; ++ i ) {
            a[i] += val, a[i] %= mod;
        }
        for(int i = block[l] + 1; i <= block[r] - 1; ++ i ) {
            lazy_add[i] += val, lazy_add[i] %= mod;
        }
    }
}
void mul(ll l, ll r, ll val) {
    if(block[l] == block[r]) {
        update(block[l]);
        for(int i = l; i <= r; ++ i ) {
            a[i] *= val, a[i] %= mod;
        }
    } else {
        update(block[l]);
        for(int i = l; i <= block[l] * m; ++ i ) {
            a[i] *= val, a[i] %= mod;
        }
        update(block[r]);
        for(int i = (block[r] - 1) * m + 1; i <= r; ++ i ) {
            a[i] *= val, a[i] %= mod;
        }
        for(int i = block[l] + 1; i <= block[r] - 1; ++ i ) {
            lazy_mul[i] *= val, lazy_mul[i] %= mod;
            lazy_add[i] *= val, lazy_add[i] %= mod;
        }
    }
}
ll query(ll x) {
    return (a[x] * lazy_mul[block[x]] % mod + lazy_add[block[x]]) % mod;
}

int main()
{
    n = read(); m = sqrt(n);
    for(int i = 1; i <= n; ++ i ) {
        a[i] = read(), a[i] %= mod;
        block[i] = (i - 1) / m + 1;
    }
    for(int i = 1; i <= block[n]; ++ i ) {
        lazy_mul[i] = 1;
    }
    for(int i = 1; i <= n; ++ i ) {
        ll op, l, r, c;
        op = read(), l = read(), r = read(), c = read();
        if(op == 0) {
            add(l, r, c);
        } else if(op == 1) {
            mul(l, r, c);
        } else {
            cout << query(r) << endl;
        }
    }
    return 0;
}

 LOJ #6284. 数列分块入门 8

  • 题意：给出一个长为 n 的数列，以及 n 个操作，操作涉及区间询问等于一个数 c 的元素，并将这个区间的所有元素改为 c 。
  • 思路：我们lazy标记一个整块的所有元素是否为相同的值。如果不是那就是-1，如果是就记为块中的元素值。
  1. 对于整块，如果lazy[]==-1，那么就暴力统计答案；否则O(1)统计答案
  2. 对于非整块，如果lazy[] == -1，那么暴力统计答案；否则O(1)统计答案。但是要注意：如果lazy[] != -1 && lazy[] != c，那么我们需要将该非整块对应的整块之前的lazy处理掉，然后再给非整块中的元素赋值为c。【其实非整块可以直接全部当作lazy[]==-1来做，只需要将整块的lazy处理掉然后处理非整块中的元素即可，但是显然前面分情况的做法要快一些。】
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <vector>
#include <algorithm>
#define INF 0x3f3f3f3f
using namespace std;
typedef long long ll ;

ll read()
{
    ll x = 0, f = 1; char c = getchar();
    while(c < '0' || c > '9') { if(c == '-') f = -f; c = getchar(); }
    while(c >= '0' && c <= '9') { x = x * 10 + c - '0'; c = getchar(); }
    return x * f;
}

const int maxN = 100005;
ll n, m, a[maxN], block[maxN], lazy[maxN];

void update(ll x) {
    if(lazy[x] == -1) return ;
    for(int i = (x - 1) * m + 1; i <= min(x * m, n); ++ i ) {
        a[i] = lazy[x];
    }
    lazy[x] = -1;
}
void incplet(ll l, ll r, ll val, ll &ans) {
    if(lazy[block[l]] == val) {
        ans += r - l + 1;
    } else if(lazy[block[l]] == -1){
        for(int i = l; i <= r; ++ i ) {
            if(a[i] == val) {
                ++ ans;
            } else {
                a[i] = val;
            }
        }
    } else {
        update(block[l]);
        for(int i = l; i <= r; ++ i ) {
            a[i] = val;
        }
    }
}
void cplet(ll x, ll val, ll &ans) {
    if(lazy[x] == -1) {
        for(int i = (x - 1) * m + 1; i <= x * m; ++ i ) {
            if(a[i] == val) ++ ans;
            else a[i] = val;
        }
        lazy[x] = val;
    } else if(lazy[x] == val) {
        ans += m;
    } else {
        lazy[x] = val;
    }
}

ll solve(ll l, ll r, ll val) {
    ll ans = 0;
    if(block[l] == block[r]) {
        incplet(l, r, val, ans);
//        update(block[l]);
//        for(int i = l; i <= r; ++ i ) {
//            if(a[i] == val) ++ ans;
//            else a[i] = val;
//        }
    } else {
        incplet(l, block[l] * m, val, ans);
        incplet((block[r] - 1) * m + 1, r, val, ans);
//        update(block[l]);
//        for(int i = l; i <= block[l] * m; ++ i ) {
//            if(a[i] == val) ++ ans;
//            else a[i] = val;
//        }
//        update(block[r]);
//        for(int i = (block[r] - 1) * m + 1; i <= r; ++ i ) {
//            if(a[i] == val) ++ ans;
//            else a[i] = val;
//        }
        for(int i = block[l] + 1; i <= block[r] - 1; ++ i ) {
            cplet(i, val, ans);
        }
    }
    return ans;
}

int main()
{
    memset(lazy, -1, sizeof(lazy));
    n = read(); m = sqrt(n);
    for(int i = 1; i <= n; ++ i ) {
        a[i] = read();
        block[i] = (i - 1) / m + 1;
    }
    for(int i = 1; i <= n; ++ i ) {
        ll l, r, c;
        l = read(), r = read(), c = read();
        cout << solve(l, r, c) << endl;
    }
    return 0;
}

 

_7许
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[总集] LOJ 分块1 – 9
think_twcie的博客
08-03 571
分块9题 出题人hzw的解析 (tips.以下代码中IO优化都已省去，想看可以点传送门) 数列分块入门 1 修改：区间加 查询：单点值查询 这是一道经典题目，线段树、树状数组等都可以搞，这里讲讲分块 分块就是将一定长度的一段数打包成块，统一处理的算法 每个块都有自己的信息，自己的标记，统一维护，统一查询 我们可以将每个区间修改或查询拆分成在若干个整块，和头尾两个不完整的块中修改、查询后信息...
Loj X:创建逻辑电路-开源
07-04
Loj X 是一个开源项目，专注于提供一个平台，让人们能够创建和设计逻辑电路，从而实现基本的计算功能，甚至构建小型的完整处理器。这个工具集成了各种元件，如逻辑门、存储器和程序读取器，使得用户可以构建出复杂的...
loj数列分块入门
PushyTao的博客
08-14 1048
数列分块入门入门 1-区间修改-单点查询入门 2-区间加法-区间查询入门 3-区间加法-单点查询入门 4-区间加法-区间查询入门 5-区间开方-区间查询入门 6-单点插入-单点查询入门 7入门 8入门 9 入门 1-区间修改-单点查询 ll n,a[maxn],lazy[maxn]; int main() { n = read; for(int i=1; i<=n; i++) a[i] = read; int blk = sqrt(n); for(int ii=1; ii<=n; ii
loj 数列分块入门 1 ~ 9 做题笔记
TMJYH09's csdn blog
04-25 932
前言 做了 hzwer 的分块系列（ %%% hzwer 学长 loj6277 数列分块入门 1 给定数列，区间修改，单点查询。 区间修改可以打永久标记。没什么好说的，毕竟是 1。 #include <bits/stdc++.h> #define int long long using namespace std; inline int read(){ int x=0,f=0;char ch=getchar(); while(!isdigit(ch))f^=!(ch^45)
loj题目总览
djrlb735733的博客
02-28 726
——DavidJing提供技术支持 现将今年7月份之前必须刷完的题目列举 完成度[25/34] [195/250] 第 1 章 贪心算法 √ [11/11] #10000 「一本通 1.1 例 1」活动安排 #10001 「一本通 1.1 例 2」种树 #10002 「一本通 1.1 例 3」喷水装置 #10003 「一本通 1.1 例 4」加工生产调度 #10004 「一本通 1.1 ...
1 数列分块入门_loj数列分块入门 1~9
weixin_28864057的博客
01-12 146
前言:先说句闲话，分块这个东西其实在第二次集训刚刚开始的时候就拉着lc学过一阵，原因是在luogu上见到了某著名毒瘤出的末日时系列的一套题目，貌似大部分都是分块，于是我想尝试着去做几道(毕竟是个珂学家)，但是看完题目就自闭了(noip毒瘤果不虚传)，这两天学长又给我们讲了一些分块的知识，就把loj上的几道入门题再捡起来说一下吧。入门基础知识就不说什么了，学长讲过了，蓝皮书上面也有。这里前面和后面的...
up_717085_google-api-php-client_71loj.rar
12-22
7. **持续学习和更新**：Google的API和服务经常更新，因此开发者需要定期检查库的更新，保持代码的兼容性和最新性。 综上所述，这个压缩包提供了一个学习和使用Google API PHP客户端的完整环境，涵盖了从认证到实际...
NLW-4
02-26
帕拉iniciarØprojeto EM阵营FOI utilizadoØCOMANDO yarn create react-app moveit --template=typescript ，ONDE moveit éØ诺姆做projetoË --template=typescript éØCOMANDO对inciar-LOJáCOM打字稿。
log4j配置，jar包
06-01
在新项目中，建议使用更新的Log4j2，因为它提供了更多的特性和性能改进。 总结来说，Log4j是Java开发中不可或缺的工具，通过配置`log4j.properties`文件，我们可以精确地控制日志的输出，便于调试和监控系统运行...
loj数论分块
gigo_64 sink in my world
10-28 146
1 板子。 #include<bits/stdc++.h> using namespace std; #define in read() int in{ int cnt=0,f=1;char ch=0; while(!isdigit(ch)){ ch=getchar();if(ch=='-')f=-1; } while(isdigit(ch)){ cnt=cnt*...
数列分块入门1-9 LibreOJ
weixin_30257433的博客
05-25 125
我也不知道为什么一个大二的ACM选手没学分块。 我怎么记得大一的时候，学长教给我的分块就只有 block 和 num 两个变量来着...好吧，应该是我没认真学。正好前两天朋友给学弟开课，乘机去蹭了一节课。然后...我还是不会哇，菜的一逼塌糊涂。 还是 卿学姐 好哇，多听几遍，睡得贼香。 分块原理 分块嘛，其实就是优雅的暴力，和莫队（不会）有点异曲同工的赶脚。通过将数组分成小块以降低复杂度。 通常情...
分块入门1~9 （完结撒花）
包子不卖包子
08-23 449
LOJ 终于肝完了分块的九种基础类型，调bug调得是真（超）是（级）开（恶）心。 有脑残的时候，把块的编号当成元素的下表。数组开太小会莫名超时。 建议读者刷LOJ上的分块入门1~9 loj#6277. 数列分块入门 1 区间加法，单点查询 基础的东西 数学老师曰：基本知识不熟悉，难题不会做！ 分块 每个块的大小都是sqrt（n） n=12 N=sqrt（12） 向下取整 3 第一块：1...
数列分块入门1-9 By hzwer
weixin_30632899的博客
08-13 166
声明 持续更新，因为博主也是正在学习分块的知识，我很菜的，菜的抠$jio$ 写在前面 分块是个很暴力的算法，但却比暴力优秀的多，分块算法的时间复杂度一般是根号的，他的主要思想是将一个长度是$n$的数列分为$m$个块,在每个块上维护一些东西，询问的时候才会用到这些维护的东西，就像线段树中的懒标记一样。 Loj #6297. 数列分块入门1 这道题目是分块最基础的题目，仅需要支...
loj 与众不同_自由开发人员是否与众不同？
编程故事的地方
07-24 590
loj 与众不同 合同编码器的兴起 在全球用于外包IT服务的856亿美元中 ，有成千上万的人在搅动着很大一部分……我们对此并不了解。 在所有在线自由职业者中，近三分之一是软件开发人员。 在全部零工经济职位中，有51 ％是针对开发人员的，在过去三年中增长了16个百分点。 到2027年，仅在美国，自由职业者的数量就有望达到1亿 。 UpWork / Edelman和Gallup的调查经济...
LOJ—— 数列分块入门 2
我们都有光明的未来
05-14 302
数列分块入门 2 时间限制: 3 Sec 内存限制: 256 MB [命题人:admin] [ Edit] [ TestData] 题目描述 给出一个长为 n 的数列，以及 n 个操作，操作涉及区间加法，询问区间内小于某个值 x 的元素个数。 输入 第一行输入一个数字 n。 第二行输入 n 个数字，第 i 个数字为 ai，以空格隔开。 接下来输入 n 行询问，每行输入四个数字opt 、l、r、c，以空格隔开。 若opt=0，表示将位于[l,r]的之间的数字都加c。 若opt=1，表示询问中[l,r]小于c
数列分块入门1-9
qq_51281451的博客
08-15 689
这里写目录标题数列分块入门1数列分块入门2 数列分块入门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
【分块入门1-9】--分块大法好
dimeitong1731的博客
09-20 207
分块一： 给出一个长为n的数列，以及n个操作，操作涉及区间加法，单点查值。 普通分块水过 #include<iostream> #include<cstdio> #include<cmath> #include<cstdlib> using namespace std; int n, a[100100], len,t...
分块入门1~9题解
hzk_cpp的博客
05-06 306
分块入门1：LOJ6277. 题目大意：给定一个长度为nnn的序列以及nnn个操作，操作设计区间加法，单点查值. 1≤n≤5∗1041\leq n\leq 5*10^41≤n≤5∗104. 分块，每个块维护一个tagtagtag表示这个块被整体加了多少. 代码如下： #include<bits/stdc++.h> using namespace std; #define Abig...
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++ 代码

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值