题目链接：https://loj.ac/problem/6282
题目大意：

先说随机数据的情况

之前提到过，如果我们块内用数组以外的数据结构，能够支持其它不一样的操作，比如此题每块内可以放一个动态的数组，每次插入时先找到位置所在的块，再暴力插入，把块内的其它元素直接向后移动一位，当然用链表也是可以的，这里用vector。

查询的时候类似，复杂度分析略。

但是这样做有个问题，如果数据不随机怎么办？

如果先在一个块有大量单点插入，这个块的大小会大大超过√n，那块内的暴力就没有复杂度保证了。

还需要引入一个操作：重新分块（重构）

每根号n次插入后，重新把数列平均分一下块，重构需要的复杂度为O(n)，重构的次数为√n，所以重构的复杂度没有问题，而且保证了每个块的大小相对均衡。
当然，也可以当某个块过大时重构，或者只把这个块分成两半。

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
//由块号寻找第一个块元素的下标
#define int(x) ((x-1)*Len+1)
const int maxn=5e5+5;
LL read()
{
    LL x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}

int a[500005];
vector<int> v[5005];
int Len, n, m;

pair<int , int> query(int b)//查询第b个元素
{
    int x=1;
    while(b>v[x].size())
    {
        b-=v[x].size(), x++;
    }

    return make_pair(x, b-1);//返回a[i]的块数和前一个元素在块中的位置
}

void rebuild()//重新分块
{
    int top=0;
    for(int i=1;i<=m;i++)
    {
        for(vector<int>::iterator it=v[i].begin(); it!=v[i].end(); it++)
        {
            a[++top]=*it;
        }
        v[i].clear();
    }
    Len=sqrt(top);//每块的大小

    for(int i=1;i<=top;i++)
    {
        v[(i-1)/Len+1].push_back(a[i]);
    }
    m=(top-1)/Len+1;//重新统计块数
}

void Insert(int a, int b)//在第a个元素前面插入b
{
    pair<int , int> t=query(a);
    v[t.first].insert(v[t.first].begin()+t.second, b);//插入元素

    if(v[t.first].size()>20*Len)//块过大时，重新分块
    {
        rebuild();
    }
}

void build(int n)//初始分块
{
    Len=sqrt(n);//每块长度
    m=(n-1)/Len+1;//总的块数
    for(int i=1;i<=n;i++)
    {
        a[i]=read();
    }
    for(int i=1;i<=n;i++)
    {
        v[(i-1)/Len+1].push_back(a[i]);
    }
}

int main()
{
    n=read();
    build(n);

    for(int i=1;i<=n;i++)
    {
        int op=read(), L=read(), R=read(), c=read();
        if(op==0)
        {
            Insert(L, R);
        }
        else
        {
            pair<int , int> t=query(R);
            printf("%d\n", v[t.first][t.second]);
        }
    }

    return 0;
}