bzoj4592 脑洞治疗仪 线段树

最新推荐文章于 2021-09-13 18:30:43 发布
最新推荐文章于 2021-09-13 18:30:43 发布
阅读量474 收藏 1
点赞数
分类专栏： BZOJ 线段树 文章标签： bzoj 线段树 二分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MaxMercer/article/details/74253615
版权
BZOJ 同时被 2 个专栏收录
129 篇文章 0 订阅
订阅专栏
线段树
15 篇文章 0 订阅
订阅专栏

Description

曾经发明了自动刷题机的发明家SHTSC又公开了他的新发明：脑洞治疗仪–一种可以治疗他因为发明而日益增大的脑洞的神秘装置。
为了简单起见，我们将大脑视作一个01序列。1代表这个位置的脑组织正常工作，0代表这是一块脑洞。
1 0 1 0 0 0 1 1 1 0
脑洞治疗仪修补某一块脑洞的基本工作原理就是将另一块连续区域挖出，将其中正常工作的脑组织填补在这块脑洞中。
（所以脑洞治疗仪是脑洞的治疗仪？）
例如，用上面第8号位置到第10号位置去修补第1号位置到第4号位置的脑洞。我们就会得到：
1 1 1 1 0 0 1 0 0 0
如果再用第1号位置到第4号位置去修补第8号位置到第10号位置：
0 0 0 0 0 0 1 1 1 1
这是因为脑洞治疗仪会把多余出来的脑组织直接扔掉。
如果再用第7号位置到第10号位置去填补第1号位置到第6号位置：
1 1 1 1 0 0 0 0 0 0
这是因为如果新脑洞挖出来的脑组织不够多，脑洞治疗仪仅会尽量填补位置比较靠前的脑洞。
假定初始时SHTSC并没有脑洞，给出一些挖脑洞和脑洞治疗的操作序列，你需要即时回答SHTSC的问题：
在大脑某个区间中最大的连续脑洞区域有多大。
Input

第一行两个整数n，m。表示SHTSC的大脑可分为从1到n编号的n个连续区域。有m个操作。
以下m行每行是下列三种格式之一。
0 l r ：SHTSC挖了一个从l到r的脑洞。
1 l0 r0 l1 r2 ：SHTSC进行了一次脑洞治疗，用从l0到r0的脑组织修补l1到r1的脑洞。
2 l r ：SHTSC询问l到r这段区间最大的脑洞有多大。
n,m <=200000，1<=l<=r<=n
Output

对于每个询问，输出一行一个整数，表示询问区间内最大连续脑洞区域有多大。
Sample Input

10 10

0 2 2

0 4 6

0 10 10

2 1 10

1 8 10 1 4

2 1 10

1 1 4 8 10

2 1 10

1 7 10 1 6

2 1 10

Sample Output

3

3

6

6

这里写图片描述

釜山行确实好看…推荐大家去看一下

这道题坑爹啊，一开始自作聪明，1操作没有去二分而靠自己特判，wa的糊里糊涂.，调了半天.

这道题线段树要维护的东西有，本区间的：最左/右边的最长连续零lc rc，零的总个数all，整个区间的最长连续零cmax以及区间的标记flag，区间的长度len.
每次pushdown，update的时候更新一下这些东西即可.

对于1操作，我们先找出挖掉区间的1的个数（区间长度-零的总个数），记得要立马把这段区间赋成0，因为可能这段要挖掉的区间就在待填补区间里，再统计需填补区间的脑洞个数，如果大于的话直接整个区间赋成1，小于的话就二分一下待填补区间，找到L（待填补区间的）到mid的脑洞个数刚好等于需挖掉的区间的可以用来的填补的脑组织（1）个数，就break.直接把L到mid的区间赋成1,即可.

/**************************************************************
    Problem: 4592
    User: MaxMercer
    Language: C++
    Result: Accepted
    Time:9712 ms
    Memory:25924 kb
****************************************************************/

#include<stdio.h>
const int maxn=200001;
int t1,t2,L,R,opt,n,m,fix;
inline char nc(){
    static char buf[100000],*p1=buf,*p2=buf;
    return p1==p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1==p2)?EOF:*p1++;
}
inline int read(){
    register int x=0,f=1;
    register char ch=nc();
    while(ch<'0'||ch>'9'){if(ch=='-')f*=-1;ch=nc();}
    while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=nc();
    return f*x;
}
inline int max(int x,int y){if(x>y) return x;else return y;}
inline int min(int x,int y){if(x<y) return x;else return y;}
struct node{
    node *ls,*rs;
    int cmax,lc,rc,flag,len,all;
    void pushdown(){
         if(flag==1){
            ls->cmax=ls->lc=ls->rc=ls->all=ls->len;
            ls->flag=1;
            rs->cmax=rs->lc=rs->rc=rs->all=rs->len;
            rs->flag=1;
         }
         if(flag==2){
            ls->cmax=ls->lc=ls->rc=ls->all=0;
            ls->flag=2;
            rs->cmax=rs->lc=rs->rc=rs->all=0;
            rs->flag=2;
         }
         flag=0;
    }
    void update(){
         if(ls->cmax==ls->len) lc=ls->len+rs->lc;
         else lc=ls->lc;
         if(rs->cmax==rs->len) rc=rs->len+ls->rc;
         else rc=rs->rc;
         all=ls->all+rs->all;
         cmax=max(ls->cmax,rs->cmax);
         cmax=max(cmax,ls->rc+rs->lc);
    }
}pool[maxn*4],*root,*tail=pool;
node *build(int lf,int rg){
    node *bt=++tail;
    if(lf==rg) {bt->len=1;bt->cmax=bt->lc=bt->rc=bt->flag=bt->all=0;return bt;}
    int mid=(lf+rg)>>1;
    bt->ls=build(lf,mid);
    bt->rs=build(mid+1,rg);
    bt->cmax=bt->lc=bt->rc=bt->flag=bt->all=0;
    bt->len=rg-lf+1;
    return bt;
}
void modify(node *bt,int lf,int rg,int L,int R,int val){
    if(L<=lf&&rg<=R){
       if(!val) bt->cmax=bt->lc=bt->rc=bt->all=rg-lf+1,bt->flag=1;
       else  bt->cmax=bt->lc=bt->rc=bt->all=0,bt->flag=2;
       return;
    }
    int mid=(lf+rg)>>1;
    bt->pushdown();
    if(L<=mid) modify(bt->ls,lf,mid,L,R,val);
    if(R>mid)  modify(bt->rs,mid+1,rg,L,R,val);
    bt->update();
}
int query(node *bt,int lf,int rg,int L,int R){
    if(L<=lf&&rg<=R) return bt->cmax;
    int mid=(lf+rg)>>1;
    bt->pushdown();
    int r1=0,r2=0,ans=0;
    if(L<=mid) r1=query(bt->ls,lf,mid,L,R);
    if(R>mid) r2=query(bt->rs,mid+1,rg,L,R);
    if(r1&&r2){
       if(mid-L+1<bt->ls->rc) ans+=mid-L+1;
       else ans+=bt->ls->rc;
       if(R-mid<bt->rs->lc) ans+=R-mid;
       else ans+=bt->rs->lc; 
    }
    ans=max(ans,max(r1,r2));
    bt->update();
    return ans;
}
int query_all(node *bt,int lf,int rg,int L,int R){
    if(L<=lf&&rg<=R) return bt->all;
    int mid=(lf+rg)>>1;
    bt->pushdown();
    int rt=0;
    if(L<=mid) rt+=query_all(bt->ls,lf,mid,L,R);
    if(R>mid) rt+=query_all(bt->rs,mid+1,rg,L,R);
    return rt;
}
int main(){
    n=read(),m=read();
    root=build(1,n);
    while(m--){
      opt=read();
      if(!opt) L=read(),R=read(),modify(root,1,n,L,R,0);
      if(opt==1){
         L=read(),R=read();
         t1=R-L+1-query_all(root,1,n,L,R),modify(root,1,n,L,R,0);
         L=read(),R=read();
         t2=query_all(root,1,n,L,R);
         int l=L,r=R;
         if(!t1||!t2) continue;
         if(t1>=t2) modify(root,1,n,L,R,1);
         else{
         while(1){
            int mid=(l+r)>>1;
            if(query_all(root,1,n,L,mid)>t1){r=mid-1;continue;}
            if(query_all(root,1,n,L,mid)<t1){l=mid+1;continue;}
            modify(root,1,n,L,mid,1);break;
         }
         }
      }
      if(opt==2) L=read(),R=read(),printf("%d\n",query(root,1,n,L,R));
    }
}


这里用了读入优化无法手工输入，要测试代码的话用这份.再附上一份随机数据生成代码.

#include<stdio.h>
const int maxn=200001;
int t1,t2,L,R,opt,n,m,fix;
inline int max(int x,int y){if(x>y) return x;else return y;}
inline int min(int x,int y){if(x<y) return x;else return y;}
struct node{
    node *ls,*rs;
    int cmax,lc,rc,flag,len,all;
    void pushdown(){
         if(flag==1){
            ls->cmax=ls->lc=ls->rc=ls->all=ls->len;
            ls->flag=1;
            rs->cmax=rs->lc=rs->rc=rs->all=rs->len;
            rs->flag=1;
         }
         if(flag==2){
            ls->cmax=ls->lc=ls->rc=ls->all=0;
            ls->flag=2;
            rs->cmax=rs->lc=rs->rc=rs->all=0;
            rs->flag=2;
         }
         flag=0;
    }
    void update(){
         if(ls->cmax==ls->len) lc=ls->len+rs->lc;
         else lc=ls->lc;
         if(rs->cmax==rs->len) rc=rs->len+ls->rc;
         else rc=rs->rc;
         all=ls->all+rs->all;
         cmax=max(ls->cmax,rs->cmax);
         cmax=max(cmax,ls->rc+rs->lc);
    }
}pool[maxn*4],*root,*tail=pool;
node *build(int lf,int rg){
    node *bt=++tail;
    if(lf==rg) {bt->len=1;bt->cmax=bt->lc=bt->rc=bt->flag=bt->all=0;return bt;}
    int mid=(lf+rg)>>1;
    bt->ls=build(lf,mid);
    bt->rs=build(mid+1,rg);
    bt->cmax=bt->lc=bt->rc=bt->flag=bt->all=0;
    bt->len=rg-lf+1;
    return bt;
}
void modify(node *bt,int lf,int rg,int L,int R,int val){
    if(L<=lf&&rg<=R){
       if(!val) bt->cmax=bt->lc=bt->rc=bt->all=rg-lf+1,bt->flag=1;
       else  bt->cmax=bt->lc=bt->rc=bt->all=0,bt->flag=2;
       return;
    }
    int mid=(lf+rg)>>1;
    bt->pushdown();
    if(L<=mid) modify(bt->ls,lf,mid,L,R,val);
    if(R>mid)  modify(bt->rs,mid+1,rg,L,R,val);
    bt->update();
}
int query(node *bt,int lf,int rg,int L,int R){
    if(L<=lf&&rg<=R) return bt->cmax;
    int mid=(lf+rg)>>1;
    bt->pushdown();
    int r1=0,r2=0,ans=0;
    if(L<=mid) r1=query(bt->ls,lf,mid,L,R);
    if(R>mid) r2=query(bt->rs,mid+1,rg,L,R);
    if(r1&&r2){
       if(mid-L+1<bt->ls->rc) ans+=mid-L+1;
       else ans+=bt->ls->rc;
       if(R-mid<bt->rs->lc) ans+=R-mid;
       else ans+=bt->rs->lc; 
    }
    ans=max(ans,max(r1,r2));
    bt->update();
    return ans;
}
int query_all(node *bt,int lf,int rg,int L,int R){
    if(L<=lf&&rg<=R) return bt->all;
    int mid=(lf+rg)>>1;
    bt->pushdown();
    int rt=0;
    if(L<=mid) rt+=query_all(bt->ls,lf,mid,L,R);
    if(R>mid) rt+=query_all(bt->rs,mid+1,rg,L,R);
    return rt;
}
inline const int read(){
    register int f=1,x=0;
    register char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&ch<='9'){x=(x<<3)+(x<<1)+ch-'0';ch=getchar();}
    return f*x;
}
int main(){
    n=read(),m=read();
    root=build(1,n);
    while(m--){
      opt=read();
      if(!opt) L=read(),R=read(),modify(root,1,n,L,R,0);
      if(opt==1){
         L=read(),R=read();
         t1=R-L+1-query_all(root,1,n,L,R),modify(root,1,n,L,R,0);
         L=read(),R=read();
         t2=query_all(root,1,n,L,R);
         int l=L,r=R;
         if(!t1||!t2) continue;
         if(t1>=t2) modify(root,1,n,L,R,1);
         else{
         while(1){
            int mid=(l+r)>>1;
            if(query_all(root,1,n,L,mid)>t1){r=mid-1;continue;}
            if(query_all(root,1,n,L,mid)<t1){l=mid+1;continue;}
            modify(root,1,n,L,mid,1);break;
         }
         }
      }
      if(opt==2) L=read(),R=read(),printf("%d\n",query(root,1,n,L,R));
    }
}

可自己修改一下数据（注意修改rand取余的数），方便你比较一下.

#include<stdio.h>
#include<ctime>
#include<cstdlib>
#include<algorithm>
using namespace std;
int L,opt,R;
int main(){
    srand(time(0));
    freopen("txt.out","w",stdout);
    printf("100 100\n");
    for(register int i=1;i<=100;i++){
       opt=rand()%3;
       printf("%d ",opt);
       if(!opt) {L=rand()%101;if(!L)L++;R=rand()%101;if(!R)R++;if(L>R) swap(L,R);printf("%d %d\n",L,R);} 
       if(opt==1) {L=rand()%101;if(!L)L++;R=rand()%101;if(!R)R++;if(L>R) swap(L,R);printf("%d %d ",L,R);L=rand()%101;if(!L)L++;R=rand()%101;if(!R)R++;if(L>R) swap(L,R);printf("%d %d\n",L,R);} 
       if(opt==2) {L=rand()%101;if(!L)L++;R=rand()%101;if(!R)R++;if(L>R) swap(L,R);printf("%d %d\n",L,R);} 
    }
}
MaxMercer
关注
专栏目录
【bzoj4592】[Shoi2015]脑洞治疗仪 线段树
Oxer的专栏
05-18 1392
我还真是傻逼呀，这么傻逼的线段树调那么久。 就是一个1操作，改成在线段树上二分即可。 #include #include #include #include #include #include #define maxn 200010 using namespace std; struct yts { int l,r; int lmx,rmx,ans,size,tag; }t[4
[BZOJ十连测]线段树
C202044zxy的博客
01-23 321
一、题目 二、解法 在若干次操作后，某一个位置的值可以表示成若干各区间的最大值。 例如位置kkk，我们找到当前操作前最后一个（编号最大但小于当前编号）覆盖当前区间左端点的操作的左端点，最后一个覆盖当前当前区间右端点的操作的右端点，把这个左右端点当成一个新的操作区间，然后重复执行上述操作。 也就是我们需要一直向左找，一直向右找，找到最左的和最右的ll,rrll,rrll,rr，kkk位置上面的即是...
【bzoj4592】【SHOI2015】【脑洞治疗仪】【线段树】
sunshinezff的专栏
05-21 695
Description 曾经发明了自动刷题机的发明家SHTSC又公开了他的新发明：脑洞治疗仪--一种可以治疗他因为发明而日益增大的脑洞的神秘装置。 为了简单起见，我们将大脑视作一个01序列。1代表这个位置的脑组织正常工作，0代表这是一块脑洞。 1 0 1 0 0 0 1 1 1 0 脑洞治疗仪修补某一块脑洞的基本工作原理就是将另一块连续区域挖出，将其中正常工作的脑组织填补在
bzoj4592: [Shoi2015]脑洞治疗仪
miaom的博客
05-18 783
由于脑洞的序列不会改变，考虑用线段树维护区间内sum，左边0的个数，右边0的个数，区间内最大脑洞。对于查询l~r最大脑洞可以将l~r分成logn个区间，总复杂度O(nlogn)。 #include #include #include #define N 800005 using namespace std; int n,m,p,x,y,l,r; int sum[N],L[N],R[N],tg[N
BZOJ4592 [Shoi2015]脑洞治疗仪
neither_nor
06-12 777
进行治疗实际上相当于用1覆盖一段区间，这段区间内原有的1的个数加上挖出来的1的个数等于这段区间的长度，并且这段区间的长度最长为治疗的区间长度 记录一下还剩多少挖出来的1，然后在线段树上爬出这个区间就可以了，因为是线段树上，所以找到一个区间是log的 知道了一段区间的长度，区间里有多少1，还剩多少脑组织，就能知道这段区间是否被完全覆盖 需要判断是否还剩脑组织，如果没了就返回，要不然复杂度不对
BZOJ4592 SHOI2015脑洞治疗仪（线段树）
weixin_30552635的博客
11-03 96
　　考虑需要资瓷哪些操作：区间赋值为0；统计区间1的个数；将区间前k个0变为1；询问区间最长全0子串。于是线段树维护区间1的个数、0的个数、最长前缀后缀全0子串即可。稍微困难的是用一个log实现将区间前k个0变为1，线段树上二分尽量往左边改即可，可以令修改函数返回值为剩余能改的1的个数。 #include<iostream> #include<cstdio> #...
bzoj4592: [Shoi2015]脑洞治疗仪（ODT）
苟为蒟蒻又何妨
01-19 279
传送门 ODT水题。 支持区间01赋值，区间填补（把区间[l,r][l,r][l,r]从左往右数kkk个1都变成0），区间查询最长连续1个数。 思路： 区间填补操作感觉不是很好弄，写线段树的神仙可以套一个二分来写。 而对于写odtodtodt的朋友们来说就很easyeasyeasy了，直接从左往右遍历到第kkk个1所在区间覆盖一波即可（详见代码）。 不会ODTODTODT的点这里 代码： #in...
BZOJ 2143 飞飞侠（线段树优化建边 / 并查集优化最短路）【BZOJ修复工程】
繁凡さん的博客
09-13 414
【BZOJ修复计划 #12】BZOJ 2143 飞飞侠 【国家集训队2011】
bzoj4919 大根堆(线段树合并)
santongding
03-28 1289
bzoj4919 也是雅礼集训考的一题。。。 似乎不必要用线段树合并，用个set也能又好又快的水过去。。。 先考虑最简单的树形dp怎么做； 设dp[i][j]表示当前在i节点并且选的最大不超过j的答案是多少； 考虑用动态开点的线段树来维护dp数组 对于每一个节点，只需要先把其儿子的dp数组加起来，这就对应线段树合并操作；又因为我用的标记永久化，每一次修改对应区间直接相加； 再根据自...
BZOJ2957 楼房重建（线段树+思路）
gyr
08-04 478
楼房重建 Description 　　小A的楼房外有一大片施工工地，工地上有N栋待建的楼房。每天，这片工地上的房子拆了又建、建了又拆。他经常无聊地看着窗外发呆，数自己能够看到多少栋房子。  　　为了简化问题，我们考虑这些事件发生在一个二维平面上。小A在平面上(0,0)点的位置，第i栋楼房可以用一条连接(i,0)和(i,Hi)的线段表示，其中Hi为第i栋楼房的高度。如果这栋楼房上任何一
[SHOI 2015] 脑洞治疗仪
12-08 207
[题目链接] https://www.lydsy.com/JudgeOnline/problem.php?id=4592 [算法] 对于操作1 ， 我们首先查询区间[l0 , r0]中有多少个1 ， 然后二分求出最大的x(x <= r1)使得[l1 , x]中0的个数 <= [l0 , r0]中1的个数 对于操作2 ， ...
BZOJ4592: [Shoi2015]脑洞治疗仪
Heret1c
06-09 609
BZOJ4592（吐槽一下dsydsy，我=这个数据=了一天我xxx！！xxx！！）一开始看到这个题。诶，区间连续最大和诶！把脑洞的值为1，正常的赋为−INF-INF 但是操作1怎么办。。 发现就是先统计出l0到r0l0到r0区间内−INF-INF的个数tottot，然后区间赋为1. 然后统计l1到r1l1到r1区间内1的个数TotTot，如果tot>Tottot>Tot就直接区间赋值了嘛。
[SHOI2015]脑洞治疗仪
weixin_30872733的博客
03-27 164
嘟嘟嘟 这题其实就是一个线段树维护最大连续和的水题。 别的操作不说，操作1只要二分找区间前\(k\)个0即可。 需要注意的是，因为操作1两区间可能有交，因此要先清空再二分查询…… 复杂度\(O(n log ^ 2 n)\)。 #include<cstdio> #include<iostream> #include<cmath> #include&lt...
脑洞治疗仪（线段树二分）
DD(XYX)的硫氰化氘博客
11-08 255
脑洞治疗仪 曾经发明了自动刷题机的发明家 SHTSC 又公开了他的新发明：脑洞治疗仪——一种可以治疗他因为发明而日益增大的脑洞的神秘装置。 为了简单起见，我们将大脑视作一个 0/1 序列。1代表这个位置的脑组织正常工作，0代表这是一块脑洞。 1 0 1 0 0 0 1 1 1 0 脑洞治疗仪修补某一块脑洞...
【SHOI 2015】脑洞治疗仪
forever_dreams的博客
10-19 331
算法标签：线段树
BZOJ4592 [Shoi2015]脑洞治疗仪（洛谷P4344）
forezxl的博客
08-22 238
BZOJ4592: [Shoi2015]脑洞治疗仪（洛谷P4344） 线段树 BZOJ题目传送门 洛谷题目传送门 昨天一个字母打错一晚上没调出来。。。 挺裸的线段树。 0直接做。1记录下l0l0l_0到r0r0r_0的1的个数后可以二分确定修补的右端点，也可以直接往下做到没有为止，前者log2log2\log^2，后者比loglog\log稍微大一点。2对每个节点记一下最左边、最右...
BZOJ4592 线段树
Devil_Gary的博客
10-21 571
这个题有毒 我调了3个小时 各种奇葩错 （还是我太菜了） 这题就线段树维护一个区间1的个数 0的个数 左端最长连续0 右端最长连续0 区间内最长连续0 转移的思路还是很好想的 对于那个补脑洞的操作（明明脑洞越来越多） 二分一下 再区间修改 还是得多码 （我学了假的线段树 常数大到离谱）#include<bits/stdc++.h> using namespace std; const int
【BZOJ4592】【Shoi2015】脑洞治疗仪 线段树
鲜衣怒马少年郎
05-24 617
第一眼看成了一个裸的01弱智线段树，然后发现弱智的是自己。。。主要就是如果好脑洞不够用了就尽量往前面补这一个操作。。。 其实还是不难。。。我们在线段树遍历的时候优先往前面补，如果这个区间不够补就分别检查两个子区间，可以证明这样的操作还是log级别的（反正我不会233），然后就是最长连续区间的套路辣 /***********************************************
BZOJ[4592][Shoi2015]脑洞治疗仪 分块
谁能代表肯德基
07-03 397
传送门ber~ 太长时间没写分块了。。。写一写。。 码力++ 都要NOI了还在刷水.... #include&amp;amp;lt;algorithm&amp;amp;gt; #include&amp;amp;lt;ctype.h&amp;amp;gt; #include&amp;amp;lt;cstdio&amp;amp;gt; #include&amp;amp;lt;cmath&amp;amp;gt; #define N 20005
等差数列与数据结构——线段树、树状数组解析
"本资源是一份关于BZOJ算术天才⑨与等差数列问题的线段树和树状数组应用的课件，主要针对信息竞赛和OI选手，涵盖了线段树和树状数组的基本概念、优势及在解决实际问题中的应用策略。标签涉及信息竞赛、OI、线段树、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值