BZOJ3196: Tyvj 1730 二逼平衡树

最新推荐文章于 2018-07-14 23:11:20 发布
最新推荐文章于 2018-07-14 23:11:20 发布
阅读量583 收藏
点赞数
分类专栏： 树套树 文章标签： BZOJ 树套树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liutian429073576/article/details/50251749
版权 

#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
inline int min(int a,int b)
{return (a<b?a:b);}
inline int max(int a,int b)
{return (a>b?a:b);}
 inline int abs(int a)
{return (a<0?-a:a);}

char c;
bool flag; 
inline void read(int &a)
{
    a=0;flag=false;
    do c=getchar();while(c!='-'&&(c<'0'||c>'9'));
    if(c=='-')c=getchar(),flag=true;
    while(c<='9'&&c>='0')a=(a<<3)+(a<<1)+c-'0',c=getchar();
    if(flag)a=-a;
}
inline void print(int a)
{
	if(a<0)putchar('-'),a=-a;
	if(a<10){putchar('0'+a),putchar('\n');return;}
    long long base=1;
    while(base<=a)
     base=(base<<3)+(base<<1);
    base/=10;
    while(base)putchar('0'+a/base),a%=base,base/=10; 
    putchar('\n');
} 
struct Node
{
    Node *f,*lc,*rc;
    int data,rank,size;
   inline bool l(){return this->f->lc==this;}
};
Node *sta=new Node[1000001];
int cc;
int max_Con=1000000;
Node *stack[1000001];
inline Node* Node_Stackpop()
{
	return stack[cc--];
}
inline void Node_Stackpush(Node *a)
{stack[++cc]=a;}
Node *empty;
inline void begin(){empty=new Node;empty->f=empty;empty->lc=empty->rc=empty;empty->data=empty->size=empty->rank=0;cc=max_Con;for(int i=0;i<=max_Con;i++)stack[i]=sta+i;}

inline Node *New_Node(){Node *tp=Node_Stackpop();tp->lc=tp->rc=empty;tp->size=1;tp->rank=1;return tp;}
inline void up_data(Node *a)
{a->rank=a->lc->size+1;a->size=a->lc->size+a->rc->size+1;}
inline void lc_change(Node *a)
{
    if(a->f==a)
       return ;
    Node *newf;
    if(a->f->f==a->f)
       newf=a;
    else if(a->f->l())
       a->f->f->lc=a,newf=a->f->f;
    else
       a->f->f->rc=a,newf=a->f->f;
    a->rc->f=a->f;
    a->f->lc=a->rc;
    a->rc=a->f;
    a->f->f=a;
    a->f=newf;
    up_data(a->rc);
    up_data(a);
}
inline void rc_change(Node *a)
{
    if(a->f==a)
       return ;
    Node *newf;
    if(a->f->f==a->f)
       newf=a;
    else if(a->f->l())
       a->f->f->lc=a,newf=a->f->f;
    else
       a->f->f->rc=a,newf=a->f->f;
    a->lc->f=a->f;
    a->f->rc=a->lc;
    a->lc=a->f;
    a->f->f=a;
    a->f=newf;
    up_data(a->lc);
    up_data(a);
}
inline void Change(Node *a)
{a->l()?lc_change(a):rc_change(a);}
inline void Twice_Change(Node *a)
{if(a->l()==a->f->l())Change(a->f);else Change(a);Change(a);}
inline void Spaly(Node *a)
{while(a->f->f!=a->f)Twice_Change(a);while(a->f!=a)Change(a);}
inline void insert(Node *a,Node *data)
{
    if(a->data>=data->data)
       if(a->lc==empty)
          a->lc=data,data->f=a,Spaly(data);
        else insert(a->lc,data);
    else if(a->rc==empty)
        a->rc=data,data->f=a,Spaly(data);
        else insert(a->rc,data);
}
const
  int INF=100000000;
int Find_Rank(Node *a,int data)
{
      if(a->data>data)
       if(a->lc==empty)
           return 1;
       else return Find_Rank(a->lc,data);
     else if(a->data==data)
         if(a->lc!=empty)
          return min(a->rank,Find_Rank(a->lc,data));   
         else return a->rank;
     else if(a->rc==empty)
           return a->rank+1;
     else return Find_Rank(a->rc,data)+a->rank;
}
int Pre(Node *a,int data)
{
      if(a->data>=data)
       if(a->lc==empty)
           return -INF;
       else return Pre(a->lc,data);
     else if(a->rc==empty)
           return a->data;
     else return max(a->data,Pre(a->rc,data));
}
bool Has(Node *a,int data)
{
    if(a->data==data)return true;
      if(a->data>data)
       if(a->lc==empty)
           return false;
       else return Has(a->lc,data);
     else if(a->rc==empty)
           return false;
     else return Has(a->rc,data);
}
int Aft(Node *a,int data)
{
      if(a->data>data)
       if(a->lc==empty)
           return a->data;
       else return min(a->data,Aft(a->lc,data));
     else if(a->rc==empty)
           return INF;
     else return Aft(a->rc,data);
}
int Find_Data(Node *a,int rank)
{
    if(a->rank==rank) 
        return a->data;
    else if(a->rank>rank)
       return Find_Data(a->lc,rank);
    return Find_Data(a->rc,rank-a->rank);
}
struct Segement_Node
{
   Node *root;
   int l,r;
}Segement_Tree[1000001];
int data[1000001];
inline void Delete(Node *a,int Sege_place)
{
    Node *first;
    if(a==Segement_Tree[Sege_place].root)
       if(a->lc!=empty)
          Segement_Tree[Sege_place].root=a->lc;
        else
          Segement_Tree[Sege_place].root=a->rc;
    else;
    while(a->lc!=empty||a->rc!=empty)
     if(a->lc!=empty)
      Change(a->lc);
    else Change(a->rc);
    (a->l()?a->f->lc:a->f->rc)=empty;
    up_data(a->f);
    Spaly(a->f);
    Segement_Tree[Sege_place].root=a->f; 
    Node_Stackpush(a);
}
void era(Node *a,int data,int Sege_place)
{
   if(a->data==data)
        Delete(a,Sege_place);
   else if(a->data<data)
       era(a->rc,data,Sege_place),up_data(a);
   else if(a->data>data)
       era(a->lc,data,Sege_place),up_data(a);
}
 
void Build_Segement_Tree(int place,int l,int r)
{
    Segement_Tree[place].l=l;
    Segement_Tree[place].r=r;
    Segement_Tree[place].root=New_Node();
    Segement_Tree[place].root->f=Segement_Tree[place].root;
    Segement_Tree[place].root->data=data[l];
    int i;
    Node *tp=Segement_Tree[place].root;
    for(i=l+1;i<=r;i++)
    tp=New_Node(),tp->data=data[i],insert(Segement_Tree[place].root,tp),
    Segement_Tree[place].root=tp;
    if(l^r)
       Build_Segement_Tree(place<<1,l,(l+r)>>1),Build_Segement_Tree(place<<1|1,1+((l+r)>>1),r);
}
int Change_Segement_Tree(int place,int l,int data)
{
    int del_data;
    if(Segement_Tree[place].l^Segement_Tree[place].r) 
       {
       if(Segement_Tree[place<<1].r>=l)
          del_data=Change_Segement_Tree(place<<1,l,data);
       else
         del_data=Change_Segement_Tree(place<<1|1,l,data);
       era(Segement_Tree[place].root,del_data,place);
       Node *tp=New_Node();
       tp->data=data;
       insert(Segement_Tree[place].root,tp),
       Segement_Tree[place].root=tp;
       return del_data;
      }
    else
     {
        del_data=Segement_Tree[place].root->data;
        Segement_Tree[place].root->data=data;
        return del_data;
     }
}
bool Segement_Has(int place,int l,int r,int data)
{
 
    if(l<=Segement_Tree[place].l&&Segement_Tree[place].r<=r)
       return Has(Segement_Tree[place].root,data);
    int re=0;
    if(Segement_Tree[place<<1].r>=l)
       re=Segement_Has(place<<1,l,r,data);
    if(re)return true;
    if(Segement_Tree[place<<1|1].l<=r)
       re=Segement_Has(place<<1|1,l,r,data);
    return re;
}
int Segement_Rank(int place,int l,int r,int data)
{
    if(l<=Segement_Tree[place].l&&Segement_Tree[place].r<=r)
       return Find_Rank(Segement_Tree[place].root,data);
    int re=0;
    if(Segement_Tree[place<<1].r>=l)
       re+=Segement_Rank(place<<1,l,r,data)-1;
    if(Segement_Tree[place<<1|1].l<=r)
       re+=Segement_Rank(place<<1|1,l,r,data)-1;
    return re+1;
}
 
int Segement_Rank2(int place,int l,int r,int data)
{
    if(l<=Segement_Tree[place].l&&Segement_Tree[place].r<=r)
       return Find_Rank(Segement_Tree[place].root,data);
    int re=0;
    if(Segement_Tree[place<<1].r>=l)
       re+=Segement_Rank2(place<<1,l,r,data)-1;
    if(Segement_Tree[place<<1|1].l<=r)
       re+=Segement_Rank2(place<<1|1,l,r,data)-1;
    return re+1;
}
 
int Segement_Pre(int place,int l,int r,int data)
{
    if(l<=Segement_Tree[place].l&&Segement_Tree[place].r<=r)
       return Pre(Segement_Tree[place].root,data);
   int re=-INF;
    if(Segement_Tree[place<<1].r>=l)
       re=Segement_Pre(place<<1,l,r,data);
    if(Segement_Tree[place<<1|1].l<=r)
       re=max(re,Segement_Pre(place<<1|1,l,r,data));
    return re;
}
int Segement_Aft(int place,int l,int r,int data)
{
    if(l<=Segement_Tree[place].l&&Segement_Tree[place].r<=r)
       return Aft(Segement_Tree[place].root,data);
   int re=INF;
    if(Segement_Tree[place<<1].r>=l)
       re=Segement_Aft(place<<1,l,r,data);
    if(Segement_Tree[place<<1|1].l<=r)
       re=min(re,Segement_Aft(place<<1|1,l,r,data));
    return re;
}
 
inline int Divid(int k,int l,int r)
{
    int data,li=k,ri=Segement_Tree[1].root->size;
    int  mid,cp;
     while(li<(ri-1))
     {
        mid=(li+ri)>>1;
        data=Find_Data(Segement_Tree[1].root,mid);
        if(Segement_Rank2(1,l,r,data)<=k)
           li=mid;
        else
           ri=mid-1;
    }     
    data=Find_Data(Segement_Tree[1].root,li);
    if(Segement_Has(1,l,r,data)&&Segement_Rank2(1,l,r,Find_Data(Segement_Tree[1].root,ri))!=k)
       return data;
    else
       return    Find_Data(Segement_Tree[1].root,ri);
         
}
int main()
{
    int i,n,m,j,k,l;
    read(n),read(m);
    for(i=1;i<=n;i++)   read(data[i]);
    begin();
    int data;
    Build_Segement_Tree(1,1,n);
    for(i=1;i<=m;i++)
       {
         read(j);
         if(j==1)
            {
                read(k),read(l),read(data);
                print(Segement_Rank(1,k,l,data));
            }
        else if(j==2)
            {
                read(j),read(k),read(l);
               print(Divid(l,j,k));
            }
        else if(j==3)
             {
                read(j),read(k);
                Change_Segement_Tree(1,j,k);
             }
        else if(j==4)
             {
                read(j),read(k),read(l);
                print(Segement_Pre(1,j,k,l));
             }
        else if(j==5)
             {
                read(j),read(k),read(l);
                print(Segement_Aft(1,j,k,l));
			 }
       }
    return 0;
}

人生第一道树套树。。。

反正就是线段树套平衡树。。。不过听Claris说把外层换成权值线段树然后用内部平衡树维护区间可以少一个log。。。Orz反正我是不会

一开始一直RE然后才发现是自己脑残New Node的时候没有返回tp的地址 windows上居然可以过去  误

不管怎么说  还是自己太弱了QAQ

Hillan_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BZOJ第二部分
11-04
BZOJ原题-BZOJP2001-P3000的题目，下载后可以离线做题。
bzoj3196 二逼平衡树 树状数组套线段树
weixin_30384217的博客
02-24 116
题目传送门 思路：树状数组套线段树模板题。 　　什么是树状数组套线段树，普通的树状数组每个点都是一个权值，而这里的树状数组每个点都是一颗权值线段树，我们用前缀差分的方法求得每个区间的各种信息， 　　其实关键就一句话，把树状数组更新的$sum[x]+=val$改成$Modify(rt[i],1,tot,a[pos],w);$。 　　这道题的最大坑点就是分数可能重复，所以对于操作1和...
BZOJ3196(TYVJ1730)二逼平衡树
weixin_34148340的博客
08-05 99
传送门：http://www.lydsy.com:808/JudgeOnline/problem.php?id=3196 http://www.tyvj.cn/Problem_Show.aspx?id=1730 3196: Tyvj 1730 二逼平衡树 Time Limit: 10 SecMemory Limit: 128 MB Descriptio...
BZOJ 3196: Tyvj 1730 二逼平衡树|线段树套平衡树
ws_yzy的博客
02-23 985
第一次写真正的树套树：线段树套平衡树？！（平衡树套线段树？！） 线段树维护的是区间，然后对于线段树维护的区间的所有数字都维护一个平衡树，然后所有的操作都对每个平衡树单独处理。 比如说操作3，需要先二分答案，然后再询问每个区间的平衡树来judgejudge 这样的复杂度是log3nlog^3n的，感觉好暴力！！分块什么的肯定也可以搞一搞。 树状数组套主席树怎么没人写，真的会MLE吗 好久没写
【BZOJ3196】【Tyvj1730】二逼平衡树，第一次的树套树（线段树+splay）
xiaoyimi的博客
04-07 2506
伟人改变环境，能人利用环境，凡人适应环境，庸人不适应环境。
BZOJ3196: 二逼平衡树 题解
IcePrincess_1968's World
07-14 296
Description 您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作： 1.查询k在区间内的排名 2.查询区间内排名为k的值 3.修改某一位值上的数值 4.查询k在区间内的前驱(前驱定义为小于x，且最大的数) 5.查询k在区间内的后继(后继定义为大于x，且最小的数) Input 第一行两个数 n,m 表示长度为n的有序序列和m个操作 第二行...
BZOJ_problem_rank:BZOJ问题等级按交流比排序
05-25
#BZOJ Problem Rankrank.cpp 程序文件data.dat bzoj题库数据done.dat AC过的题，初始可以把所有A过的题粘进去，正常退出的话自动维护。black.dat 黑名单。选题时会跳过。错题、神题、没题面、不想做等等。//Thank ...
BZOJ全代码
02-05
BZOJ平台全部代码，解压到一个文件夹在打开使用。BZOJ平台全部代码，解压到一个文件夹在打开使用。
BZOJ第一部分
11-03
BZOJ原题-BZOJP1000-P2000的题目，下载后可以离线做题。
BZOJ3230相似子串测试数据
08-19
BZOJ3230相似子串的测试数据，希望能够帮到大家。
[树套树] BZOJ3196: 二逼平衡树
Lynstery's blog
04-14 715
题意您需要写一种数据结构（可参考题目标题），来维护一个有序数列，其中需要提供以下操作： 1.查询k在区间内的排名 2.查询区间内排名为k的值 3.修改某一位值上的数值 4.查询k在区间内的前驱(前驱定义为小于x，且最大的数) 5.查询k在区间内的后继(后继定义为大于x，且最小的数)题解求区间第k大，树套数模板题。 外层线段树定序列，内层平衡树询问信息。#include<cstdio> #
【BZOJ】3196 Tyvj 1730 二逼平衡树 线段树+平衡树
Chester King
01-03 279
题目传送门这题除了烦一点，其实也没什么大不了的嘛……就是外层一棵区间线段树，内层套上splay，除了第二个操作需要套一个二分，时间复杂度为O(log32n)O(\log_2^3n)，其他的操作的时间复杂度都是O(log22n)O(\log_2^2n)。主要是细心吧，耐心一点写都能过的吧。p.s.话说内存不够导致TLE什么的好鬼啊……还是ZZK大佬最强了，一眼就看出了问题。附上AC代码：#includ
multi_treap
moon_NO2015的博客
08-21 335
#include #include #include using namespace std; class multi_treap//multi_treap和treap类似，也是一种排序二叉树，但支持重复元素，其他功能上和treap一样 { private: struct node//multi_treap的节点定义 { node* ch[2]; int v, r, s, num;
bzoj 3196: Tyvj 1730 二逼平衡树
clover_hxy的博客
04-28 497
#include #include #include #include #include #define N 2000003 #define M 50003 using namespace std; int n,m; int ls[4*M],rs[4*M],root[4*M]; int ch[N][3],fa[N],maxn,a[N],size[N],key[N],cnt[N],sz; void
BZOJ3196 二逼平衡树 Solution
守望、御神木
10-02 1133
题意：写一个数据结构支持如下操作： （1）区间第k大 （2）区间内求某个数的排名 （3）修改某个位置的数 （4）区间内求某个数的前趋、后继。 Sol:以下提供两种做法。 Sol1:线段树套平衡树。非常裸的做法，除询问区间第k大复杂度为O(log^3n),其余操作时间复杂度为O(log^2n). Code1: #include #include #include #defin
[BZOJ3196]二逼平衡树（线段树套splay）
zyf2000
04-29 2765
花费了不知多少页来描述我们的心情 却不知为何填不满一行的空白
bzoj3196/洛谷P3380 线段树套splay 【附赠数据生成器】
litble的成(tui)长(fei)史
01-06 462
假标题：震惊！一只蒟蒻两天刷新两次最长代码记录，这究竟是数据结构的扭曲还是代码能力的沦丧？ 题目分析 线段树，套splay嘛。如题所言，我们就弄一棵线段树，然后线段树的每一个节点都是一棵splay，这样就方便完成各种操作。 那么这道题（应该）唯一要讲解的就是第二个操作啦，第二个操作就是二分答案＋第一个操作。其他的让代码来解答吧。 代码 #include using namespace
3196: Tyvj 1730 二逼平衡树 线段树套平衡树
ws_fqk
02-13 903
看了看上次刷题时间是2.4真是感人。。似乎从WC回来后就一直在颓废。。 假期的最后一天决定刷几个题收收心。。清早来一发数据结构压压惊。。 线段树套平衡树裸题啦。。 一定是我的姿势不对好慢啊qwq#include<iostream> #include<cstdio> #include<cstdlib> #define N 50005 #define M 3000005 #define inf
【BZOJ 3196】[Tyvj 1730]二逼平衡树
SunIsMe的博客
03-22 298
题目描述传送门–Portal题目解析题目都说了是平衡树，肯定就是平衡树板题，又因为是区间操作，树套树就行了。（第一次写，就写的线段树套Splay，感觉Splay跑得shi慢。。。一定是蒟蒻自带大常数的原因）唯一要思考的就是如何找到区间第k大，很简单，二分判定就行了。 又因为Splay的点更新问题，Wa了我3个小时，以后一定要记住，只要有修改，一定要更新！！！而且是更新当前节点的所有信息，尤其是标记
BZOJ2839:集合计数(容斥,组合数学)
最新发布
06-08
这个问题是一个比较经典的容斥原理的应用题目。我们可以考虑使用容斥原理来求解这个问题。具体来说，我们可以考虑求出所有集合的个数，然后减去至少包含一个特定元素的集合的个数，再加上至少包含两个特定元素的集合...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值