CodeForces 455D 分块

题目链接:http://codeforces.com/problemset/problem/455/D

题意:给定一个长度为n的序列a[]。 m次操作。共有两种操作 1 l r:将序列的a[l].a[l+1]...a[r]变成a[r].a[l].a[l+1]...a[r-1];2 l r k:求序列a[l].a[l+1]...a[r]中有多少个值为k。 输入的l,r,k都是加密过的。所以要解密一下。规则为 l=(l+ans-1)%n+1  r=(r+ans-1)%n+1 k=(k+ans-1)%n+1. (当解密过后l>r时交换l,r)ans为上一个2操作的结果。初始的ans为0. 即题目要求强制在线。

思路:考虑分块。每块维护一个cnt数组,cnt[i]表示在该块中数字i出现的次数。 再维护一个双端队列deque. 然后对于1操作就暴力来修改就好了。注意如果1操作涉及到多块的时候,要将第i块的最后一个移动到第i+1块的第一个。 然后维护一下cnt即可。

#define _CRT_SECURE_NO_DEPRECATE
#include<stdio.h>
#include<string.h>
#include<cstring>
#include<algorithm>
#include<queue>
#include<math.h>
#include<time.h>
#include<vector>
#include<iostream>
#include<map>
using namespace std;
typedef long long int LL;
const int MAXN = 100000 + 10;
int belong[MAXN], block, num, L[MAXN], R[MAXN];
int n, q, val[MAXN];
struct Node{
    deque<int>Q;
    int cnt[MAXN];
}Bval[400];
void build(){
    block = (int)sqrt(n + 0.5);
    num = n / block; if (n%block){ num++; }
    for (int i = 1; i <= num; i++){
        memset(Bval[i].cnt, 0, sizeof(Bval[i].cnt));
        Bval[i].Q.clear();
        L[i] = (i - 1)*block + 1; R[i] = i*block;
    }
    R[num] = n;
    for (int i = 1; i <= n; i++){
        belong[i] = ((i - 1) / block) + 1;
    }
    for (int i = 1; i <= num; i++){
        for (int k = L[i]; k <= R[i]; k++){
            Bval[i].cnt[val[k]]++;
            Bval[i].Q.push_back(val[k]);
        }
    }
}
void modify(int st, int ed){
    deque<int>::iterator it; int v;
    if (belong[st] == belong[ed]){
        it = Bval[belong[st]].Q.begin();
        for (int i = L[belong[st]]; i < ed; i++){
            it++;
        }
        v = *it;
        Bval[belong[st]].Q.erase(it);
        it = Bval[belong[st]].Q.begin();
        for (int i = L[belong[st]]; i<st; i++){
            it++;
        }
        Bval[belong[st]].Q.insert(it, v);
        return;
    }
    it = Bval[belong[ed]].Q.begin();
    for (int i = L[belong[ed]]; i < ed; i++){ it++; }
    v = *it;
    Bval[belong[ed]].Q.erase(it); Bval[belong[ed]].cnt[v]--;
    it = Bval[belong[st]].Q.begin();
    for (int i = L[belong[st]]; i < st; i++){ it++; }
    Bval[belong[st]].Q.insert(it, v); Bval[belong[st]].cnt[v]++;
    for (int i = belong[st] + 1; i <= belong[ed]; i++){
        it = Bval[i - 1].Q.end() - 1; v = *it;
        Bval[i].Q.push_front(v); Bval[i].cnt[v]++;
        Bval[i - 1].cnt[v]--;
        Bval[i - 1].Q.erase(it);
    }
}
int query(int st, int ed, int v){
    int ans = 0;
    deque<int>::iterator it;
    if (belong[st] == belong[ed]){
        it = Bval[belong[st]].Q.begin();
        for (int i = L[belong[st]]; i<st; i++){
            it++;
        }
        for (int i = st; i <= ed; i++, it++){
            ans += ((*it) == v);
        }
        return ans;
    }
    it = Bval[belong[st]].Q.begin();
    for (int i = L[belong[st]]; i<st; i++){
        it++;
    }
    for (int i = st; i <= R[belong[st]]; i++, it++){
        ans += ((*it) == v);
    }
    for (int i = belong[st] + 1; i < belong[ed]; i++){
        ans += Bval[i].cnt[v];
    }
    it = Bval[belong[ed]].Q.begin();
    for (int i = L[belong[ed]]; i <= ed; i++, it++){
        ans += ((*it) == v);
    }
    return ans;
}
int main(){
    //#ifdef kirito
    //    freopen("in.txt", "r", stdin);
    //    freopen("out.txt", "w", stdout);
    //#endif
    //    int start = clock();
    while (~scanf("%d", &n)){
        for (int i = 1; i <= n; i++){
            scanf("%d", &val[i]);
        }
        build(); scanf("%d", &q);
        int type, l, r, v, ans = 0;
        for (int i = 1; i <= q; i++){
            scanf("%d", &type);
            if (type == 1){
                scanf("%d%d", &l, &r);
                l = ((l + ans - 1) % n) + 1; r = ((r + ans - 1) % n) + 1;
                if (l>r){ swap(l, r); }
                modify(l, r);
            }
            else{
                scanf("%d%d%d", &l, &r, &v);
                l = ((l + ans - 1) % n) + 1; r = ((r + ans - 1) % n) + 1;  v = ((v + ans - 1) % n + 1);
                if (l>r){ swap(l, r); }
                printf("%d\n", ans = query(l, r, v));
            }
        }
    }
    //#ifdef LOCAL_TIME
    //    cout << "[Finished in " << clock() - start << " ms]" << endl;
    //#endif
    return 0;
}
时间: 2024-08-02 23:13:15

CodeForces 455D 分块的相关文章

CodeForces 444C 分块

题目链接:http://codeforces.com/problemset/problem/444/C 题意:给定一个长度为n的序列a[].起初a[i]=i,然后还有一个色度的序列b[],起初b[i]=0.现在有2种操作: 1 l r x:区间染色,a[l],a[l+1]...a[r]变成x.同时b[l],b[l+1]...b[r]加上对应的|x-a[i]|值. 2 l r:统计区间和,统计区间b[l],b[l+1]...b[r]的和. 思路:线段树是比较常见的做法.考虑分块.每块维护一个laz

CodeForces 103D 分块处理

题目链接:http://codeforces.com/problemset/problem/103/D 题意:给定一个长度为n的序列.然后q个询问.每个询问为(a,b),表示从序列第a项开始每b项的加和. 思路:2014集训队论文中的<<根号算法——不只是分块>>中提到这题. 传统的数据结构比较擅长处理连续区间的询问.但是不擅长处理间隔位置的询问.考虑到分块. 对于b>sqrt(n)的询问.我们暴力计算.可以发现b越大我们扫描的位置就会越小.最大扫描次数为O(n/sqrt(n

CodeForces 551E 分块

题目链接:http://codeforces.com/problemset/problem/551/E 题意:给定一个长度为N的序列. 有2个操作 1 l r v:序列第l项到第r项加v(区间加),  2 v:求整个序列中值为v的数的位置的差值最大是多少.不存在输出-1. 思路:分块. 每块维护该块序列排序后的序列. 对于区间修改,我们定义一个lazy标记.对于整块的修改我们只修改lazy, 其他情况暴力修改.然后情况该块后重新加入修改后的块然后排序. 对于查询操作.查询每块时v应该减去该块的l

CodeForces 13E 分块

题目链接:http://codeforces.com/problemset/problem/13/E 题意:给定n个弹簧和每个弹簧初始的弹力a[].当球落在第i个位置.则球会被弹到i+a[i]的位置. 现在有2种操作: 1 a b:把第a个弹簧的弹力修改为b. 2 a:当球初始放入的位置为a时,需要弹几次才会弹出n.弹出前的最后一个位置是多少. 输出位置和次数. 思路:和BZOJ 2002一样. 然后记录一个最后弹出去的位置preidx.每次弹出当前块的时候记录当前的位置即可.然后最后再暴力模拟

codeforces 551E. GukiZ and GukiZiana 分块

题目链接 给出n个数, m个操作, 每个操作有两种, 将一段区间加上某个值, 或者询问一个k, a[i] = a[j] = k, 输出满足条件的最大的j-i, 如果没有输出-1. 做法是将数组分块, 第一次做这种, 抄的codeforces上面的代码... #include<bits/stdc++.h> using namespace std; #define pb(x) push_back(x) #define ll long long #define mk(x, y) make_pair(

Codeforces Round #404 (Div. 2) C 二分,水 D 数学,好题 E 分块

Codeforces Round #404 (Div. 2) C. Anton and Fairy Tale 题意:仓库容量n,每天运来m粮食,第 i 天被吃 i 粮食,问第几天仓库第一次空掉. tags:==SB题 注:二分边界判断,数据范围爆long long判断. // CF404 C #include<bits/stdc++.h> using namespace std; #pragma comment(linker, "/STACK:102400000,102400000&

Codeforces 506D Mr. Kitayuta&#39;s Colorful Graph(分块 + 并查集)

题目链接  Mr. Kitayuta's Colorful Graph 把每种颜色分开来考虑. 所有的颜色分为两种:涉及的点的个数 $> \sqrt{n}$    涉及的点的个数 $<= \sqrt{n}$ 对于第一种颜色,并查集缩点之后对每个询问依次处理过来若两点连通则答案加一. 对于第二种颜色,并查集所点之后对该颜色涉及的所有点两两之间判断是否连通, 若连通则另外开一个map记录答案. 最后把两个部分的答案加起来即可. 细节问题  由于每种颜色处理完之后并查集都要重新初始化,对于第一种颜色

Codeforces 785 E. Anton and Permutation(分块,树状数组)

Codeforces 785 E. Anton and Permutation 题目大意:给出n,q.n代表有一个元素从1到n的数组(对应索引1~n),q表示有q个查询.每次查询给出两个数l,r,要求将索引为l,r的两个数交换位置,并给出交换后数组中的逆序对数. 思路:此题用到了分块的思想,即将这组数分为bsz块,在每一块上建Fenwick树,对于每次查询,只需要处理l,r中间的块和l,r所在块受影响的部分.具体实现见代码及注释. #include<iostream> #include<

CodeForces 1202F(数论,整除分块)

题目 CodeForces 1213G 做法 假设有\(P\)个完整的循环块,假设此时答案为\(K\)(实际答案可能有多种),即每块完整块长度为\(K\),则\(P=\left \lfloor \frac{N}{K} \right \rfloor\) 假设循环快中有\(p_a,p_b\)个\(A\)和\(B\),则 \(p_a\cdot P\le a\Longrightarrow p_a\le \left \lfloor \frac{a}{P} \right \rfloor\) \(p_a\cd