Codeforces 455D - Serega and Fun (Solved by Square Root Decomposition)

 

Problem Link:

 

http://codeforces.com/problemset/problem/455/D

 

---

 

Problem Statement:

 

D. Serega and Fun

 

time limit per test: 4 seconds

memory limit per test: 256 megabytes

input: standard input

output: standard output

 

 

Serega loves fun. However, everyone has fun in the unique manner. Serega has fun by solving query problems. One day Fedor came up with such a problem.

You are given an array a consisting of n positive integers and queries to it. The queries can be of two types:

1. Make a unit cyclic shift to the right on the segment from l to r (both borders inclusive). That is rearrange elements of the array in the following manner:a[l], a[l + 1], ..., a[r - 1], a[r] → a[r], a[l], a[l + 1], ..., a[r - 1].
2. Count how many numbers equal to k are on the segment from l to r (both borders inclusive).

Fedor hurried to see Serega enjoy the problem and Serega solved it really quickly. Let's see, can you solve it?

 

Input

The first line contains integer n (1 ≤ n ≤ 10⁵) — the number of elements of the array. The second line contains n integers a[1], a[2], ..., a[n] (1 ≤ a[i] ≤ n).

The third line contains a single integer q (1 ≤ q ≤ 10⁵) — the number of queries. The next q lines contain the queries.

As you need to respond to the queries online, the queries will be encoded. A query of the first type will be given in format: 1 l'_i r'_i. A query of the second type will be given in format: 2 l'_i r'_i k'_i. All the number in input are integer. They satisfy the constraints: 1 ≤ l'_i, r'_i, k'_i ≤ n.

To decode the queries from the data given in input, you need to perform the following transformations:

l_i = ((l'_i + lastans - 1) mod n) + 1; r_i= ((r'_i + lastans - 1) mod n) + 1; k_i = ((k'_i + lastans - 1) mod n) + 1.

Where lastans is the last reply to the query of the 2-nd type (initially, lastans = 0). If after transformation li is greater than ri, you must swap these values.

 

Output

For each query of the 2-nd type print the answer on a single line.

 

---

 

Analysis:

 

There are a lot of ways to solve this problem.

(1)    The most brutal way is to use square root decomposition.

(2)    Some more elegant way is to use splay trees or treaps to solve it.

Here I will only present the brutal way to solve it, i.e., using square root decomposition. Maybe some time later I will post the more elegant way.

 

In this problem, we are asked to perform one operation and one query. For each operation, we are given two parameters l and r, and we need to perform a right shift on the interval from l to r, i.e. a[l]=a[r], a[l+1]=a[l], a[l+2]=a[l+1], …, a[r]=a[r-1]. For each query, we are given three parameters l, r and k, and we need to count the number of elements equal to k in the interval from l to r.

If we implement the data structure naively using a vector, each right shift operation would take O(n) time and each query would also take O(n) time, which would cause an overall complexity of O(nq) and consequentially lead us to “time limit exceeded”.

To implement a data structure with better performance, we can get help from a classical way called square root decomposition, i.e., dividing the elements into approximately √n blocks each of which has approximately √n elements. After that, we can keep for each block keep track of the elements inside it and the number of elements equal to 1 to 10⁵ inside this block.

With this data structure, we can both perform the right shift operation in √n steps and count the number of elements equal to k in an interval in √n steps, since there can be at most √n blocks and each block has at most √n elements.

To perform each right shift operation, we can keep track of the elements inside each block in a deque (double ended queue) and insert the element positioned at r to position x and then push the right most element of the block which has just increased one in size to the following block until all blocks return to their normal size.

There is one last issue with this method, i.e., sometimes we do not choose the number of blocks and the size of each block to be exactly √n. If we choose some other number, it may improve the code's performance. In this problem, I filled each block with 800 elements, which makes the code accepted. However, when I choose the size to be 400, I got the verdict "limit limit exceeded". In fact, one can find the best size by mathematical calculation, which I will not present here.

 

---

 

Time Complexity:

 

O(n√n)

 

---

 

AC Code:

 

#include <iostream>
#include <sstream>
#include <fstream>
#include <string>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <algorithm>
#include <functional>
#include <utility>
#include <bitset>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <cstdio>
#include <memory.h>
#include <iomanip>
#include <unordered_set>
#include <unordered_map>
using namespace std;

#define MP make_pair
#define FS first
#define SC second
#define LB lower_bound
#define PB push_back
#define lc p*2+1
#define rc p*2+2

typedef long long ll;
typedef pair<int,int> pi; 

const int Maxn=1e5+10;
const int Maxp=200;
const int Maxd=800;

int n,q,t;
int l,r,k,ans=0;
int a[Maxn];

class group{
    public:
        int cnt[Maxn];
        deque<int> v;
}gp[Maxp];

void right_shift(){ //perform the right shift
    int a=l/Maxd,b=r/Maxd,aa=l%Maxd,bb=r%Maxd;
    int val=*(gp[b].v.begin()+bb);
    gp[b].v.erase(gp[b].v.begin()+bb);
    gp[a].v.insert(gp[a].v.begin()+aa,val);
    gp[b].cnt[val]--;
    gp[a].cnt[val]++;
    for(int i=a;i<b;i++){
        val=gp[i].v.back();
        gp[i].v.pop_back();
        gp[i+1].v.push_front(val);
        gp[i].cnt[val]--;
        gp[i+1].cnt[val]++;
    }
}

int count_val(){ //count the number of elements equal to k from l to r
    int a=l/Maxd,b=r/Maxd,aa=l%Maxd,bb=r%Maxd;
    int rez=0;
    if(a==b){
        for(auto it=gp[a].v.begin()+aa;it<=gp[a].v.begin()+bb;it++){
            if(*it==k) rez++;
        }
    }
    else{
        for(auto it=gp[a].v.begin()+aa;it!=gp[a].v.end();it++){
            if(*it==k) rez++;
        }
        for(int i=a+1;i<b;i++){
            rez+=gp[i].cnt[k];
        }
        for(auto it=gp[b].v.begin();it<=gp[b].v.begin()+bb;it++){
            if(*it==k) rez++;
        }
    }
    return rez;
}

void build(){ //initialize the blocks 
    for(int i=0;i<n;i++){
        gp[i/Maxd].v.push_back(a[i]);
        gp[i/Maxd].cnt[a[i]]++;
    }
}

int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%d",a+i);
    }
    build();
    scanf("%d",&q);
    for(int i=0;i<q;i++){
        scanf("%d%d%d",&t,&l,&r);
        l=(l+ans-1)%n;
        r=(r+ans-1)%n;
        if(l>r) swap(l,r);
        if(t==1){
            right_shift();
        }
        else{
            scanf("%d",&k);
            k=(k+ans-1)%n+1;
            ans=count_val();
            printf("%d\n",ans);
        }
    }
return 0;
}