bzoj3337 ORZJRY I（块状链表）

最新推荐文章于 2025-06-19 18:22:08 发布
最新推荐文章于 2025-06-19 18:22:08 发布
阅读量677 收藏 2
点赞数
CC 4.0 BY-SA版权
分类专栏： 块状链表 省选 文章标签： 块状链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wu_tongtong/article/details/79111972
本文详细介绍了块状链表的数据结构及其在各种操作中的应用，包括插入、删除、区间翻转等高级操作，并通过具体代码实现展示了如何高效地维护一个动态序列。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

Description

Jry最近做(屠)了很多数据结构题，所以想 BS你，他希望你能实现一种数据结构维护一个序列：
这里写图片描述

Input

第一行n；
第二行n个数；
第三行q，代表询问个数；
接下来q行，每行一个op，输入格式见描述。

Output

对于7≤op≤11的操作，一行输出一个答案。

Sample Input

6
5 2 6 3 1 4
15
7 2 4
8 1 3
9 2 4 5
10 1 6 4
11 2 5 4
6 1 4 7
8 1 4
5 3 4 5
2 1
1 2 8
3 3 5
4 1 5 2
9 2 5 4
10 3 6 4
11 1 6 100

Sample Output

11
4
1
4
3
0
3
12
6

HINT

n,q≤100000
任意时刻数列中的数≤2^31-1
0≤任意时刻数列中的数≤2^31-1

本题共3组数据


分析：

  • opt=1
    块状链表的基本操作：find插入的位置，分裂成两块，单元素插入
  • opt=2
    块状链表的基本操作：find插入位置，直接在第now块O(n)修改即可
  • opt=3
    查找到[x,y]区间，分裂出来，设置一个翻转标记，翻转整个区间（每个块打上翻转标记，链表的连接方式也翻过来）
  • opt=4
    查找到[x,x+k-1]和[x+k,y]两个区间，直接变换指针
  • opt=5
    查找到[x,y]区间，分裂出来，设置一个覆盖标记，每个块都打上覆盖标记
  • opt=6
    查找到[x,y]区间，分裂出来，设置一个修改标记，每个块都打上修改标记
  • opt=7
    每个块维护一个sum值，直接询问[x,y]的和
  • opt=8
    在每个块内维护一个新的数组s，把块内的元素按照从小到大排好序，直接查询最大值和最小值即可
  • opt=9
    查找到[x,y]区间，分裂出来，在每个块的s数组中二分查找询问元素，记录前驱后继与询问元素的差值最小值
  • opt=10
    二分答案，转化成判定问题：查找到[x,y]区间，分裂出来，在每个块的s数组中二分查找询问元素，统计比询问元素的小的元素个数
  • opt=11
    询问10的子问题

块状链表的基本操作还是比较好些好想的，然而这道题的扩展操作比较多，我们来看一看code：

初始化

块内维护信息：
d：原数组
s：从小到大排序后的数组
rev：翻转标记
delta：加标记
same：覆盖标记
size：块内的元素个数
sum：块内元素和
nxt：链指针

struct node{
    int d[1003],s[1003];
    int rev,delta,same,size,nxt;
    ll sum;
};
node a[N];
queue<int> q;   //内存池

void clear(int x)
{
    a[x].sum=a[x].rev=a[x].delta=a[x].same=a[x].size=0;
    a[x].nxt=-1;
}

int newnode()    //申请新结点
{
    int t=q.front(); q.pop();
    return t;
}

int del(int x)   //删除结点，恢复到内存池
{
    q.push(x); clear(x);
}

int init()       //初始化
{
    for (int i=1;i<N;i++) q.push(i);
    a[0].nxt=-1; a[0].size=0;
}

定位

void find(int &pos,int &now)
{
    for (now=0;a[now].nxt!=-1&&pos>a[now].size;now=a[now].nxt) pos-=a[now].size;
}

合并

合并的思路还是从now开始一路遍历下去
如果相邻块的大小之和小于blocksize（sqrt(n)），我们就进行合并

在合并之前，我们要保证块内的信息是稳定的，因此我们要标记下放

合并完成之后，每一块的信息就有变化了

我们就要重新维护块的信息
void merge(int now)    //now+now.nxt ---> now 
{
    int t=a[now].nxt;
    push(now); push(t);   
    for (int i=1;i<=a[t].size;i++)
        a[now].d[++a[now].size]=a[t].d[i];
    a[now].nxt=a[t].nxt;
    del(t);
    update(now);          
}

void maintain(int now)     //合并小块 
{
    for (;now!=-1;now=a[now].nxt)
        if (a[now].nxt!=-1&&a[now].size+a[a[now].nxt].size<=blocksize)
            merge(now);
}

维护信息

信息的维护分成两种：

  • 维护s数组和sum：我们直接把d数组复制到s数组中，sort一下即可
  • 标记下放：块状链表也不是什么线段树，每个块的大小只有sqrt(n)左右，所以直接O(n)处理即可
void push(int now)
{
    if (a[now].rev)
    {
        a[now].rev=0;
        for (int i=1;i<=a[now].size/2;i++)
            swap(a[now].d[i],a[now].d[a[now].size-i+1]);
    }
    if (a[now].same)
    {
        for (int i=1;i<=a[now].size;i++)
            a[now].d[i]=a[now].same;
        a[now].sum=a[now].size*a[now].same;
        a[now].same=0;
    }
    if (a[now].delta)
    {
        for (int i=1;i<=a[now].size;i++)
            a[now].d[i]+=a[now].delta;
        a[now].sum+=a[now].size*a[now].delta;
        a[now].delta=0;
    }
} 

void update(int x)
{
    a[x].sum=0;
    for (int i=1;i<=a[x].size;i++)
        a[x].s[i]=a[x].d[i],
        a[x].sum+=a[x].d[i];
    sort(a[x].s+1,a[x].s+1+a[x].size);    //维护顺序 
}

分裂

申请新结点，把后半部分直接复制到新结点中，不要忘了维护指针

要注意：分裂点我们划分到了下一块

这个性质关乎之后的操作

void divide(int now,int pos)   //分裂 pos分到了下一块 
{
    push(now);
    int t=newnode();
    for (int i=pos;i<=a[now].size;i++)
        a[t].d[++a[t].size]=a[now].d[i];
    a[t].nxt=a[now].nxt; a[now].nxt=t;
    a[now].size=max(pos-1,0);
    update(t);
    update(now);
}

单点插入

我们先要定位插入的位置：第now块的第pos位
之后把第now块分裂开
因为在分裂的时候pos分裂到了后一块，所以一开始的时候要pos++
因为块的大小和信息都有变化，所以我们调用一下maintain（合并小块）

void insert(int pos,int val)
{
    int now; pos++;
    find(pos,now); divide(now,pos);
    a[now].d[++a[now].size]=val;
    update(now);
    maintain(now);
}

单点删除

因为是单点删除，我们不用分裂，直接把后面的元素前移即可
因为块的大小和信息都有变化，所以我们调用一下maintain（合并小块）

void erase(int pos)
{
    int now;
    find(pos,now); push(now);
    for (int i=pos;i<a[now].size;i++)
        a[now].d[i]=a[now].d[i+1];
    a[now].size--;
    update(now);
    maintain(now);
}

分裂区间

这个函数非常的重要
调用后返回的lp和rp就是：
这里写图片描述
因为块的大小和信息都有变化，所以我们调用一下maintain（合并小块）

void solve(int l,int r,int &lp,int &rp)
{
    int pos=l;
    find(pos,lp); divide(lp,pos);
    pos=r+1; find(pos,rp); divide(rp,pos);
    pos=r; find(pos,rp);
}

区间翻转

我们需要一个辅助数组，把区间的块信息记录下来
方便翻转区间链接方式
因为块的大小和信息都有变化，所以我们调用一下maintain（合并小块）

void reverse(int x,int y)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int now=lp,top=0;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
        st[++top]=i,a[i].rev^=1;

    a[st[1]].nxt=a[rp].nxt;    //整个区间翻转 
    for (int i=top;i>1;i--)
        a[st[i]].nxt=st[i-1];
    a[lp].nxt=rp;
    maintain(lp);
}

区间右移

这里写图片描述
唯一需要注意的就是指针的修改
因为块的大小和信息都有变化，所以我们调用一下maintain（合并小块）

void move(int x,int y,int z)
{
    int lp,rp,mp,np;
    solve(x,y-z,lp,mp);
    solve(y-z+1,y,mp,rp);
    np=a[lp].nxt;
    a[lp].nxt=a[mp].nxt;
    a[mp].nxt=a[rp].nxt;
    a[rp].nxt=np;
    maintain(lp);
}

区间修改+询问区间和

这个操作比较简单
注意我们在修改的时候，直接维护了sum值
因为块的大小和信息都有变化，所以我们调用一下maintain（合并小块）

void add(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
    {
        a[i].delta+=z;
        a[i].sum+=a[i].size*z;
    }    
    maintain(lp);
}

void same(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
    {
        a[i].delta=0;
        a[i].same=z;
        a[i].sum=a[i].size*z;
    }
    maintain(lp);
}

ll sum(int x,int y)
{
    int lp,rp;
    solve(x,y,lp,rp);
    ll ans=0;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
        ans+=a[i].sum;
    maintain(lp);
    return ans;
}

询问区间最值

在每个结点中，我们维护了一个s数组，所以我们可以直接从s数组中查找

但是有一个问题：我们在调用这个块的时候，块的信息可能没有push过

如果我们每访问一个块就push一次，O(n)的复杂度不太划算

因为修改操作只有加和区间覆盖，是不会影响元素之间的大小关系的

所以我们直接把delta累加到元素上即可
（有覆盖标记的块需要特判一下）

因为我们调用了分裂操作，块的大小有变化，所以我们调用一下maintain（合并小块）

int range(int x,int y)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int mn=INF,mx=-INF;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt) if (a[i].size)
    {
        if (a[i].same)
        {
            mn=min(mn,a[i].same+a[i].delta);    //可能没有push 
            mx=max(mx,a[i].same+a[i].delta);
        }
        else
        {
            mn=min(mn,a[i].s[1]+a[i].delta);
            mx=max(mx,a[i].s[a[i].size]+a[i].delta);
        }
    }       
    maintain(lp);
    return mx-mn;
}

询问最小差值

在每个结点中，我们维护了一个s数组
我们可以直接在s数组中调用lower_bound函数，找到大于等于询问元素的第一个位置

注意：我们在调用这个块的时候，块的信息可能没有push过

我们要把delta累加到元素上
（有覆盖标记的块需要特判一下）

因为我们调用了分裂操作，块的大小有变化，所以我们调用一下maintain（合并小块）

int near(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int ans=INF;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
    {
        if (a[i].same) ans=min(ans,abs(a[i].same+a[i].delta-z));
        else
        {
            int x=lower_bound(a[i].s+1,a[i].s+a[i].size+1,z-a[i].delta)-a[i].s;
            if (x!=a[i].size+1)
                ans=min(ans,abs(a[i].s[x]+a[i].delta-z));
            if (x!=1) 
                x--,ans=min(ans,abs(a[i].s[x]+a[i].delta-z));
        }
    }
    maintain(lp);
    return ans;
}

询问第K值

我们二分一个答案M
统计比M小的元素个数，计算出M的排名
在s数组中调用upper_bound函数，找到大于询问元素的第一个位置x
那么x-1就是小于M的元素个数

还是这个问题：我们在调用这个块的时候，块的信息可能没有push过

我们要把delta累加到元素上
（有覆盖标记的块需要特判一下）

因为我们调用了分裂操作，块的大小有变化，所以我们调用一下maintain（合并小块）

int min_k(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int L=0,R=INF,ans;
    while (L<R)
    {
        int M=((L+R)>>1)+1;
        int sum=1;    //排名 
        for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
        {
            if (a[i].same)
            {
                if (a[i].same+a[i].delta<M) sum+=a[i].size;
            }
            else
            {
                int x=upper_bound(a[i].s+1,a[i].s+a[i].size+1,M-a[i].delta-1)-a[i].s;
                sum+=max(x-1,0);
            }
        }
        if (sum<=z) L=M;
        else R=M-1;
    }
    maintain(lp);
    return L;
}

询问小于某元素的元素个数

上一种询问的子问题

int ask_xiao(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int ans=0;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
    {
        if (a[i].same)
        {
            if (a[i].same+a[i].delta<z) ans+=a[i].size;
        } 
        else
        {
            int x=upper_bound(a[i].s+1,a[i].s+a[i].size+1,z-a[i].delta-1)-a[i].s;
            ans+=max(x-1,0);
        }
    }
    maintain(lp);
    return ans;
}

tip

一开始TLE了
发现是move的时候maintain传入的起点错了
这样就会导致小的块没有及时合并，时间退化的比较厉害

lower_bound和upper_bound的应用要注意

#include<cstdio>
#include<cstring>
#include<iostream>
#include<queue>
#include<algorithm>
#include<cmath>
#define ll long long

using namespace std;

const int INF=1e9;
const int N=10000;
int n,m,blocksize,st[N],b[N];
struct node{
    int d[1003],s[1003];
    int rev,delta,same,size,nxt;
    ll sum;
};
node a[N];
queue<int> q;

void clear(int x)
{
    a[x].sum=a[x].rev=a[x].delta=a[x].same=a[x].size=0;
    a[x].nxt=-1;
}

int newnode()
{
    int t=q.front(); q.pop();
    return t;
}

int del(int x)
{
    q.push(x); clear(x);
}

int init()
{
    for (int i=1;i<N;i++) q.push(i);
    a[0].nxt=-1; a[0].size=0;
}

void find(int &pos,int &now)
{
    for (now=0;a[now].nxt!=-1&&pos>a[now].size;now=a[now].nxt) pos-=a[now].size;
}

void push(int now)
{
    if (a[now].rev)
    {
        a[now].rev=0;
        for (int i=1;i<=a[now].size/2;i++)
            swap(a[now].d[i],a[now].d[a[now].size-i+1]);
    }
    if (a[now].same)
    {
        for (int i=1;i<=a[now].size;i++)
            a[now].d[i]=a[now].same;
        a[now].sum=a[now].size*a[now].same;
        a[now].same=0;
    }
    if (a[now].delta)
    {
        for (int i=1;i<=a[now].size;i++)
            a[now].d[i]+=a[now].delta;
        a[now].sum+=a[now].size*a[now].delta;
        a[now].delta=0;
    }
} 

void update(int x)
{
    a[x].sum=0;
    for (int i=1;i<=a[x].size;i++)
        a[x].s[i]=a[x].d[i],
        a[x].sum+=a[x].d[i];
    sort(a[x].s+1,a[x].s+1+a[x].size);    //维护顺序 
}

void merge(int now)    //now+now.nxt ---> now 
{
    int t=a[now].nxt;
    push(now); push(t);
    for (int i=1;i<=a[t].size;i++)
        a[now].d[++a[now].size]=a[t].d[i];
    a[now].nxt=a[t].nxt;
    del(t);
    update(now);
}

void maintain(int now)     //合并小块 
{
    for (;now!=-1;now=a[now].nxt)
        if (a[now].nxt!=-1&&a[now].size+a[a[now].nxt].size<=blocksize)
            merge(now);
}

void divide(int now,int pos)   //分裂 pos分到了下一块 
{
    push(now);
    int t=newnode();
    for (int i=pos;i<=a[now].size;i++)
        a[t].d[++a[t].size]=a[now].d[i];
    a[t].nxt=a[now].nxt; a[now].nxt=t;
    a[now].size=max(pos-1,0);
    update(t);
    update(now);
}

void insert(int pos,int val)
{
    int now; pos++;
    find(pos,now); divide(now,pos);
    a[now].d[++a[now].size]=val;
    update(now);
    maintain(now);
}

void erase(int pos)
{
    int now;
    find(pos,now); push(now);
    for (int i=pos;i<a[now].size;i++)
        a[now].d[i]=a[now].d[i+1];
    a[now].size--;
    update(now);
    maintain(now);
}

void solve(int l,int r,int &lp,int &rp)
{
    int pos=l;
    find(pos,lp); divide(lp,pos);
    pos=r+1; find(pos,rp); divide(rp,pos);
    pos=r; find(pos,rp);
}

void reverse(int x,int y)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int now=lp,top=0;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
        st[++top]=i,a[i].rev^=1;

    a[st[1]].nxt=a[rp].nxt;    //整个区间翻转 
    for (int i=top;i>1;i--)
        a[st[i]].nxt=st[i-1];
    a[lp].nxt=rp;
    maintain(lp);
}

void move(int x,int y,int z)
{
    int lp,rp,mp,np;
    solve(x,y-z,lp,mp);
    solve(y-z+1,y,mp,rp);
    np=a[lp].nxt;
    a[lp].nxt=a[mp].nxt;
    a[mp].nxt=a[rp].nxt;
    a[rp].nxt=np;
    maintain(lp);
}

void add(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
    {
        a[i].delta+=z;
        a[i].sum+=a[i].size*z;
    }    
    maintain(lp);
}

void same(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
    {
        a[i].delta=0;
        a[i].same=z;
        a[i].sum=a[i].size*z;
    }
    maintain(lp);
}

ll sum(int x,int y)
{
    int lp,rp;
    solve(x,y,lp,rp);
    ll ans=0;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
        ans+=a[i].sum;
    maintain(lp);
    return ans;
}

int range(int x,int y)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int mn=INF,mx=-INF;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt) if (a[i].size)
    {
        if (a[i].same)
        {
            mn=min(mn,a[i].same+a[i].delta);    //可能没有push 
            mx=max(mx,a[i].same+a[i].delta);
        }
        else
        {
            mn=min(mn,a[i].s[1]+a[i].delta);
            mx=max(mx,a[i].s[a[i].size]+a[i].delta);
        }
    }       
    maintain(lp);
    return mx-mn;
}

int near(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int ans=INF;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
    {
        if (a[i].same) ans=min(ans,abs(a[i].same+a[i].delta-z));
        else
        {
            int x=lower_bound(a[i].s+1,a[i].s+a[i].size+1,z-a[i].delta)-a[i].s;
            if (x!=a[i].size+1)
                ans=min(ans,abs(a[i].s[x]+a[i].delta-z));
            if (x!=1) 
                x--,ans=min(ans,abs(a[i].s[x]+a[i].delta-z));
        }
    }
    maintain(lp);
    return ans;
} 

int min_k(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int L=0,R=INF,ans;
    while (L<R)
    {
        int M=((L+R)>>1)+1;
        int sum=1;    //排名 
        for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
        {
            if (a[i].same)
            {
                if (a[i].same+a[i].delta<M) sum+=a[i].size;
            }
            else
            {
                int x=upper_bound(a[i].s+1,a[i].s+a[i].size+1,M-a[i].delta-1)-a[i].s;
                sum+=max(x-1,0);
            }
        }
        if (sum<=z) L=M;
        else R=M-1;
    }
    maintain(lp);
    return L;
} 

int ask_xiao(int x,int y,int z)
{
    int lp,rp;
    solve(x,y,lp,rp);
    int ans=0;
    for (int i=a[lp].nxt;i!=a[rp].nxt;i=a[i].nxt)
    {
        if (a[i].same)
        {
            if (a[i].same+a[i].delta<z) ans+=a[i].size;
        } 
        else
        {
            int x=upper_bound(a[i].s+1,a[i].s+a[i].size+1,z-a[i].delta-1)-a[i].s;
            ans+=max(x-1,0);
        }
    }
    maintain(lp);
    return ans;
} 

int main()
{
    scanf("%d",&n);
    int opt,x,y,z;
    blocksize=sqrt(n);
    init();
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&x);
        insert(i-1,x);      //从0开始 
    }
    scanf("%d",&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d",&opt);
        switch (opt)
        {
            case 1:scanf("%d%d",&x,&y); insert(x,y); break;
            case 2:scanf("%d",&x); erase(x); break;
            case 3:scanf("%d%d",&x,&y); reverse(x,y); break;
            case 4:scanf("%d%d%d",&x,&y,&z); move(x,y,z); break;
            case 5:scanf("%d%d%d",&x,&y,&z); add(x,y,z); break;
            case 6:scanf("%d%d%d",&x,&y,&z); same(x,y,z); break;
            case 7:scanf("%d%d",&x,&y); printf("%lld\n",sum(x,y)); break;
            case 8:scanf("%d%d",&x,&y); printf("%d\n",range(x,y)); break;
            case 9:scanf("%d%d%d",&x,&y,&z); printf("%d\n",near(x,y,z)); break;
            case 10:scanf("%d%d%d",&x,&y,&z); printf("%d\n",min_k(x,y,z)); break;
            case 11:scanf("%d%d%d",&x,&y,&z); printf("%d\n",ask_xiao(x,y,z)); break;
        }
    }
    return 0;
}
经典数据结构-块状链表详解
09-06 1788
经典数据结构-块状链表详解 1、 概述 在进行算法设计时，我们常用的两种线性数据结构是数组和链表。它们各有优缺点。数组特点是元素在内存中紧挨着存储，因而优点是定位快（O(1)），缺点是插入删除慢（O(n)）；而链表则不同，它通过指针将不同位置的元素链接起来，因而优缺点与数组正好相反：定位慢（O(n)），插入删除快（O(1)）。本文介绍一种新的数据结构：块状链表，它将数组和链表的优点
Summary
热门推荐
ADP+Pi==ATP
07-10 1万+
ATP感觉自己退役之前是用不上机房的空调了【笑
bzoj 3337: ORZJRY I （块状链表）
clover_hxy的博客
08-25 1401
3337: ORZJRY I Time Limit: 30 Sec  Memory Limit: 512 MB Submit: 188  Solved: 48 [Submit][Status][Discuss] Description Jry最近做(屠)了很多数据结构题，所以想 BS你，他希望你能实现一种数据结构维护一个序列： Input 第一行n； 第二行n个数；
块状链表详解
最新发布
weixin_35698867的博客
06-19 28
众所周知，数组可以以的复杂度查询、修改元素，但删除和插入元素的复杂度是的；链表恰好相反，插入、删除元素的复杂度为，但查询为。有没有能以较优复杂度完成插入、删除、查询、修改操作的线性数据结构？本篇介绍的块状链表就可以。顾名思义，块状链表运用分块的思想，将数组与链表结合起来。这里引用一张经典的图来展示它大概的样子：可以看出块状链表就是以数组为节点（块）的链表。
BZOJ3337 ORZJRY I
dieyi9889的博客
10-15 159
目录 BZOJ3337 ORZJRY I 题意 题解 Code:(加了FastIO略长。。) BZOJ3337 ORZJRY I 题目传送门 题意 emm...大致就是那样了吧，似乎就是一个毒瘤的数据结构来维护这么多种操作吧.. 题解 观察一下这些操作，发现...
bzoj3337 ORZJRY I
浅笑~如夏
01-27 496
题目 哇，好繁琐的一道数据结构题，居然有11个丧心病狂的操作。 据说正解是块状链表，但写起来特别麻烦，要接近400行才能写完，而且有些操作比较难维护。 这个时候，就要用一些黑科技了，叫odt，，全名是什么我也不太清楚，在处理随机意义下的含区间覆盖操作的数据结构有奇效，大概思路就是用STL把相同值的一串合并在一起算。 typedef pairint,int> pii; struct line
bzoj 3337: ORZJRY I
OZY的博客
09-26 1189
感觉打开了新世纪的大门
BZOJ 1507 Editor（块状链表）
weixin_34336292的博客
12-04 94
题目链接：http://61.187.179.132/JudgeOnline/problem.php?id=1507 题意：一个文本编辑器，模拟以下操作： 思路：块状链表的主要操作： （1）find(p,b)：找到位置p在链表的位置b； （2）split(b,p)：将第b块分裂成两块，前一块大小为p； （3）maintain(b):将b块之后的碎片合并； 利用以上三种操作可以完成插...
[BZOJ]3065: 带插入区间K小值 块状链表
TYB的博客
12-24 413
分块
[BZOJ3337]ORZJRY I
dichanpan2699的博客
03-01 146
感觉写完这题神清气爽，本来认为平衡树已经属于很复杂的东西了。 强烈推荐写一写这题，写完了就再也不用怕任何数据结构了。 思路很简单，每个块内维护一个\(s\)数组与_s数组。 表示原数组和排完序之后的数组，之后各种操作再打上各种标记。 于是你就轻松愉快 的解决了这道题。 代码: #include <bits/stdc++.h> #define il inline #define...
【BZOJ-1507】Editor 块状链表
weixin_30552811的博客
09-13 107
1507: [NOI2003]Editor Time Limit:5 SecMemory Limit:162 MBSubmit:3397Solved:1360[Submit][Status][Discuss] Description Input 输入文件editor.in的第一行是指令条数t，以下是需要执行的t个操作。其中： 为了使输入文件便于阅读，...
【BZOJ-3337】ORZJRY I 块状链表
weixin_30596165的博客
09-16 158
3337: ORZJRY I Time Limit:30 SecMemory Limit:512 MBSubmit:190Solved:50[Submit][Status][Discuss] Description Jry最近做(屠)了很多数据结构题，所以想 BS你，他希望你能实现一种数据结构维护一个序列： Input 第一行n；第...
[BZOJ3337]ORZJRY I（块状链表）
ADP+Pi==ATP
12-04 1095
狂热的数据结构爱好者ATP= =
BZOJ_P1507[NOI2003]Editor(块状链表)
BeiYu
02-10 735
传送门 Time Limit: 5 Sec Memory Limit: 162 MB Submit: 2833 Solved: 1148 [Submit][Status][Discuss] DescriptionInput 输入文件editor.in的第一行是指令条数t，以下是需要执行的t个操作。其中： 为了使输入文件便于阅读，Insert操作的字符串中可能会插入一些回车符，请忽略掉它
bzoj 1507 Editor 块状链表
弱智就要多努力
08-01 320
题目：http://www.lydsy.com/JudgeOnline/problem.php?id=1507题意：思路：用块状链表写的，操作还是挺繁琐的。。。#include <bits/stdc++.h>using namespace std;const int N = 4000000 + 10, M = 3000+10; const int block_num = 3000 + 100;que
块状链表 bzoj 3343教主的魔法
weixin_34232617的博客
01-14 93
//块状链表//分块排序，然后每次查找时在暴力查找头和尾两个块。//中间那些块，因为有序所以只需2分查找即可。我用的是lower_pound();//插入是，也是头和尾暴力插入，中间那些加到一个累计里即可。#include<cstdio>#include<cmath>#include<algorithm>#include<iostream>using...
2019.01.23【BZOJ3337】ORZJRY I（FHQ_treap实现ODT）
zxyoi_dreamer的博客（不定期诈尸）
01-23 307
传送门 解析： 这种题无脑压节点，剩下的无脑写平衡树暴力就行了。 平衡树做不了的提出来数组做就行了。 没什么难度。 代码： #include&lt;bits/stdc++.h&gt; using namespace std; #define ll long long #define re register #define gc get_char #define cs const namesp...
bzoj3337 块状链表的各种操作
litble的成(tui)长(fei)史
01-04 675
题目分析在我做这道题之前，我一直以为维护数列已经是很BT的数据结构板子题了，现在发现我错了…… 本蒟蒻的最长代码记录，甚至超过了立体八数码那道题。所以为了图代码更简洁，本蒟蒻牺牲了一些常数，所以这代码常数很大…… 我们来分析一下各种操作吧（想看完整代码请直接翻到最下面） 好的，我们建立块，需要维护一些什么呢？原数组a,一个排序后的数组b，一个翻转标记rev，一个赋值标记same，一个块的大小s
块状链表
Balloons2012的专栏
10-06 1466
/* * 本模板支持以下操作： * 1.在任意位置插入一个整数 * 2.插入一个块(Block)，包含多个整数 * 3.删除一个整数 * 4.输出第i位上的整数 * 注意：所有Insert(pos,data)，均是在pos之后插入。 * BlockList::N是sqrt(n)的结果，它决定了块状链表的效率 */ #include #include #include #include #d
陈立杰课件与BZOJ代码精选分享
- **算法竞赛在线评测系统**：BZOJ（BeiJing University Online Judge）是一个用于算法竞赛的在线评测系统，它提供了一个平台供参赛者提交代码，系统自动对代码进行测试并给出运行结果。 - **算法编程训练**：BZOJ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值