重拾主席树

最新推荐文章于 2018-12-10 17:27:00 发布

置顶 stevensonson

最新推荐文章于 2018-12-10 17:27:00 发布

阅读量181

点赞数

分类专栏： BZOJ

本文链接：https://blog.csdn.net/stevensonson/article/details/83592206

版权

BZOJ 专栏收录该内容

94 篇文章 1 订阅

订阅专栏

文章目录

主席树是一种可持久化的值域线段树。这个我在之前的博客提到过。
由于空间的原因，主席树是要动态开点的。因此主席树更恰当的定义是可持久化动态开点值域线段树。
因此在重拾主席树之前，我们先看看动态开点线段树。会的可以直接跳到下面的部分。

动态开点线段树

BZOJ4627

题目描述：

酷爱日料的小Z经常光顾学校东门外的回转寿司店。在这里，一盘盘寿司通过传送带依次呈现在小Z眼前。不同的寿
司带给小Z的味觉感受是不一样的，我们定义小Z对每盘寿司都有一个满意度，例如小Z酷爱三文鱼，他对一盘三文
鱼寿司的满意度为10；小Z觉得金枪鱼没有什么味道，他对一盘金枪鱼寿司的满意度只有5；小Z最近看了电影“美
人鱼”，被里面的八爪鱼恶心到了，所以他对一盘八爪鱼刺身的满意度是-100。特别地，小Z是个著名的吃货，他
吃回转寿司有一个习惯，我们称之为“狂吃不止”。具体地讲，当他吃掉传送带上的一盘寿司后，他会毫不犹豫地
吃掉它后面的寿司，直到他不想再吃寿司了为止。今天，小Z再次来到了这家回转寿司店，N盘寿司将依次经过他的
面前，其中，小Z对第i盘寿司的满意度为Ai。小Z可以选择从哪盘寿司开始吃，也可以选择吃到哪盘寿司为止，他
想知道共有多少种不同的选择，使得他的满意度之和不低于L，且不高于R。注意，虽然这是回转寿司，但是我们不
认为这是一个环上的问题，而是一条线上的问题。即，小Z能吃到的是输入序列的一个连续子序列；最后一盘转走
之后，第一盘并不会再出现一次。
Input

第一行包含三个整数N，L和R，分别表示寿司盘数，满意度的下限和上限。
第二行包含N个整数Ai，表示小Z对寿司的满意度。
N≤100000，|Ai|≤100000，0≤L, R≤10^9
Output

仅一行，包含一个整数，表示共有多少种选择可以使得小Z的满意度之和
不低于L且不高于R。
Sample Input

5 5 9

1 2 3 4 5
Sample Output

题解：

显然可以处理前缀和，设 $s u m [i]$ 为到 $i$ 的前缀和，那么只要 $s u m [j]$ 满足 $sum[i]-r\leq sum[j]\leq sum[i]-l$ 即可。因此我们可以开一个值域线段树，然后每次进行区间查询，查询区间 $[s u m [i] - r, s u m [i] - l]$ 即可。

但是这题的值域有 $10^{10}$ 之多，直接开线段树内存直接起飞。然而总数只有 $10^5$ 个。因此我们可以动态开点，这样就可以在不爆内存的情况下完成线段树的操作。

这道题值得注意的就是要先建一个为0的点，表示从最左边到当前点的区间。

代码：

#include<bits/stdc++.h>
#define ll long long
#define MAXN 100005
using namespace std;
const ll inf=1e10;
ll read(){
    char c;ll x=0,y=1;while(c=getchar(),(c<'0'||c>'9')&&c!='-');
    if(c=='-') y=-1;else x=c-'0';while(c=getchar(),c>='0'&&c<='9')
    x=x*10+c-'0';return x*y;
}
ll n,l,r,cnt=1,root=1,ans,sum[10000002],son[10000002][2],pre[MAXN];
void build(ll &node,ll l,ll r,ll p){
    if(!node){
        ++cnt;node=cnt;
        son[node][0]=son[node][1]=sum[node]=0;
    }
    sum[node]++;
    if(l==r) return;
    ll mid=(l+r)>>1;
    if(p<=mid) build(son[node][0],l,mid,p);
    else build(son[node][1],mid+1,r,p);
}
ll query(ll node,ll l,ll r,ll L,ll R){
    if(L<=l&&r<=R) return sum[node];
    ll mid=(l+r)>>1,ans=0;
    if(L<=mid&&son[node][0]) ans+=query(son[node][0],l,mid,L,R);
    if(R>mid&&son[node][1]) ans+=query(son[node][1],mid+1,r,L,R);
    return ans;
}
int main()
{
    n=read();l=read();r=read();
    for(ll i=1;i<=n;i++){
        ll x=read();
        pre[i]=pre[i-1]+x;
    }
    build(root,-inf,inf,0);
    for(ll i=1;i<=n;i++){
        ans+=query(root,-inf,inf,pre[i]-r,pre[i]-l);
        build(root,-inf,inf,pre[i]);
    }
    printf("%lld",ans);
    return 0;
}

主席树

主席树的定义和性质在主席树——可持久化值域线段树这篇博客里提到过。大致来说，就是对于区间 $[1, n]$ 每一个前缀区间 $[1, l]$ 建一个线段树。那么对于 $[1, l]$ 和 $[1, l + 1]$ 的线段树，它们只有一个点不同，因此新建时只要新建 $l o g n$ 个点即可。所以主席树的空间复杂度为 $n l o g n$ 。

求静态区间第 $k$ 大可以用主席树维护（~~当然也可以用平衡树~~），这个例题在上面链接的博客里。

下面的这道例题讲讲主席树怎么可持久化

可持久化书橱 CF/707/D

在这里插入图片描述

题解：

总共有n*m个格子。这里我们以每次操作为不同线段树维护的线，也就是对于每个操作新建一个新的线段树。由于每次新建都只会改一个节点，所以可以用主席树维护。

前两个操作就是最基本的更新操作，新建一个节点，复制其原来的状态，并修改其值。例如原来点x有书。现在对x进行操作2，那么也就是新建一个点，复制原来x的装台，然后将其状态变为没有书。

第三个操作也一样，我们只要打一个标记，每次异或，必要时下推即可。

操作4要求可持久化，其实这是最简单的操作，因为我们每一棵线段树记录的都是每一个操作之后区间 $[1, n * m]$ 的状态，所以要回到做操x时的状态时，只要root[i]=root[x]将其根赋值为操作x的根即可。这样就简单地实现了可持久化。

代码：

#include<bits/stdc++.h>
#define MAXN 300005
#define N 30000005
using namespace std;
int read(){
	char c;int x;while(c=getchar(),c<'0'||c>'9');x=c-'0';
	while(c=getchar(),c>='0'&&c<='9') x=x*10+c-'0';return x;
}
int n,m,op,cpt,root[MAXN],son[N][2],add[MAXN*40],sum[N];
int pl(int x,int y){
	return (x-1)*m+y;
}
void newnode(int &x){
	++cpt;
	sum[cpt]=sum[x];add[cpt]=add[x];
	son[cpt][0]=son[x][0];son[cpt][1]=son[x][1];
	x=cpt;
}
void up(int x){
	sum[x]=sum[son[x][0]]+sum[son[x][1]];
}
void down(int x,int L,int R){
	if(add[x]){
		newnode(son[x][0]);newnode(son[x][1]);
		add[son[x][0]]^=1;add[son[x][1]]^=1;
		sum[son[x][0]]=L-sum[son[x][0]];
		sum[son[x][1]]=R-sum[son[x][1]];
		add[x]=0;
	}
}
void update(int &x,int l,int r,int p,int ad){
	newnode(x);
	if(l==r){
		sum[x]=ad;return;
	}
	int mid=(l+r)>>1;down(x,mid-l+1,r-mid);
	if(p<=mid) update(son[x][0],l,mid,p,ad);
	else update(son[x][1],mid+1,r,p,ad);
	up(x);
}
void reverse(int &x,int l,int r,int L,int R){
	newnode(x);
	if(L<=l&&r<=R){
		add[x]^=1;sum[x]=(r-l+1)-sum[x];
		return;
	}
	int mid=(l+r)>>1;down(x,mid-l+1,r-mid);
	if(L<=mid) reverse(son[x][0],l,mid,L,R);
	if(R>mid) reverse(son[x][1],mid+1,r,L,R);
	up(x);
}
int main()
{
	n=read();m=read();op=read();
	for(int i=1;i<=op;i++){
		root[i]=root[i-1];int type=read();
		if(type==1){
			int x=read(),y=read();
			update(root[i],1,n*m,pl(x,y),1);
		}
		else if(type==2){
			int x=read(),y=read();
			update(root[i],1,n*m,pl(x,y),0);
		}
		else if(type==3){
			int x=read();
			reverse(root[i],1,n*m,pl(x,1),pl(x,m));
		}
		else if(type==4){
			int x=read();
			root[i]=root[x];
		}
		printf("%d\n",sum[root[i]]);
	}
	return 0;
}

BZOJ3932

Description

最近实验室正在为其管理的超级计算机编制一套任务管理系统，而你被安排完成其中的查询部分。超级计算机中的
任务用三元组(Si,Ei,Pi)描述，(Si,Ei,Pi)表示任务从第Si秒开始，在第Ei秒后结束（第Si秒和Ei秒任务也在运行
），其优先级为Pi。同一时间可能有多个任务同时执行，它们的优先级可能相同，也可能不同。调度系统会经常向
查询系统询问，第Xi秒正在运行的任务中，优先级最小的Ki个任务（即将任务按照优先级从小到大排序后取前Ki个
）的优先级之和是多少。特别的，如果Ki大于第Xi秒正在运行的任务总数，则直接回答第Xi秒正在运行的任务优先
级之和。上述所有参数均为整数，时间的范围在1到n之间（包含1和n）。
Input

输入文件第一行包含两个空格分开的正整数m和n，分别表示任务总数和时间范围。接下来m行，每行包含三个空格
分开的正整数Si、Ei和Pi(Si≤Ei)，描述一个任务。接下来n行，每行包含四个空格分开的整数Xi、Ai、Bi和Ci，
描述一次查询。查询的参数Ki需要由公式 Ki=1+(Ai*Pre+Bi) mod Ci计算得到。其中Pre表示上一次查询的结果，
对于第一次查询，Pre=1。
Output

输出共n行，每行一个整数，表示查询结果。
Sample Input

4 3

1 2 6

2 3 3

1 3 2

3 3 4

3 1 3 2

1 1 3 4

2 2 4 3
Sample Output

11
HINT

样例解释

K1 = (1*1+3)%2+1 = 1

K2 = (1*2+3)%4+1 = 2

K3 = (2*8+4)%3+1 = 3

对于100%的数据，1≤m,n,Si,Ei,Ci≤100000，0≤Ai,Bi≤100000，1≤Pi≤10000000，Xi为1到n的一个排列

题解：

这道题算是简单的主席树综合题吧。
首先给出的是时间段 $[l, r]$ ，于是我们可以进行差分，在时间 $l$ 打一个 $+ 1$ 的标记，时间 $r + 1$ 打一个 $- 1$ 的标记。这样我们就把区间信息转变为每个点的信息。然后我们按照时间点顺序建立主席树，每次建立时，就修改在当时刻打上标记的点即可。

这就是大致思路，具体操作可以看代码，思路还是十分清晰易懂的。

代码：

#include<bits/stdc++.h>
#define MAXN 100005
#define ll long long
using namespace std;
ll read(){
    char c;ll x;while(c=getchar(),c<'0'||c>'9');x=c-'0';
    while(c=getchar(),c>='0'&&c<='9') x=x*10+c-'0';return x;
}
ll n,m,k,Max,tot,cnt,lst,b[MAXN],son[MAXN*40][2],siz[MAXN*40],sum[MAXN*40],root[MAXN];
struct node{ll val,type;};
vector<node> task[MAXN];
map<ll,ll> mp;
void newnode(ll &x){
    ++cnt;
    son[cnt][0]=son[x][0];son[cnt][1]=son[x][1];
    sum[cnt]=sum[x];siz[cnt]=siz[x];
    x=cnt;
}
void build(ll &x,ll l,ll r){
    ll mid=(l+r)>>1;x=++cnt;
    if(l==r) return;
    build(son[x][0],l,mid);
    build(son[x][1],mid+1,r);
}
void up(ll x){
    sum[x]=sum[son[x][0]]+sum[son[x][1]];
    siz[x]=siz[son[x][0]]+siz[son[x][1]];
}
void modify(ll &x,ll l,ll r,ll val,ll p,ll t){
    newnode(x);
    if(l==r){
        sum[x]+=val;siz[x]+=t;
        return;
    }
    ll mid=(l+r)>>1;
    if(p<=mid) modify(son[x][0],l,mid,val,p,t);
    else modify(son[x][1],mid+1,r,val,p,t);
    up(x);
}
ll query(ll x,ll l,ll r,ll k){
    if(k>=siz[x]) return sum[x];
    if(l==r) return sum[x]/siz[x]*k;
    ll mid=(l+r)>>1;
    if(siz[son[x][0]]>=k) return query(son[x][0],l,mid,k);
    else if(siz[son[x][0]]<k) return sum[son[x][0]]+query(son[x][1],mid+1,r,k-siz[son[x][0]]); 
}
int main()
{
    n=read();m=read();lst=1;
    for(ll i=1;i<=n;i++){
        ll l=read(),r=read(),e=read();Max=max(Max,r);b[i]=e;
        task[l].push_back((node){e,1});     //差分
        task[r+1].push_back((node){-e,-1});
    }
    sort(b+1,b+1+n);     //离散
    for(ll i=1;i<=n;i++)if(!mp[b[i]])mp[b[i]]=++tot;
    build(root[0],1,tot);
    for(ll i=1;i<=Max;i++){
        root[i]=root[i-1];
        for(ll j=0;j<task[i].size();j++){
            int v=task[i][j].val,p=task[i][j].type;
            modify(root[i],1,tot,task[i][j].val,mp[labs(task[i][j].val)],task[i][j].type);    //更新
        }
    }
    for(ll i=1;i<=m;i++){
        ll x=read(),A=read(),B=read(),C=read();
        k=1+(A*lst+B)%C;
        printf("%lld\n",lst=query(root[x],1,tot,k));    //统计
    }
    return 0;
}

stevensonson

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
重拾主席树

文章目录动态开点线段树BZOJ4627题解：代码：主席树可持久化书橱题解：代码：BZOJ3932题解：代码：主席树是一种可持久化的值域线段树。这个我在之前的博客提到过。由于空间的原因，主席树是要动态开点的。因此主席树更恰当的定义是可持久化动态开点值域线段树。因此在重拾主席树之前，我们先看看动态开点线段树。会的可以直接跳到下面的部分。动态开点线段树BZOJ4627题目描述：酷爱日料的...
复制链接

扫一扫