主席树（知识学习+板子总结）

概念

主席树

以前i个值建第i棵线段树，

新来的值只会新开一条链，

对于第一棵树而言，即普通的权值线段树，或者理解成一条链也无妨

结构体的权值线段树写法

利用前缀和的方法 统计[l,r]内各个数出现的数量

 

前提保证a1-an均在1-n之间

如果不在1-n之间就离散化一下搞成rank就到1-n之间了

十一的时候学过这个东西 

但是当时只是看懂

没有及时跟上例题和总结 然后就忘了QAQ

这说明总结和例题多么重要

知识还是一个沉积的过程啊

现在再看这个真的是清清楚楚明明白白

思路来源

https://www.bilibili.com/video/av16552942?from=search&seid=1412104890759122013

【算法讲堂】【电子科技大学】【ACM】权值线段树与主席树

http://hzwer.com/2709.html 

心得

及时掌握板子 学会灵活应用板子

知识点总结的板子以后就不要手敲啦

但要保证绝对的理解和应用灵活

多做题才是王道.jpg

 

顺便插入、查询这种和普通权值线段树有什么不同呢

就是放两棵树同一位置的节点进去

查询排名的话维护它们的差 否则也要同步按区间走

诶 其实就是之前传参的时候传一个p参数作区间的标号

现在传两个参，树A的这个节点node的标号，和树B的这个节点node的标号

其他部分，在我看来，没啥差别

例题

BZOJ3524 Couriers-主席树

顺便挂一个这题的题解代码http://hzwer.com/2709.html 

题主用非结构体的也把主席树搞出来了

这启发我们 并不是一定要结构体

要学会各种各样的线段树写法

50多行的精简代码看得真是敬慕&&羡慕之情油然而生

代码1

#include
#include
#include
#include
#include
using namespace std;
const int maxn=1e5+10;
//主席树 与上一棵树共用没有新开的那些节点 
//root数组代表第i颗树的根 
//插入和查询都是 两棵树同步走相对应的节点 
int cnt,root[maxn],n,m,goal;
struct node
{
	int lson,rson,num;
	//分别是左子下标 右子下标 这段值域出现的个数 
}tree[maxn*20];//每个点开logn个节点 20倍maxn差不多了
//pre代表上一颗子树的根 cur代表当前子树的根 v代表要插的值 
void pushup(int pos)
{
	tree[pos].num=tree[tree[pos].lson].num+tree[tree[pos].rson].num;
}
void update(int pre,int cur,int l,int r,int v) 
{
	if(l==r)//前缀和思想，第i颗树包含了前i个元素，值即权值线段树的操作 
	{
		tree[cur].num=tree[pre].num+1;
		return; 
	}
	int mid=(l+r)>>1;
	if(v<=mid)//新值在左子树里 新开一个左子节点
	{
		tree[cur].lson=++cnt;
		tree[cur].rson=tree[pre].rson;//共用右子
		update(tree[pre].lson,tree[cur].lson,l,mid,v);//递归左子区间 
	} 
	else//新值在右子树里 新开一个右子节点 
	{
		tree[cur].rson=++cnt;
		tree[cur].lson=tree[pre].lson;
		update(tree[pre].rson,tree[cur].rson,mid+1,r,v);
	}
	pushup(cur); 
}
int query(int L,int R,int l,int r)
{
	if(l==r)return l;//二分区间直至单点满足 不满足返回0 
	int mid=(l+r)>>1; 
	if(tree[tree[R].lson].num-tree[tree[L].lson].num>goal)return query(tree[L].lson,tree[R].lson,l,mid);
	else if(tree[tree[R].rson].num-tree[tree[L].rson].num>goal)return query(tree[L].rson,tree[R].rson,mid+1,r);
	return 0;
}
int main()
{
	//确保所有值都在1到n之间 如果不在的话 离散化一下就搞成1到n之间了
	//插第一条链的时候 不用管pre节点里值是什么 认为全都是0也无妨 
	//也可以先build一棵普通权值线段树 然后再add节点 
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;++i)
	{
		int v;
		scanf("%d",&v);
		root[i]=++cnt;
		update(root[i-1],root[i],1,n,v);
	}
	//前缀和思想 [l,r]信息只需将第root[r]棵树与第root[l-1]棵树作差 
	//以下为bzoj3524 问[l,r]内出现次数超过一半的数是否存在 
	while(m--)
	{
		int l,r;
		scanf("%d%d",&l,&r);
		goal=(r-l+1)>>1; 
		printf("%d\n",query(root[l-1],root[r],1,n));
	} 
	return 0;
}

代码2

好叭是直接http://hzwer.com/2709.html人家的非结构体的代码

当板子存着，不建空数的话，nlogn的空间差不多是够的，而且代码精简好评

①update的&y用的真的是出神入化

就是先赋成一样的左子和右子，如果是改的这棵树导致不一样的话再递归进去改，回调的时候由于引用也对应了修改

不用讨论那么多情况

②query的循环也是好评啊，二分的写法，把递归搞成了非递归

#include
#include
using namespace std;
const int N=1e5+10;
int root[N],ls[40*N],rs[40*N],sum[40*N];
int n,m,sz;
inline int read()
{
    char ch=getchar();
    while(!(ch>='0'&&ch<='9'))ch=getchar();
    int x=0;
    while(ch>='0'&&ch<='9'){x=x*10+(ch-'0');ch=getchar();}
    return x;
}
void update(int l,int r,int x,int &y,int v)
{
    y=++sz;
    sum[y]=sum[x]+1;//递归过程就对应着改
    if(l==r)return;
    ls[y]=ls[x];rs[y]=rs[x];//先赋成一样的
    int mid=(l+r)>>1;
    if(v<=mid)update(l,mid,ls[x],ls[y],v);//递归进去改ls[y]，引用之后ls[y]也对应了改变
    else update(mid+1,r,rs[x],rs[y],v);
}
int que(int L,int R)//L R传进来两棵树
{
    int l=1,r=n,mid,x,y,tmp=(R-L+1)>>1;
    x=root[L-1];y=root[R];
    while(l!=r)
    {
        if(sum[y]-sum[x]<=tmp)return 0;
        mid=(l+r)>>1;
        if(sum[ls[y]]-sum[ls[x]]>tmp)//左子树
        {r=mid;x=ls[x];y=ls[y];}
        else if(sum[rs[y]]-sum[rs[x]]>tmp)//右子树
        {l=mid+1;x=rs[x];y=rs[y];}
        else return 0;
    }
    return l;
}
int main()
{
    n=read();m=read();
    for(int i=1;i<=n;i++)
    {
        int x;x=read();
        update(1,n,root[i-1],root[i],x);
    }
    for(int i=1;i<=m;i++)
    {
        int l,r;l=read();r=read();
        printf("%d\n",que(l,r));
    }
    return 0;
}

代码3（以hdu6278主席树+二分为例）

现在喜欢写这种的，

有着第一种的结构体写法，

和第二种的简洁的写法

还算是具有一定的可读性吧

#include
#include
#include
#include
using namespace std;
const int maxn=1e5+10;
struct node
{
	int l,r,num;
	node(){l=r=num=0;} 
}e[maxn*40];
//1e5开*40,1e6开*45
//其实开(log(maxn)*(n+m)*maxn)就好
int n,q;
int a[maxn];
int root[maxn],cnt;//开m+1的规模 
int L,R,l,r;
void update(int l,int r,int &cur,int las,int pos)
{
	cur=++cnt;
    //直接一路搜到底更新 不利用回溯pushup 单路单点修改
	e[cur]=e[las];
	e[cur].num++;
	if(l==r)return;
	int mid=(l+r)/2;
	if(pos<=mid)update(l,mid,e[cur].l,e[las].l,pos);
	else update(mid+1,r,e[cur].r,e[las].r,pos); 
}
int query(int l,int r,int cur,int las,int ql,int qr)
{
    //除了两棵树作差以外 就是裸的线段树区间求和
	if(ql<=l&&r<=qr)return e[cur].num-e[las].num;
	int ans=0;
	int mid=(l+r)/2;
	if(ql<=mid)ans+=query(l,mid,e[cur].l,e[las].l,ql,qr);
	if(qr>mid)ans+=query(mid+1,r,e[cur].r,e[las].r,ql,qr);
	return ans;
}
int erfen(int L,int R,int l,int r)
{
	while(l<=r)
	{
		int mid=(l+r)/2;
        //二分出最大的r r的都不满足要求 所以答案就是r
		if(query(1,n,root[R],root[L-1],mid,n)>=mid)l=mid+1;
		else r=mid-1;
	}
	return r;
}
int main()
{
	while(~scanf("%d%d",&n,&q))
	{
	 cnt=0;
	 memset(e,0,sizeof e);
	 for(int i=1;i<=n;++i)
	 {
	  scanf("%d",&a[i]);
	  update(1,n,root[i],root[i-1],a[i]);
     }
     for(int i=1;i<=q;++i)
     {
     	scanf("%d%d",&L,&R);
     	printf("%d\n",erfen(L,R,1,n));
     }
	} 
	return 0;
}