复习一下整体二分

最新推荐文章于 2020-02-12 17:11:38 发布
最新推荐文章于 2020-02-12 17:11:38 发布
阅读量1.5k 收藏 4
点赞数 1
分类专栏： 总结 特殊算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012288458/article/details/45539717
版权

    前阵子颓废了一下，学了个整体二分和cdq分治，感觉还是比较神奇的一个东西，写篇博客总结一下。

    关于整体二分

        http://www.cnblogs.com/zig-zag/archive/2013/04/18/3027707.html先膜拜下Zig_zag神犇。。。
      
整体二分是一种非常神奇的离线算法。

      带修改的区间查询第k小，树套树、分块什么的其实可以轻松秒掉，但是代码量都非常巨大，而整体二分在允许离线的情况下，可以完美的在O（n log^2 n）的时间内解决这个问题，且代码量极短。
考虑对于单个询问，我们可以二分答案，通过判断比mid小的数有多少个来缩小范围。对于多个询问我们同样可以这样做，每次二分将操作序列分成两个序列，对于询问操作，如果比二分的mid小的数大于k-1个，那么就将它放到左序列，否则就将它放到右序列；对于修改操作，如果修改的数小于mid，即对于左序列的二分有影响，就将它放到左序列，否则就将它放到右序列。当 修改的数小于mid时，我们记录一下其对右序列询问的贡献，这样再对左序列和右序列分别进行二分就可以了。每次插入和询问操作，很容易就想到用树状数组来维护，于是就完美的解决了这个代码量巨大的问题。
      注意，二分前必须保证操作序列按照时间顺序排序。 

/**************************************************************
    Problem: 1901
    User: Oxer
    Language: C++
    Result: Accepted
    Time:332 ms
    Memory:3176 kb
****************************************************************/
 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
#include<cerrno>
using namespace std;
 
struct yts
{
    int x,y,cur,id,op,k;
}q[30010],t[30010];
 
int tmp[30010],a[30010],ans[30010];
int c[30010];
bool mark[30010];
int n,m,cnt,num;
 
int lowbit(int x)
{
    return x&(-x);
}
 
void add(int i,int x)
{
    while (i<=n)
    {
        c[i]+=x;
        i+=lowbit(i);
    }
}
inline void assert(int x){
    if (x){
        int z=12;
        int x= z/(z-12);
    }
}
int query(int i)
{
    int tmp=0;
    while (i>0)
    {
        tmp+=c[i];
        i-=lowbit(i);
    }
    return tmp;
}
 
void solve(int l,int r,int L,int R)
{
    if (l>r) return;
    if (L==R)
    {
        for (int i=l;i<=r;i++)
          if (q[i].op==3) ans[q[i].id]=L;
        return;
    }
    int mid=(L+R)/2;
    for (int i=l;i<=r;i++)
    {
        if (q[i].op==1 && q[i].y<=mid) add(q[i].x,1);
        if (q[i].op==2 && q[i].y<=mid) add(q[i].x,-1);
        if (q[i].op==3) tmp[i]=query(q[i].y)-query(q[i].x-1);
    }
    for (int i=l;i<=r;i++)
    {
        if (q[i].op==1 && q[i].y<=mid) add(q[i].x,-1);
        if (q[i].op==2 && q[i].y<=mid) add(q[i].x,1);
    }
    int ct=0;
    for (int i=l;i<=r;i++)
    {
        if (q[i].op==3)
        {
            if (q[i].cur+tmp[i]>q[i].k-1) ct++,mark[i]=1;
            else q[i].cur+=tmp[i],mark[i]=0;
        }
        else
        {
            if (q[i].y<=mid) ct++,mark[i]=1;
            else mark[i]=0;
        }
    }
    int l1=l,l2=l+ct;
    for (int i=l;i<=r;i++) 
      if (mark[i]) t[l1++]=q[i];
      else t[l2++]=q[i];
    for (int i=l;i<=r;i++) q[i]=t[i];
    solve(l,l1-1,L,mid);
    solve(l1,l2-1,mid+1,R);
}
 
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        q[++num].x=i;q[num].y=a[i];q[num].op=1;q[num].id=0;
    }
    for (int i=1;i<=m;i++)
    {
        char opt[5];
        scanf("%s",opt);
        if (opt[0]=='C')
        {
            int x,y;
            scanf("%d%d",&x,&y);
            q[++num].op=2;q[num].x=x;q[num].y=a[x];q[num].id=0;
            q[++num].op=1;q[num].x=x;q[num].y=y;q[num].id=0;
            a[x]=y;
        }
        else
        {
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            q[++num].op=3;q[num].x=x;q[num].y=y;q[num].k=z;q[num].id=++cnt;
        }
    }
    solve(1,num,0,1000000000);
    for (int i=1;i<=cnt;i++) printf("%d\n",ans[i]);
    return 0;
}
bzoj3110  http://www.lydsy.com/JudgeOnline/showsource.php?id=940098
给树套树跪了（至今还不会树套树）。。。和例题差不多，加了些小操作，用区间修改区间查询搞一搞就好了，还现学了个树状数组区间修改区间查询，真心快呀。




跪一下写线段树的神犇。。。 
/**************************************************************
    Problem: 3110
    User: Oxer
    Language: C++
    Result: Accepted
    Time:1116 ms
    Memory:7620 kb
****************************************************************/
 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
 
using namespace std;
 
struct yts
{
    int x,y,op,cur,k,id;
}q[100010],t[100010];
 
int tmp[100010],ans[100010],c[2][100010];
bool mark[100010];
int n,m,num,cnt;
 
int lowbit(int x)
{
    return x&(-x);
}
 
void modify(int o,int i,int x)
{
    while (i<=n)
    {
        c[o][i]+=x;
        i+=lowbit(i);
    }
}
 
int query(int o,int i)
{
    int tmp=0;
    while (i>0)
    {
        tmp+=c[o][i];
        i-=lowbit(i);
    }
    return tmp;
}
 
void solve(int l,int r,int L,int R)
{
    if (l>r) return;
    if (L==R)
    {
        for (int i=l;i<=r;i++)
          if (q[i].op==2) ans[q[i].id]=L;
        return;
    }
    int mid=(L+R)/2;
    for (int i=l;i<=r;i++)
    {
        if (q[i].op==1)
        {
            if (q[i].k>mid)
            {
                modify(0,q[i].x,1);modify(1,q[i].x,q[i].x-1);
                modify(0,q[i].y+1,-1);modify(1,q[i].y+1,-q[i].y);
            }
        }
        else tmp[i]=(query(0,q[i].y)*q[i].y-query(1,q[i].y))-(query(0,q[i].x-1)*(q[i].x-1)-query(1,q[i].x-1));
    }
    for (int i=l;i<=r;i++)
      if (q[i].op==1 && q[i].k>mid)
      {
        modify(0,q[i].x,-1);modify(1,q[i].x,1-q[i].x);
        modify(0,q[i].y+1,1);modify(1,q[i].y+1,q[i].y);
      }
    int ct=0;
    for (int i=l;i<=r;i++)
    {
        if (q[i].op==2)
        {
            if (q[i].cur+tmp[i]>q[i].k-1) mark[i]=1;
            else ct++,q[i].cur+=tmp[i],mark[i]=0;
        }
        else
        {
            if (q[i].k>mid) mark[i]=1;
            else ct++,mark[i]=0;
        }
    }
    int l1=l,l2=l+ct;
    for (int i=l;i<=r;i++)
      if (!mark[i]) t[l1++]=q[i];
      else t[l2++]=q[i];
    for (int i=l;i<=r;i++) q[i]=t[i];
    solve(l,l1-1,L,mid);
    solve(l1,l2-1,mid+1,R);
}
 
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d%d",&q[i].op,&q[i].x,&q[i].y,&q[i].k);
        if (q[i].op==2) q[i].id=++cnt;
    }
    solve(1,m,-n,n);
    for (int i=1;i<=cnt;i++) printf("%d\n",ans[i]);
    return 0;
}


bzoj2527  http://www.lydsy.com/JudgeOnline/problem.php?id=2527
      这也是一道比较经典的整体二分题目，二分一下时刻，每次二分把它保证操作的时刻<=mid，然后查询一下就可以了。
小技巧：在操作序列最后加入一个极限操作，保证边界不会溢出。
hzwer学长的代码风格确实精简。。。 
/**************************************************************
    Problem: 2527
    User: Oxer
    Language: C++
    Result: Accepted
    Time:12952 ms
    Memory:19324 kb
****************************************************************/
 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
#include<vector>
#define maxn 300010
#define ll long long
#define inf 1000000000
 
using namespace std;
 
ll c[maxn];
int l[maxn],r[maxn],val[maxn],p[maxn];
int tmp[maxn],id[maxn],ans[maxn];
bool mark[maxn];
int n,m,k,T;
vector<int> a[maxn];
 
int lowbit(int x)
{
    return x&(-x);
}
 
void add(int i,int x)
{
    while (i<=m)
    {
        c[i]+=x;
        i+=lowbit(i);
    }
}
 
ll query(int i)
{
    ll q=0;
    while (i>0)
    {
        q+=c[i];
        i-=lowbit(i);
    }
    return q;
}
 
void opera(int i,int f)
{
    if (l[i]<=r[i]) add(l[i],f*val[i]),add(r[i]+1,-f*val[i]);
    else add(1,f*val[i]),add(l[i],f*val[i]),add(r[i]+1,-f*val[i]);
}
 
void solve(int l,int r,int L,int R)
{
    if (l>r) return;
    if (L==R)
    {
        for (int i=l;i<=r;i++)
          ans[id[i]]=L;
        return;
    }
    int mid=(L+R)/2;
    while (T<=mid) {T++;opera(T,1);}
    while (T>mid) {opera(T,-1);T--;}
    ll tot=0;int now,cnt=0;
    for (int i=l;i<=r;i++)
    {
        tot=0;now=id[i];
        for (int j=0;j<a[now].size();j++)
        {
            tot+=query(a[now][j]);
            if (tot>=p[now]) break;
        }
        if (tot>=p[now]) mark[i]=1,cnt++;
        else mark[i]=0;
    }
    int l1=l,l2=l+cnt;
    for (int i=l;i<=r;i++)
      if (mark[i]) tmp[l1++]=id[i];
      else tmp[l2++]=id[i];
    for (int i=l;i<=r;i++) id[i]=tmp[i];
    solve(l,l1-1,L,mid);
    solve(l1,l2-1,mid+1,R);
}
 
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        int x;
        scanf("%d",&x);
        a[x].push_back(i);
    }
    for (int i=1;i<=n;i++) scanf("%d",&p[i]);
    scanf("%d",&k);
    for (int i=1;i<=k;i++)
      scanf("%d%d%d",&l[i],&r[i],&val[i]);
    for (int i=1;i<=n;i++) id[i]=i;
    k++;
    l[k]=1;r[k]=m;val[k]=inf;
    solve(1,n,1,k);
    for (int i=1;i<=n;i++)
      if (ans[i]!=k) printf("%d\n",ans[i]);
      else printf("NIE\n");
    return 0;
}

bzoj2738  http://www.lydsy.com/JudgeOnline/problem.php?id=2738
      第一眼看到数据范围吓傻了。。。什么？！二维可持久化线段树？！原谅我太弱了。。。仔细一看还是比较水的，插入的时候按照权值排序，二分一下答案，每次保证插入的权值<=mid，然后写个二维树状数组查询就好了。应该算是比较经典的例题了。 
/**************************************************************
    Problem: 2738
    User: Oxer
    Language: C++
    Result: Accepted
    Time:11524 ms
    Memory:7276 kb
****************************************************************/
 
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
 
using namespace std;
 
struct yts
{
    int x,y,val;
}a[510*510];
 
struct yts1
{
    int x1,y1,x2,y2,k;
}q[60010];
 
int c[510][510];
int tmp[60010],id[60010],ans[60010];
bool mark[60010];
int n,m,T,cnt;
 
bool cmp(yts x,yts y)
{
    return x.val<y.val;
}
 
int lowbit(int x)
{
    return x&(-x);
}
 
void add(int k,int x)
{
    for (int i=a[k].x;i<=n;i+=lowbit(i))
      for (int j=a[k].y;j<=n;j+=lowbit(j))
        c[i][j]+=x;
}
 
int get(int x,int y)
{
    int tmp=0;
    for (int i=x;i>0;i-=lowbit(i))
      for (int j=y;j>0;j-=lowbit(j))
        tmp+=c[i][j];
    return tmp;
}
 
int query(int i)
{
    int x1=q[i].x1,y1=q[i].y1,x2=q[i].x2,y2=q[i].y2;
    return get(x2,y2)-get(x2,y1-1)-get(x1-1,y2)+get(x1-1,y1-1);
}
 
void solve(int l,int r,int L,int R)
{
    if (l>r) return;
    if (L==R) return;
    int mid=(L+R)/2;
    while (T<cnt && a[T+1].val<=mid) T++,add(T,1);
    while (a[T].val>mid) add(T,-1),T--;
    int cnt=0;
    for (int i=l;i<=r;i++)
    {
        int x=query(id[i]);
        if (x>q[id[i]].k-1) mark[i]=1,ans[id[i]]=mid,cnt++;
        else mark[i]=0;
    }
    int l1=l,l2=l+cnt;
    for (int i=l;i<=r;i++)
      if (mark[i]) tmp[l1++]=id[i];
      else tmp[l2++]=id[i];
    for (int i=l;i<=r;i++) id[i]=tmp[i];
    solve(l,l1-1,L,mid);
    solve(l1,l2-1,mid+1,R);
}
 
int main()
{
    scanf("%d%d",&n,&m);
    int mx=0;
    for (int i=1;i<=n;i++)
      for (int j=1;j<=n;j++)
      {
        a[++cnt].x=i;a[cnt].y=j;
        scanf("%d",&a[cnt].val);
        mx=max(a[cnt].val,mx);
      }
    sort(a+1,a+cnt+1,cmp);
    for (int i=1;i<=m;i++) scanf("%d%d%d%d%d",&q[i].x1,&q[i].y1,&q[i].x2,&q[i].y2,&q[i].k);
    for (int i=1;i<=m;i++) id[i]=i;
    solve(1,m,0,mx+1);
    for (int i=1;i<=m;i++) printf("%d\n",ans[i]);
    return 0;
}

总结：对于询问和修改混合的题目，要记录一下前面的修改操作对后面的贡献。对比一下，整体二分其实是优于许多高端的数据结构的，但是出难题也是比较难想的。

附：树状数组的区间修改、区间查询
记i-n的共同增量为delta[i]，前i项的和为sum[i]，则query(l,r)=sum[r]-sum[l-1]，现在的关键是怎样求sum[i]。
sum[i]=sigma(a[1……i])+i*delta[1]+(i-1)*delta[2]+……+1*delta[i]
 =sigma(a[1……i])+sigma(delta[j]*(i+1-j))
 =sigma(a[1……i])+(i+1)*sigma(delta[j])-sigma(j*delta[j])
这样只要维护一下sigma(delta[i])和sigma(i*delta[i])，问题就解决了。

qingdaobaibai
关注
专栏目录
POJ 2104【整体二分】
Mr.Phoebe的专栏
08-27 1245
整体二分的想法就是将操作进行分块，将相互影响的操作放在一块。这题要注意分治结束条件 在没有离散化的情况下，就要以操作判断结束条件，当然这题操作数比较小，这样的话也更快。 下面的姿势是重排下标，总感觉重排结构体会慢一些….实际上好像没什么影响// whn6325689 // Mr.Phoebe // http://blog.csdn.net/u013007900 #i
整体二分小结
TaoSama's Microcosm
02-15 5304
整体二分小结Ⅰ. 整体二分认知 摘抄部分2013许昊然论文−《浅谈数据结构题的几个非经典解法》摘抄部分2013许昊然论文-《浅谈数据结构题的几个非经典解法》 特么的论文用了啥j8加密编码,还不能复制。。又不是不标出处。特么的论文用了啥j8加密编码, 还不能复制。。又不是不标出处。 Ⅱ. 题目讲解POJ 2104 K-th Number题意: N≤105的序列,|Ai|≤109,
整体二分
蒟蒻QTY
10-01 369
相对于普通二分，整体二分用于处理较多询问.如果用普通二分去处理询问，效率将是O(Q*log×f(？))多出来的Q将无法让人承受。因而有了整体二分。整体二分与二分的最大区别就是对所有询问一同处理。所谓的一同处理，是指省去了二分中的冗余部分，上一个询问二分过这个区间，而当前询问又二分了一次，整体二分保证了没有这个冗余。具体而言，当前带着所有询问传到了一个区间，整理得到一部分询问满足左区间，另一部分满足右
整体二分题表
TYB的博客
12-05 377
整体二分题表
二分
qq_36684096的博客
02-12 426
最基础的二分我们经常用来查找序列中的某个数，当然这要求这个序列是单调的。 常见的二分查找代码如下： int binary(int a[],int low,int high,int x){ //查找是否有此元素 int mid; while(low<=high) { mid=(low+high)/2; if(a[mid]=x)return mid; ...
2014高中三年级语文二轮专题复习-抓分精练系列-文言文整体阅读.doc
10-12
1. 文言文阅读：这是关于高中三年级语文复习资料的文档，主要针对文言文的整体阅读能力进行训练。文言文是中国古代书面语言，理解文言文需要掌握词汇、语法、句式以及历史文化背景等知识。 2. 文言文阅读技巧：包括...
2022年高三二轮复习精品数学 思想二 分类讨论思想（文科） .docx
02-07
分类讨论的思想方法是将一个复杂问题分解为多个更简单、更易于处理的部分，通过逐个解决这些部分来达到解决整体问题的目的。这种思想在处理集合、函数、不等式、几何等多个数学领域都有广泛的应用。 分类讨论通常...
2021届高考地理二轮复习分类解析汇编：自然地理环境的整体性与差异性借鉴.pdf
12-17
2021届高考地理二轮复习分类解析汇编：自然地理环境的整体性与差异性借鉴.pdf
2015届高考历史二轮复习 抓分练 第22课时 “蒸汽”的力量和走向整体的世界
08-19
【标题】和【描述】提及的是高中历史复习的内容，聚焦于工业革命及其对全球一体化的影响。这个主题涉及历史上的重大事件，包括工业革命的起因、影响，以及它如何塑造了18-19世纪的世界格局。 【标签】中的"课件...
全国通用2016高考物理二轮专题复习计算题32分练4
08-06
【全国通用2016高考物理二轮专题复习计算题32分练4】是针对高中物理复习的一份练习资料，旨在帮助学生强化计算题的解答能力。这份资料中的两个题目涉及了牛顿运动定律、摩擦力、动量守恒、电场与磁场的相关知识。 ...
整体二分入门
Zeyu_King的专栏
04-24 2203
骗分神器！ 推荐论文：xhr2013集训队论文 能够整体二分的题目必须满足一下几点（摘自xhr论文） 1、询问答案具有可二分性 2、修改对答案的判定相互独立，互不影响 3、如果修改对询问有贡献，则贡献是确定的，且与判定标准为无关 4、贡献满足结合律、交换律，具有可加性 5、题目允许离线（好像现在大部分题目强制在线） 另外一个很重要的一点就是注意些整体二分时必须是的当前步骤的复杂度只
理解整体二分[例题[Dynamic Rankings]]
FSYo 的博客
10-20 353
[整体二分的概述] 大家应该知道怎么一组找静态区间第k大 二分答案出mid,如果比mid小的数的个数&gt;k , mid变小,否则mid变大 当有很多组时,复杂度很不优秀,因此出现了整体二分 即将所有操作一起二分答案 刚刚理解整体二分时,立马想到了一幅图,与大家分享一下 想必大家看过吧 整体二分就是这么一个过程 很多询问与修改(不同颜色的球) 通过很多层筛选(递归二分) 最终...
kd-tree小结
Oxer的专栏
05-23 5081
来省队集训被吊打，于是无聊学了一下kd-tree，挺好玩的东西。 kd-tree是一种支持查询平面最近点（其实是k维，但这种题目比较少）的数据结构，单次理论时间复杂度O（√n），但实际是非常快的，可以说kd-tree就是一种比较优化的暴力。 kd-tree的思想是将平面进行分割，第一次按第一维分割，第二次按第二维分割，然后接着按第一维分割，直至每个叶子节点只包含一个点，类似线段树的结构。查询时
"二级公共基础知识复习资料：数据结构与算法的基本概念、复杂度分析
以上是关于二级公共基础知识复习资料的相关内容的总结，主要包括数据结构与算法、数据结构的基本知识与应用、数据结构的存储结构、经典的数据结构、算法设计的基本方法、算法分析等方面的内容。包括算法的基本概念、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值