动态主席树

最新推荐文章于 2021-06-08 11:22:40 发布
最新推荐文章于 2021-06-08 11:22:40 发布
阅读量210 收藏
点赞数
分类专栏： 数据结构 文章标签： 动态主席树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_17080419/article/details/102905084
版权

动态主席树

P2617 Dynamic Rankings

在这里插入图片描述

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=1e5+10;

int n,m,a[maxn],b[maxn*2],total;
int ST[maxn*300],ls[maxn*300],rs[maxn*300],no,root[maxn];
int ql[20],qr[20],cnt1,cnt2;

struct Opt
{
    int l,r,k,x,y;
    int tag;
}opt[maxn];

inline int lowbit(int x)
{
    return x&(-x);
}

void Update(int &rt,int pos,int L,int R,int val)
{
    if(!rt)
        rt=++no;
    ST[rt]+=val;
    if(L==R)
        return;
    int mid=(L+R)>>1;
    if(pos<=mid)
        Update(ls[rt],pos,L,mid,val);
    if(pos>mid)
        Update(rs[rt],pos,mid+1,R,val);
}

void add(int x,int val)
{
    int pos=lower_bound(b+1,b+1+total,a[x])-b;
    for(int i=x;i<=n;i+=lowbit(i))
        Update(root[i],pos,1,total,val);
}

int Query(int L,int R,int k)
{
    if(L==R)
        return L;
    int sum=0;
    for(int i=1;i<=cnt1;++i)
        sum-=ST[ls[ql[i]]];
    for(int i=1;i<=cnt2;++i)
        sum+=ST[ls[qr[i]]];
    int mid=(L+R)>>1;
    if(k-sum<=0)
    {
        for(int i=1;i<=cnt1;++i)
            ql[i]=ls[ql[i]];
        for(int i=1;i<=cnt2;++i)
            qr[i]=ls[qr[i]];
        return Query(L,mid,k);
    }
    else
    {
        for(int i=1;i<=cnt1;++i)
            ql[i]=rs[ql[i]];
        for(int i=1;i<=cnt2;++i)
            qr[i]=rs[qr[i]];
        return Query(mid+1,R,k-sum);
    }
}

int PreQuery(int l,int r,int k)
{
    cnt1=0,cnt2=0;
    for(int i=l;i>0;i-=lowbit(i))
        ql[++cnt1]=root[i];
    for(int i=r;i>0;i-=lowbit(i))
        qr[++cnt2]=root[i];
    return Query(1,total,k);
}

int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);
        b[i]=a[i];
    }

    int cnt=n;
    for(int i=1;i<=m;++i)
    {
        char op[10];
        scanf("%s",op);
        if(op[0]=='Q')
        {
            scanf("%d%d%d",&opt[i].l,&opt[i].r,&opt[i].k);
            opt[i].tag=1;
        }
        else
        {
            scanf("%d%d",&opt[i].x,&opt[i].y);
            opt[i].tag=0;
            b[++cnt]=opt[i].y;
        }
    }

    sort(b+1,b+1+cnt);
    total=unique(b+1,b+1+cnt)-b-1;

    for(int i=1;i<=n;++i)
        add(i,1);

    for(int i=1;i<=m;++i)
    {
        if(!opt[i].tag)
        {
            add(opt[i].x,-1);
            a[opt[i].x]=opt[i].y;
            add(opt[i].x,1);
        }
        else
        {
            int pos=PreQuery(opt[i].l-1,opt[i].r,opt[i].k);
            printf("%d\n",b[pos]);
        }
    }
    return 0;
}

动态主席树就是构建n棵权值线段树，每棵树理论上会有total个节点。但其实只需要关注属于自己的一条路径就可以了。当然第x棵树上还是会有前面的节点更新过来的节点。

然后用树状数组去关联这n棵线段树。

add：每次修改一棵线段树x，都要给x~n中相关联的做Update操作
Update：根据节点的位置给途中遇到的每个节点做更新
Query：每次查询前，处理好下一层需要访问的根节点，之后才能继续往下走

H. Yuuki and a problem

离散化

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=2e5+10;

int n,q,total;
int a[maxn],b[maxn*2];
ll ST[maxn*150];
int ls[maxn*150],rs[maxn*150],root[maxn],no;
int cnt1,cnt2,ql[20][20],qr[20][20];

struct Opt
{
    int l,r;
    int tag;
}opt[maxn];

inline int lowbit(int x)
{
    return x&(-x);
}

void Update(int &rt,int pos,int L,int R,int val)
{
    if(!rt)
        rt=++no;
    ST[rt]+=val;
    if(L==R)
    	return;
    int mid=(L+R)>>1;
    if(pos<=mid)
        Update(ls[rt],pos,L,mid,val);
    if(pos>mid)
        Update(rs[rt],pos,mid+1,R,val);
}

void add(int x,int val)
{
    int pos=lower_bound(b+1,b+1+total,a[x])-b;
    for(int i=x;i<=n;i+=lowbit(i))
        Update(root[i],pos,1,total,val);
}

ll Query(int l,int r,int L,int R,int d)
{
    if(l<=L&&R<=r)
    {
        ll ans=0;
        for(int i=1;i<=cnt1;++i)
            ans-=ST[ql[d][i] ];
        for(int i=1;i<=cnt2;++i)
            ans+=ST[qr[d][i] ];
        return ans;
    }

    int mid=(L+R)>>1;
    ll ans=0;
    if(l<=mid)
    {
        for(int i=1;i<=cnt1;++i)
            ql[d+1][i]=ls[ql[d][i]];
        for(int i=1;i<=cnt2;++i)
            qr[d+1][i]=ls[qr[d][i]];
        ans+=Query(l,r,L,mid,d+1);
    }
    if(r>mid)
    {
        for(int i=1;i<=cnt1;++i)
            ql[d+1][i]=rs[ql[d][i]];
        for(int i=1;i<=cnt2;++i)
            qr[d+1][i]=rs[qr[d][i]];
        ans+=Query(l,r,mid+1,R,d+1);
    }
    return ans;
}

ll PreQuery(int l,int r,int pos)
{
    memset(ql,0,sizeof(ql));
    memset(qr,0,sizeof(qr));
    cnt1=cnt2=0;
    for(int i=l;i>0;i-=lowbit(i))
        ql[1][++cnt1]=root[i];
    for(int i=r;i>0;i-=lowbit(i))
        qr[1][++cnt2]=root[i];
    return Query(1,pos,1,total,1);
}

int main()
{
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);
        b[i]=a[i];
    }

    int cnt=n;
    for(int i=1;i<=q;++i)
    {
        int op;
        scanf("%d",&op);
        if(op==1)
        {
            opt[i].tag=1;
            scanf("%d%d",&opt[i].l,&opt[i].r);
            b[++cnt]=opt[i].r;
        }
        else
        {
            opt[i].tag=2;
            scanf("%d%d",&opt[i].l,&opt[i].r);
        }
    }

    sort(b+1,b+1+cnt);
    total=unique(b+1,b+1+cnt)-b-1;
    for(int i=1;i<=n;++i)
        add(i,a[i]);

    for(int i=1;i<=q;++i)
    {
        if(opt[i].tag==1)
        {
            int x=opt[i].l,y=opt[i].r;
            add(x,-a[x]);
            a[x]=y;
            add(x,a[x]);
        }
        else
        {
            ll x=0,y=0;
            while(1)
            {
                y=x+1;
                int pos=upper_bound(b+1,b+1+total,y)-b-1;
                x=PreQuery(opt[i].l-1,opt[i].r,pos);
                if(x<y)
                    break;
            }
            printf("%lld\n",x+1);
        }
    }
    return 0;
}

非离散化

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn=2e5+10;

int n,q,total=2e5;
int a[maxn],b[maxn*2];
ll ST[maxn*150];
int ls[maxn*150],rs[maxn*150],root[maxn],no;
int cnt1,cnt2,ql[20][20],qr[20][20];

inline int lowbit(int x)
{
    return x&(-x);
}

void Update(int &rt,int pos,int L,int R,int val)
{
    if(!rt)
        rt=++no;
    ST[rt]+=val;
    if(L==R)
    	return;
    int mid=(L+R)>>1;
    if(pos<=mid)
        Update(ls[rt],pos,L,mid,val);
    if(pos>mid)
        Update(rs[rt],pos,mid+1,R,val);
}

void add(int x,int pos,int val)
{
    for(int i=x;i<=n;i+=lowbit(i))
        Update(root[i],pos,1,total,val);
}

ll Query(int l,int r,int L,int R,int d)
{
    if(l<=L&&R<=r)
    {
        ll ans=0;
        for(int i=1;i<=cnt1;++i)
            ans-=ST[ql[d][i]];
        for(int i=1;i<=cnt2;++i)
            ans+=ST[qr[d][i]];
        return ans;
    }

    int mid=(L+R)>>1;
    ll ans=0;
    if(l<=mid)
    {
        for(int i=1;i<=cnt1;++i)
            ql[d+1][i]=ls[ql[d][i]];
        for(int i=1;i<=cnt2;++i)
            qr[d+1][i]=ls[qr[d][i]];
        ans+=Query(l,r,L,mid,d+1);
    }
    if(r>mid)
    {
        for(int i=1;i<=cnt1;++i)
            ql[d+1][i]=rs[ql[d][i]];
        for(int i=1;i<=cnt2;++i)
            qr[d+1][i]=rs[qr[d][i]];
        ans+=Query(l,r,mid+1,R,d+1);
    }
    return ans;
}

ll PreQuery(int l,int r,int pos)
{
    memset(ql,0,sizeof(ql));
    memset(qr,0,sizeof(qr));
    cnt1=cnt2=0;
    for(int i=l;i>0;i-=lowbit(i))
        ql[1][++cnt1]=root[i];
    for(int i=r;i>0;i-=lowbit(i))
        qr[1][++cnt2]=root[i];
    return Query(1,pos,1,total,1);	
}

int main()
{
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;++i)
    {
        scanf("%d",&a[i]);
        add(i,a[i],a[i]);
    }

	while(q--)
	{
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op==1)
		{
			add(l,a[l],-a[l]);
			a[l]=r;
			add(l,a[l],a[l]);
		}
		else
		{
			ll x=0,y=0;
			while(1)
			{
				y=x+1;
				x=PreQuery(l-1,r,min(1ll*total,y));
				if(x<y)
					break;
			}
			printf("%lld\n",x+1);
		}
	}
    return 0;
}
Cheng Yu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
动态主席树 单点更新 动态区间第k小
唐大帅
04-19 223
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，然后...
主席树动态
TRDD的博客
10-15 185
以ZOJ2114为模板题。 附上此题链接 主席树的动态单点改值主要是主席树加树状数组，具体暂未理解，待熟练仔细揣摩。 代码如下 #include&amp;lt;cstdio&amp;gt; #include&amp;lt;cstdlib&amp;gt; #include&amp;lt;cstring&amp;gt; #include&amp;lt;cmath&amp;gt; #include&amp;lt;algorithm&a
ZOJ 2112 Dynamic Rankings （动态主席树）
满月照亮的路
02-16 196
题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2112 题目大意： 比静态查询区间第k小多加了一个修改操作。 题目分析：  对于所有的数（原序列的数和要修改的数）都离散化处理， 动态修改的核心是对于树状数组中出现的点开线段树维护， 因为之前修改一个数对于后续区间有影响，我们令开一个根节点数组S 来维...
主席树 —— ③动态区间第K小（树套树，带修改主席树）
Plus Ultra！
07-29 1122
动态区间第K小 动态区间第K小，又称带修改主席树（动态主席树），对于初学真的不太友好。因为这个和静态区间第K小（静态主席树）数据结构都完全不同了。 和求静态第K小一样，我们要得到[L, R]状态的线段树，才能进行二分得到第K小。 静态主席树 是一个 可持久化线段树，每次利用 前缀和来计算[L, R]状态，但是前缀和就不便于进行修改操作了，那么对于可修改的区间求和，我们就要用到 树状数组/线段树。 ...
主席树动态第k小模板
天道酬勤
07-27 248
#include<cstdio> #include<cstring> #include<cstdlib> #include<algorithm> using namespace std; const int maxn = 1e5 + 10; struct node { int l, r, sum; }; struct op { ...
学习笔记--函数式线段树(主席树)(动态维护第K极值(树状数组套主席树))
weixin_30640769的博客
02-05 150
函数式线段树..资瓷 区间第K极值查询 似乎不过似乎划分树的效率更优于它,但是如果主席树套树状数组后,可以处理动态的第K极值.即资瓷插入删除,划分树则不同… 那么原理也比较易懂: 建造一棵线段树(权值线段树),维护的信息是序列中每个数的出现次数,静态查询第K极值,只需要从根做二分,然后向下转左右子树,找到叶子节点即可…(由于线段树的性质,这个查找的复杂度是log级..)...
[BZOJ1901]Dynamic Rankings（动态主席树）
薇小薇
12-15 278
放假前一下午------放假------开学一上午
【bzoj1901】【Dynamic Rankings】【动态主席树】
sunshinezff的专栏
04-01 635
Description 给定一个含有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【树状数组+主席树】
Gene_I must wait for the sunrise
11-18 339
题意： 给定一个区间，求这个区间第k小的数，支持单点修改。 思路： 动态主席树裸题。 我们先来回顾一下静态主席树的做法，对于数组中每一个位置都维护一棵权值线段树，该权值线段树保存的是区间 [1,x] 的信息。因此我想要求区间 [l,r] 之间第k大的时候，只需要将root[r]-root[l-1]就是维护区间 [l,r] 信息的权值线段树，因此就可...
动态主席树（主席树套树状数组）zoj 2112 Dynamic Rankings 详解
菜鸡的博客
10-10 180
既然看到这个题了，相信静态主席树求区间第k大应该不成问题了， 此题在原有基础上，不过添加了单点修改的要求。 那么来说一下大体思路： 首先，用题目给的n个原始数据像之前一样建立主席树。对于修改，我们不是要真的去修改我们已经建立好的主席树，而是用另一个数组来维护修改所造成的变化，例如：要求 i 位置到 j 位置的第k大，之前的策略是找到第 i-1 和 第 j 棵树，两个权值线段树根据左右子节点的权值下...
动态主席树（亲妈级注释）
weixin_45563175的博客
08-08 261
动态主席树 本文介绍动态主席树，学习之前，你必须需要先了解静态主席树，本文只介绍相对于静态主席树多出来的部分。 动态主席树已经算是另一种数据结构了。这里以ZOJ2112为例。 首先我们需要知道主席树是一种离线数据结构，意思是我们不能一边询问一边修改或输出。所以我们把询问存储起来，这里主要是因为我们要储存改变的值，不然无法离散化，所以就离线了。这里要改变一个值，例如把2变成6，那么2的数量就要少一个，6的数量就要多一个，可我们又不能再开一个线段树，所以我们考虑将每一个节点都变成一棵树，每对他进行操作时就是对这
主席树
Virgil's Blog
08-03 513
主席树主席树可以解决不适用结合律的区间问题（如区间第 KK 大，区间种类数），这些问题原本是需要繁琐的树套树，而有了主席树就简单很多了。主席树的中心思想是保留历史版本，最暴力的做法是没插入一个节点就新建一棵线段树，但这样会各种爆，其实我们可以只新建有更改的节点，然后直接连边到原来的节点即可。类比普通的线段树，主席树的插入顺序相当于普通线段树的位置，而主席树中的位置是维护的权值。例题[POJ2104]
主席树 （动态）图文讲解让你一次就懂 zoj2112为例
WilliamSun0122的博客
09-07 7979
主席树（动态）学动态主席树之前一定要先会静态主席树。 静态主席树：http://blog.csdn.net/williamsun0122/article/details/77871278参考博客：http://www.cnblogs.com/Empress/p/4659824.html 这个博客讲的是对的，不过它的图和代码好像是错的，虽然能过，但应该是数据不够强，具体怎么错的它的博客下面评论有。
Dynamic Rankings (动态主席树 / 整体二分)
Fau的博客
06-08 496
题目链接: Dynamic Rankings 2021.6.8 更新了区间线段树套权值线段树的解题方式, 并翻新了博客 大致题意 带修改的第k小数模板题. 解题思路 动态主席树 和 整体二分 的模板题! 思路一: 树状数组 + 主席树 考虑到通常的静态第k小数, 我们可以用主席树在O(mlogn)的优秀时间复杂度内求出结果. 其主体思路是在权值线段树上进行树上二分. 现在考虑到有了单点修改操作, 我们如果直接在常规的主席树上进行修改, 当你修改pos位置时, 我们需要把[pos, n]区间的所有版本主席树
mcu8660点名观看主席怎么设置
最新发布
07-17
3. 设置主席权限：在会议配置中，选择“主席模式”或者类似选项，赋予某用户“主席”权限。主席有更多操作权限，包括点名发言权。 4. 点名设置：在点名设置中，可以设定如何触发点名，比如手动点击或者通过语音命令...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值