主席树详解 zoj 2112 （单点更新）+ poj 2104 区间第k大

最新推荐文章于 2019-08-06 21:59:57 发布
最新推荐文章于 2019-08-06 21:59:57 发布
阅读量3.1k 收藏
点赞数
分类专栏： 数据结构 ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jackyguo1992/article/details/9746933
版权
解决问题：单点更新，区间询问第k大的数是多少
缺点：容易MLE
复杂度：n*logn*logS （n个数，离散化后有S个不同的数）
1.树状数组套线段树：树状数组表示区间，理论上树状数组上每个元素对应一棵线段树，线段树rank区间在[l,r]的数已经有多少个，所有的线段树的结构都是一样的
2.离线操作，离散化，排序：离散化知道整个操作过程要有哪些数，排序后知道他们的rank是多少，rank值相当于一张表，当要在x位置改成u，在树状数组x,x+=x&(-x).....位置上更新线段树上rank[u]的位置，要查询[l,r]上第k小的数，得到此时第k小的数的rank，查rank表，知道这个数是多少
3.保持历史版本：由于每棵树的结构一样，所以可以共用节点。理论上有n棵线段树，但实际最开始为0，每次更新根据需要在原有的树上加入新节点
4.查询具有f[l,r]=f[1,r]-f[1,l-1]的性质
zoj 2112 
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define MAXN 50050
#define MAXM 10500

class CMT
{
private:
    struct Node
    {
        int sz;
        Node *ch[2];
        Node()
        {
            sz=0;ch[0]=ch[1]=NULL;
        }
        Node(int _sz,Node *ll,Node *rr)
        {
            sz=_sz;ch[0]=ll;ch[1]=rr;
        }
        int gets(){ return this?sz:0;} // 如果为空就返回0
        int getls() { return this?ch[0]->gets():0;}
        int getrs() { return this?ch[1]->gets():0;}
    }pool[(MAXN+MAXM)*40],*a[MAXN],*b[MAXN],*c[40],*d[40]; // pool是总共节点数，a，b是n个数，
    int used,amount,left,right;
//原来有n个数，避免一个个插入时n*logn*logS的复杂度，直接插入n*logS，在a数组上操作
//之后单点更新在b数组上操作，n*logn*logS，b是树状数组模式的操作，b上每个元素对应一棵线段树的根
    Node *malloc(Node *root,int w)
    {
        //if(pool[used]==NULL)
            //pool[used]=new Node(); //new出来后放在内存池，避免TLE
        Node *now=&pool[used++];
        if(root==NULL)//b数组操作时
        {
            now->sz=w;
            now->ch[0]=NULL;//每次复用时要初始化
            now->ch[1]=NULL;
        }
        else//a数组操作时
        {
            now->sz=root->sz+w;
            now->ch[0]=root->ch[0];
            now->ch[1]=root->ch[1];
        }
        return now;
    }
    Node *insert(Node *root,int x,int w,int l,int r)//a数组上的插入
    {
        Node *now=malloc(root,w);
        if(l!=r)
        {
            if(x<=(l+r)/2) now->ch[0]=insert(now->ch[0],x,w,l,l+r>>1);
            else now->ch[1]=insert(now->ch[1],x,w,(l+r>>1)+1,r);
        }
        return now;
    }
    Node *change(Node *root,int x,int w,int l,int r)//b数组上的单点更新
    {
        if(root==NULL) root=malloc(NULL,0);
        if(l!=r)
        {
            if(x<=(l+r>>1)) root->ch[0]=change(root->ch[0],x,w,l,l+r>>1);
            else root->ch[1]=change(root->ch[1],x,w,(l+r>>1)+1,r);
        }
        root->sz+=w;
        return root;
    }
    int query(int k,int lc,int ld,int l,int r)
    {
        if(l==r) return l;
        int sum=0;
        for(int i=0;i<lc;++i)
            if(c[i])
            sum-=c[i]->getls();
        for(int i=0;i<ld;++i)
            if(d[i])
            sum+=d[i]->getls();
        if(k<=sum)
        {
            for(int i=0;i<lc;++i)
                if(c[i])
                c[i]=c[i]->ch[0];
            for(int i=0;i<ld;++i)
                if(d[i])
                d[i]=d[i]->ch[0];
            return query(k,lc,ld,l,l+r>>1);
        }
        else // 如果k大于在左儿子上的个数，说明要找的数在右儿子上
        {
            for(int i=0;i<lc;++i)
                if(c[i])
                c[i]=c[i]->ch[1];
            for(int i=0;i<ld;++i)
                if(d[i])
                d[i]=d[i]->ch[1];
            return query(k-sum,lc,ld,(l+r>>1)+1,r);
        }
    }

public:
    void clear(int n,int l,int r)//l，r是整棵线段树的左右区间，根据全部数排序时是从0还是1开始排，决定l是0还是1
    {
        used=0;
        amount=n;
        left=l;
        right=r;
        for(int i=0;i<=n;++i)// a,b都是1-n的
            a[i]=b[i]=NULL;
    }
    void insert(int i,int x,int w)
    {
        a[i]=insert(a[i-1],x,w,left,right);//a[i]是1-i的叠加
    }
    int query(int l,int r,int k)//要询问[l+1,r]的结果，即f(r)-f(l)
    {
        int lc=0,ld=0;
        c[lc++]=a[l];
        d[ld++]=a[r];
        for(int x=l;x;x-=x&(-x))
            c[lc++]=b[x];
        for(int x=r;x;x-=x&(-x))
            d[ld++]=b[x];
        return query(k,lc,ld,left,right);
    }
    void change(int i,int x,int w)
    {
        while(i<=amount)
        {
            b[i]=change(b[i],x,w,left,right);
            i+=i&(-i);
        }
    }
}cmt;

struct CMD
{
    int x,y,k;
    char ch;
}cmd[MAXM];
int a[MAXN],b[MAXM+MAXN],tot,n,m;

int main ()
{
    int T;scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        tot=0;
        for(int i=0;i<n;++i)
        {
            scanf("%d",&a[i]);
            b[tot++]=a[i];
        }
        for(int i=0;i<m;++i)
        {
            scanf(" %c",&cmd[i].ch);
            if(cmd[i].ch=='Q')
                scanf("%d%d%d",&cmd[i].x,&cmd[i].y,&cmd[i].k);
            else {
                    scanf("%d%d",&cmd[i].x,&cmd[i].k);
                b[tot++]=cmd[i].k;
            }
        }
        sort(b,b+tot);
        int cnt=1;
        for(int i=1;i<tot;++i)
            if(b[i]!=b[i-1])
            b[cnt++]=b[i];
        tot=cnt;

        cmt.clear(n,0,tot-1);
        for(int i=0;i<n;++i)
        {
            int j=lower_bound(b,b+tot,a[i])-b;
            cmt.insert(i+1,j,1);// i+1是a数组上更新的位置，j是对应的线段树更新的位置
        }
        for(int i=0;i<m;++i)
        {
            if(cmd[i].ch=='Q')
            {
                printf("%d\n",b[cmt.query(cmd[i].x-1,cmd[i].y,cmd[i].k)]); //f[l,r]=f[1,r]-f[1,l-1]
            }
            else
            {
                int j=lower_bound(b,b+tot,a[cmd[i].x-1])-b;
                cmt.change(cmd[i].x,j,-1);
                a[cmd[i].x-1]=cmd[i].k;
                j=lower_bound(b,b+tot,a[cmd[i].x-1])-b;
                cmt.change(cmd[i].x,j,1);
            }
        }
    }
    return 0;
}



poj2104 
#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
#define MAXN 105050
#define MAXM 10050

class CMT
{
private:
    struct Node
    {
        int sz;
        Node *ch[2];
        int gets(){ return this?sz:0;} // 如果为空就返回0
        int getls() { return this?ch[0]->gets():0;}
        int getrs() { return this?ch[1]->gets():0;}
    }pool[MAXN*50],*a[MAXN];// pool是总共节点数，a，b是n个数，
    int used,amount,left,right;
//原来有n个数，避免一个个插入时n*logn*logS的复杂度，直接插入n*logS，在a数组上操作
//之后单点更新在b数组上操作，n*logn*logS，b是树状数组模式的操作，b上每个元素对应一棵线段树的根
    Node *malloc(Node *root,int w)
    {
        Node *now=&pool[used++];
        if(root==NULL)//b数组操作时
        {
            now->sz=w;
            now->ch[0]=NULL;//每次复用时要初始化
            now->ch[1]=NULL;
        }
        else//a数组操作时
        {
            now->sz=root->sz+w;
            now->ch[0]=root->ch[0];
            now->ch[1]=root->ch[1];
        }
        return now;
    }
    Node *insert(Node *root,int x,int w,int l,int r)//a数组上的插入
    {
        Node *now=malloc(root,w);
        if(l!=r)
        {
            if(x<=(l+r)/2) now->ch[0]=insert(now->ch[0],x,w,l,l+r>>1);
            else now->ch[1]=insert(now->ch[1],x,w,(l+r>>1)+1,r);
        }
        return now;
    }
    int query(Node *lq,Node *rq,int k,int l,int r)
    {
        if(l==r) return l;
        int sum=rq->getls()-lq->getls();
        if(k<=sum)
        {
            if(lq) lq=lq->ch[0];
            if(rq) rq=rq->ch[0];
            return query(lq,rq,k,l,l+r>>1);
        }
        else
        {
            if(lq) lq=lq->ch[1];
            if(rq) rq=rq->ch[1];
            return query(lq,rq,k-sum,(l+r>>1)+1,r);
        }
    }

public:
    void clear(int n,int l,int r)//l，r是整棵线段树的左右区间，根据全部数排序时是从0还是1开始排，决定l是0还是1
    {
        used=0;
        amount=n;
        left=l;
        right=r;
        for(int i=0;i<=n;++i)// a,b都是1-n的
            a[i]=NULL;
    }
    void insert(int i,int x,int w)
    {
        a[i]=insert(a[i-1],x,w,left,right);//a[i]是1-i的叠加
    }
    int query(int l,int r,int k)
    {
        return query(a[l],a[r],k,left,right);
    }

}cmt;

struct CMD
{
    int x,y,k;
}cmd[MAXM];
int a[MAXN],b[MAXN],tot,n,m;

int main ()
{
        scanf("%d%d",&n,&m);
        tot=0;
        for(int i=0;i<n;++i)
        {
            scanf("%d",&a[i]);
            b[++tot]=a[i];
        }
        for(int i=0;i<m;++i)
        {
            scanf("%d%d%d",&cmd[i].x,&cmd[i].y,&cmd[i].k);
        }
        sort(b+1,b+1+tot);
        int cnt=1;
        for(int i=2;i<=tot;++i)
            if(b[i]!=b[i-1])
            b[++cnt]=b[i];
        tot=cnt;

        cmt.clear(n,1,tot);
        for(int i=0;i<n;++i)
        {
            int j=lower_bound(b+1,b+1+tot,a[i])-b;
            cmt.insert(i+1,j,1);// i+1是a数组上更新的位置，j是对应的线段树更新的位置
        }
        for(int i=0;i<m;++i)
        {
                printf("%d\n",b[cmt.query(cmd[i].x-1,cmd[i].y,cmd[i].k)]); //f[l,r]=f[1,r]-f[1,l-1]
        }

    return 0;
}


未水
关注
专栏目录
动态主席树 单点更新 动态区间第k小
唐大帅
04-19 226
P2617 Dynamic Rankings 题目描述 给定一个含有n个数的序列a[1],a[2],a[3]……a[n]，程序必须回答这样的询问：对于给定的i,j,k，在a[i],a[i+1],a[i+2]……a[j]中第k小的数是多少(1≤k≤j-i+1)，并且，你可以改变一些a[i]的值，改变后，程序还能针对改变后的a继续回答上面的问题。你需要编一个这样的程序，从输入文件中读入序列a，然后...
zoj 2112 Dynamic Rankings（动态第k大，树状数组套主席树）
梦幻的蔷薇色
11-01 420
这个题在kuangbin大佬的模板里有。 http://www.cnblogs.com/kuangbin/p/3308118.html kuangbin大佬博客里有四个学习连接。#include <bits/stdc++.h> using namespace std;const int MAXN = 60010; struct node { int l,r,sum; }T[MAXN*30
主席树 单点更新 区间第k大
malanlllll的的的的的博客
05-03 430
话不多说直接写（好像咕了好久了）----2019.5.3 文章目录主席数的概念luoguP3919poj 区间第k大 主席数的概念 主席树又叫可持续性线段树，它可以保存区间各个修改时段的状态。它通过在原树上不断附加单链来实现logn复杂度的修改和记忆，子树间的联系不再是乘2或乘2加1而是通过直接存数组下标来实现保存（类似指针）。对不同时段的搜索也是依靠记录该时段根的下标来实现的。 讲一下主席树的搜...
主席树板子（带单点更新&&不带更新）
black_horse2018的博客
05-29 224
// 带单点更新的 #include <stdio.h> #include <string.h> #include <iostream> #include <algorithm> #include <vector> #include <queue> #include <set> #include <ma...
ZOJ - 2112 动态单点修改主席树
twh233的算法blog
10-30 372
题目链接 参考博客：https://www.cnblogs.com/Empress/p/4659824.html 题意：n个数，q个询问 (n&lt;=50000, q&lt;=10000) Q x y z 代表询问[x, y]区间里的第z小的数 C x y    代表将(从左往右数)第x个数变成y     对于更新， 我们不改变这些已经建好的树， 而是另建一批树S，用来记录更新，而...
【动态主席树】ZOJ 2112【树状数组+主席树】
Gene_I must wait for the sunrise
11-18 339
题意： 给定一个区间，求这个区间第k小的数，支持单点修改。 思路： 动态主席树裸题。 我们先来回顾一下静态主席树的做法，对于数组中每一个位置都维护一棵权值线段树，该权值线段树保存的是区间 [1,x] 的信息。因此我想要求区间 [l,r] 之间第k大的时候，只需要将root[r]-root[l-1]就是维护区间 [l,r] 信息的权值线段树，因此就可...
主席树入门详解一（学习笔记）（例题POJ-2104 求区间第k小）
QDU_ZXF的博客
07-20 5000
学习主席树，在网上搜了很多教程（都好简短啊，直接就是几行字就上代码，看不懂啊有木有~~），最后才很艰难的学会了最基础的部分。下面就是我在学习的过程中的产生的疑惑和解决的办法。 学习主席树需要的前置技能：线段树。 参考资料 1. B站上的视频讲解（话说B站真的啥都有啊） https://www.bilibili.com/video/av4619406/?p=1 2.参考博客 https:...
zoj 2112 Dynamic Rankings 带修改区间第k大的几种解法
写东西的地方
08-16 3743
给出n个数，有两种操作，一种是修改某个数的值，另一种查询指定区间第k大。 比较快的做法是树套树，而分块算法复杂度比较高写起来方便。分块算法可以很简单的处理单独修改某个值的情况。 将n个数分成num块，每块大小siz=n/num。每一块内部排序进行排序，查询[l,r]第k大时，先二分答案，对于完全包含在区间的内块直接二分搜索，而对于区间两端只有部分包含的则直接遍历查找。复杂度是logn*(2*s
zoj-2112(主席树动态求区间第k小数)
AC之路
08-25 2410
总算是把动态求区间第k个数的算法看明白了。 在主席树的基础上，如果有修改操作，则要通过套树状数组来实现任意区间求第k小的问题。 刚开始看不明白什么意思，现在有一点理解。树状数组的每个元素是一个线段树，来维护修改后的前后缀和，树状数组能在log时间内更整个数组，现在用相同的方式更新整个线段树数组，每次更新一个点时，要更新这个点代表的整个线段树。同样的，求和时用一个use数组记录所要更新的点的下标
ACM训练必备POJ ZOJ题目分类及解题思路
04-19
学习ACM程序设计的朋友一定要看，这是训练必备的POJ ZOJ题目分类及解题思路
树套树-区间第k大（带修改）
w20810的专栏
01-05 2319
题目：zoj2112 题意：求区间第k大的数，有修改操作。 分析：这题可以树套树搞。 从网上看了很多博客才理解。。。资料1  资料2 我看的是树状数组套线段树版的。还有线段树套平衡树版的。 首先用一棵主席树（见这篇文章）维护没有操作前的数据。 然后用树状数组维护修改。 树状数组的每一个节点是一棵线段树，而且树状数组的每个节点都有一个管辖域（树状数组的性质没变）。 每更新一次
zoj2112
08-26 116
这道题是要求待修改的区间第k值，看的kuangbin的树状数组加主席树，这种方法是离线的。本来是想做hdu5412的，结果超时，所以只能交了zoj2110。没什么多说的，就是模板题。如果要求第k大，只要做相应的修改就行了，有多种修改的方法，只要能的出正确答案就行。 参考代码：http://www.cnblogs.com/kuangbin/p/3308118.html （今天为...
Dynamic Rankings ZOJ - 2112 树套树 带修改主席树
loooooog的博客
08-24 148
求区间第K大，很简单——-主席树即可； 那么如果增加一个修改操作，又该怎么处理呢？ 单点修改—-很容易想到 树状数组； 此时树状数组每个节点存的是一颗空树； 详细的解释，说明 #include&lt;iostream&gt; #include&lt;cstdio&gt; #include&lt;algorithm&gt; #include&lt;cstdlib&gt; #include&...
bzoj 1901/zoj 2112（主席树+树状数组）
KGV093的博客
10-07 372
传送门 题解：又一道《万年A不掉》系列。外层树状数组维护内层权值线段树，修改/查询/空间复杂度都是(O(nlog(n)^2))。关于前缀，由静态root[r]-root[l]变为两个按树状数组lowbit处理过的root池(PL,PR)相减。 P.S.今天终于大概明白树状数组到底怎么在外层维护权值线段树，具体注释将尽快附上。#include<cstdio> #include<cstring> #
动态主席树 可修改主席树 ZOJ 2112
精通时间管理
08-06 436
题意: n个数，q个询问 (n<=50000, q<=10000) Q x y z 代表询问[x, y]区间里的第z小的数 C x y 代表将(从左往右数)第x个数变成y 【样例】 1 5 3 3 2 1 4 7 Q 1 4 3 C 2 6 Q 2 5 3 这里离散化建树过程和静态主席树有一点不同，我们必须把所有询问先存起来并且把改变的数也加入到原序列中再离散化建树，会导致空间复...
zoj 2112 （主席树，树状数组套线段树）
know_heng的博客
09-22 330
Dynamic Rankings Time Limit: 10 Seconds      Memory Limit: 32768 KB The Company Dynamic Rankings has developed a new kind of computer that is no longer satisfied with the query like to simply
ZOJ2112
binarycopycode
02-01 342
动态求区间第k小，整体二分蛤不清be（菜哭.jpg ，给Qt的板子注释了一蛤 #include #include #include using namespace std; const int N = 5e4 + 7; const int M = 1e5 + 7; const int INF = 1 << 30; struct Quiry { int x,y,z,id,tp; }Q[ N
zoj2112 分类： templates z...
aa288288的博客
07-20 109
树状数组套主席树 好像没有什么特别的地方，就是要注意卡空间。 先处理出初始序列的主席树 O(N∗log(N+M)) 然后用树状数组记录修改 O(M∗logN∗log(N+M)) 时间复杂度/空间复杂度: O((N+M∗logN)∗log(N+M)) #include <cstdio> #include <cstdlib...
ACM训练精选：POJ ZOJ题目分类与高效解题策略
在POJ（Polynomial Olympiad in Java）和ZOJ（Zhejiang Online Judge）等平台，你可以找到大量的编程题目，涵盖了多种算法类型和知识领域。本文档列出了部分精选题目及其所属的类别，对于学习和提升ACM技能非常有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值