[学习笔记]主席树经典例题

最新推荐文章于 2021-04-07 09:10:29 发布
最新推荐文章于 2021-04-07 09:10:29 发布
阅读量216 收藏 1
点赞数
原文链接：http://www.cnblogs.com/Panda-hu/p/11145743.html
版权

level 1

level 1-1 模板-查询k小值

模板，不再赘述。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
#define MAXN 200000
int n,Q;
int a[MAXN+5],b[MAXN+5];
int root[MAXN+5];
int rnum;
struct node
{
    int lc,rc;
    int sum;
}tree[MAXN*20+5];
void Build(int &x,int l,int r)
{
    x=++rnum;
    if(l==r)return ;
    int mid=(l+r)>>1;
    Build(tree[x].lc,l,mid);
    Build(tree[x].rc,mid+1,r);
}
int Insert(int x,int l,int r,int pos)
{
    int Nr=++rnum;
    tree[Nr]=tree[x];
    tree[Nr].sum=tree[x].sum+1;
    if(l==r)return Nr;
    int mid=(l+r)>>1;
    if(pos<=mid)tree[Nr].lc=Insert(tree[Nr].lc,l,mid,pos);
    else tree[Nr].rc=Insert(tree[Nr].rc,mid+1,r,pos);
    return Nr;
}
int Query(int Lr,int Rr,int l,int r,int val)
{
    int Pv=tree[tree[Rr].lc].sum-tree[tree[Lr].lc].sum;
    if(l==r)return l;
    int mid=(l+r)>>1;
    if(val<=Pv)return Query(tree[Lr].lc,tree[Rr].lc,l,mid,val);
    else return Query(tree[Lr].rc,tree[Rr].rc,mid+1,r,val-Pv);
}
int main()
{
    scanf("%d%d",&n,&Q);
    for(int i=1;i<=n;i++)
    {scanf("%d",&a[i]);b[i]=a[i];}
    sort(b+1,b+n+1);
    int p=unique(b+1,b+n+1)-b-1;
    Build(root[0],1,p);
    for(int i=1;i<=n;i++)
    {
        int P=lower_bound(b+1,b+p+1,a[i])-b;
        root[i]=Insert(root[i-1],1,p,P);
    }
    while(Q--)
    {
        int l,r,k;
        scanf("%d%d%d",&l,&r,&k);
        printf("%d\n",b[Query(root[l-1],root[r],1,p,k)]);
    }
}

level 1-2 [POI2014]couriers

给一个数列，每次询问一个区间内有没有一个数出现次数超过一半
n≤500000n≤500000n≤500000

建nnn个版本的权值线段树，每个点统计数值iii的出现次数。
询问的时候用rrr版本减去l−1l-1l−1版本，维护sum递归查找一下即可。
[代码算了…]

level 2

level 2-1 [CQOI2015]任务查询系统

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

其实这道题本身是不用主席树的。
关键是它要强制在线…
一个十分显然的套路:
运用差分思想，将操作拆成两个部分：在Si位置插入线段树，在Ei+1位置从线段树中删除。
线段树的每个位置代表优先值为iii的计算机。在线段树上维护优先值之和。
通过主席树保存每个时间的线段树即可。
由于有优先值很大，因此要离散化。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
using namespace std;
#define MAXN 300000
int n,Q;
int root[MAXN*20+5];
int rnum;
struct As
{
    int l,r,val;
}a[MAXN+5];
struct Qry
{
    int pos,val,st,Tp;
}qry[MAXN+5];
struct node
{
    int lc,rc;
    long long cnt,sum;
}tree[MAXN*20+5];
int Hs[MAXN+5];
bool cmp(Qry s1,Qry s2){return s1.Tp<s2.Tp;}
int read()
{
    int x=0,f=1;char s=getchar();
    while(s<'0'||s>'9'){if(s=='-')f=-1;s=getchar();}
    while(s>='0'&&s<='9'){x=x*10+s-'0';s=getchar();}
    return x*f;
}
int Insert(int x,int l,int r,int pos,int val,int F)
{
    int Nr=++rnum;
    tree[Nr]=tree[x];
    tree[Nr].cnt+=F;
    tree[Nr].sum+=F*val;
    if(l==r)return Nr;
    int mid=(l+r)>>1;
    if(pos<=mid)tree[Nr].lc=Insert(tree[Nr].lc,l,mid,pos,val,F);
    else tree[Nr].rc=Insert(tree[Nr].rc,mid+1,r,pos,val,F);
    return Nr;
}
long long Query(int x,int l,int r,int val)
{
    if(l==r)return val*tree[x].sum/tree[x].cnt;
    int mid=(l+r)>>1;
    int Pv=tree[tree[x].lc].cnt;
    if(tree[x].cnt<=val)return tree[x].sum;
    if(Pv>=val)return Query(tree[x].lc,l,mid,val);
    return Query(tree[x].rc,mid+1,r,val-Pv)+tree[tree[x].lc].sum;
}
int main()
{
    n=read(),Q=read();
    for(int i=1;i<=n;i++)
    {
        a[i].l=read(),a[i].r=read(),a[i].val=read();
        Hs[i]=a[i].val;
    }
    sort(Hs+1,Hs+n+1);
    int p=unique(Hs+1,Hs+n+1)-Hs-1;
    for(int i=1;i<=n;i++)
    {
        int P=lower_bound(Hs+1,Hs+p+1,a[i].val)-Hs;
        qry[i*2-1]=(Qry){P,a[i].val,1,a[i].l};
        qry[i*2]=(Qry){P,a[i].val,-1,a[i].r+1};
    }
    sort(qry+1,qry+n*2+1,cmp);
    int Qcnt=1;
    for(int i=1;i<=Q;i++)
    {
        root[i]=root[i-1];
        while(i==qry[Qcnt].Tp)
        {
            root[i]=Insert(root[i],1,p,qry[Qcnt].pos,qry[Qcnt].val,qry[Qcnt].st);
            Qcnt++;
        }
    }
    long long ans=1;
    while(Q--)
    {
        int ps,A,B,C;
        long long k;
        scanf("%d%d%d%d",&ps,&A,&B,&C);
        k=(ans*A+B)%C+1;
        ans=Query(root[ps],1,p,k);
        printf("%lld\n",ans);
    }
}

level 2-2 可持久化并查集

用主席树维护fa数组和dep数组。
将每次合并看做是单点修改fa值。
注意这里并不能用路径压缩，因为路径压缩修改的fa值非常多，很容易MLE。
这里可以用启发式合并，使得深度大约在log⁡n\log nlogn左右
由于find的时候要Query,因此还会多一个log⁡\loglog
复杂度O(nlog⁡2n)O(n\log^2 n)O(nlog2n)
由于实际深度多数小于log⁡n\log nlogn因此常数较小。

#include<iostream>
#include<cstdio>
using namespace std;
#define MAXN 200000
int tp,n,Q,u,v;
int rt[MAXN*40+5];
struct Per_DSU{
	int L[MAXN*40+5],R[MAXN*40+5],fa[MAXN*40+5],dep[MAXN*40+5];
	int ecnt;
	Per_DSU(){ecnt=0;}
	void Build(int &p,int l,int r)
	{
		p=++ecnt;
		if(l==r){fa[p]=l;return ;}
		int mid=(l+r)>>1;
		Build(L[p],l,mid),Build(R[p],mid+1,r);
	}
	void merge(int p1,int &p2,int l,int r,int pos,int v)
	{
		p2=++ecnt;L[p2]=L[p1],R[p2]=R[p1];
		if(l==r){fa[p2]=v;dep[p2]=dep[p1];return ;}
		int mid=(l+r)>>1;
		if(pos<=mid)merge(L[p1],L[p2],l,mid,pos,v);
		else merge(R[p1],R[p2],mid+1,r,pos,v);
	}
	void update(int p,int l,int r,int pos)
	{
		if(l==r){dep[p]++;return ;}
		int mid=(l+r)>>1;
		if(pos<=mid)update(L[p],l,mid,pos);
		else update(R[p],mid+1,r,pos);
	}
	int Query(int p,int l,int r,int pos)
	{
		if(l==r)return p;
		int mid=(l+r)>>1;
		if(pos<=mid)return Query(L[p],l,mid,pos);
		else return Query(R[p],mid+1,r,pos);
	}
	int xfind(int rt,int pos)
	{
		int np=Query(rt,1,n,pos);
		if(fa[np]==pos)return np;
		return xfind(rt,fa[np]);
	}
}S;
int main()
{
	scanf("%d%d",&n,&Q);
	S.Build(rt[0],1,n);
	for(int i=1;i<=Q;i++)
	{
		scanf("%d%d",&tp,&u);
		if(tp==1)
		{
			scanf("%d",&v);
			int nx,ny;
			rt[i]=rt[i-1];
            nx=S.xfind(rt[i],u);ny=S.xfind(rt[i],v);
            if(S.fa[nx]!=S.fa[ny])
            {
                if(S.dep[nx]>S.dep[ny])swap(nx,ny);
                S.merge(rt[i-1],rt[i],1,n,S.fa[nx],S.fa[ny]);
                if(S.dep[nx]==S.dep[ny])S.update(rt[i],1,n,S.fa[ny]);
            }
		}
		if(tp==2)rt[i]=rt[u];
		if(tp==3){
			scanf("%d",&v);
			int nx,ny;
			rt[i]=rt[i-1];
            nx=S.xfind(rt[i],u);ny=S.xfind(rt[i],v);
			if(S.fa[nx]==S.fa[ny])puts("1");
            else puts("0");
		}
	}
}

level 2-3 [SDOI2010]粟粟的书架

其实这题可以不用线段树做…
Task1:
由于Pi,j≤1,000,R,C≤200P_{i,j}≤1,000,R, C≤200Pi,j​≤1,000,R,C≤200
考虑直接矩阵前缀和。
定义cnt[i][j][k]cnt[i][j][k]cnt[i][j][k]为(1,1)−(i,j)(1,1)-(i,j)(1,1)−(i,j)矩阵中数值大于等于kkk的个数。
sum[i][j][k]sum[i][j][k]sum[i][j][k]为(1,1)−(i,j)(1,1)-(i,j)(1,1)−(i,j)矩阵中数值大于等于kkk的数值和。
二分一下kkk即可
Task2:
考虑使用主席树。
做法很显然，基本上和模板一样。
发现也有用莫队做的，但实际上这道题用莫队并不好…

level 3

level 3-1 [CTSC2018]混合果汁

看到CTSC被吓到了…
其实是一道联赛签到题。

看到最小值最大第一直觉二分ddd。
考虑果汁按ddd排序。
题目要求价格乘以容量最大，由于总容量固定，价格肯定是越小越好，那么肯定还要按价格排序。
这是二维的，由于价格只用前缀，明显是一个主席树可以解决的问题。
具体做法就是先让果汁按ddd从大到小排序，依次加入主席树中，这样我们就有了nnn个版本的线段树，接下来二分ddd，在相应版本的线段树上再次二分即可。
注意这题要开long long…
O(nlog⁡2n)O(n \log^2 n)O(nlog2n)

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cmath>
#include<vector>
using namespace std;
#define MAXN 100000
#define LL long long
#define INF 1000000000000000001
#define MOD 1000000000
#define PB push_back
#define MP make_pair
#define FR first
#define SE second
int n,Q,tp1,tp2,tp3;
int rt[MAXN+5];
int pcnt;
struct juice
{
	int d,p,l;
}S[MAXN+5];
struct node
{
    int lc,rc;
    LL cnt,sum;
}tree[MAXN*20+5];
bool cmp(juice s1,juice s2){return s1.d>s2.d;}
void Build(int &x,int l,int r)
{
    x=++pcnt;
    if(l==r)return ;
    int mid=(l+r)>>1;
    Build(tree[x].lc,l,mid);
    Build(tree[x].rc,mid+1,r);
}
int Insert(int x,int l,int r,int pos,LL val)
{
    int Nr=++pcnt;
    tree[Nr]=tree[x];
    tree[Nr].sum=tree[x].sum+1LL*val*pos;
    tree[Nr].cnt=tree[x].cnt+val;
    if(l==r)return Nr;
    int mid=(l+r)>>1;
    if(pos<=mid)tree[Nr].lc=Insert(tree[Nr].lc,l,mid,pos,val);
    else tree[Nr].rc=Insert(tree[Nr].rc,mid+1,r,pos,val);
    return Nr;
}
LL Query(int x,int l,int r,LL L)
{
	//printf("%d %lld->%d %d\n",tree[x].cnt,L,l,r);
	if(tree[x].cnt<L)return INF;
    if(l==r)return 1LL*L*l;
    int mid=(l+r)>>1;
    if(tree[tree[x].lc].cnt>=L)return Query(tree[x].lc,l,mid,L);
    else return tree[tree[x].lc].sum+Query(tree[x].rc,mid+1,r,L-tree[tree[x].lc].cnt);
}
int main()
{
    scanf("%d%d",&n,&Q);
    for(int i=1;i<=n;i++)
    {
    	scanf("%d%d%d",&tp1,&tp2,&tp3);
    	S[i]=(juice){tp1,tp2,tp3};
	}
    sort(S+1,S+n+1,cmp);
    Build(rt[0],1,MAXN);
    for(int i=1;i<=n;i++)
    rt[i]=Insert(rt[i-1],1,MAXN,S[i].p,S[i].l);
    while(Q--)
    {
        LL G,L;
        scanf("%lld%lld",&G,&L);
        int l=1,r=n,p=0;
        while(l<=r)
        {
        	int mid=(l+r)>>1;
        	if(Query(rt[mid],1,MAXN,L)<=G)p=mid,r=mid-1;
        	else l=mid+1;
    	}
    	printf("%d\n",(p!=0)?S[p].d:-1);
    }

}

level 3-2 欧铂瑞特

写了一篇blog

仍在更新中

转载于:https://www.cnblogs.com/Panda-hu/p/11145743.html

domy79360
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
主席树题集及小结
代码笔记本
12-03 772
怕期末月完了就忘完了,蒟蒻总结一波。 先来模板题:求静态区间第k小 https://www.luogu.com.cn/problem/P3834 对于板子的理解: 板子的博客 #include<iostream> #include<vector> #include<queue> #include<cstring> #include<cmath> #include<map> #include<set> #inclu
[C++]可持久化线段树 主席树模型分析及例题详解
weixin_62712365的博客
08-07 1203
可持久化线段树 主席树模型分析及例题详解
主席树的一些习题
Harris-H的博客
04-07 368
主席树的一些习题 P3567 [POI2014]KUR-Couriers 题意 输出区间内出现次数严格大于区间长度的一半的数，存在输出任意，否则输出0。 思路 区间数出现次数具有可减性，考虑建立主席树，令k=(r−l+1)2k=\dfrac{(r-l+1)}{2}k=2(r−l+1)​，每次查询左子树元素个数是否大于kkk，是就递归进入左子树，否则进入右子树，每次都需要提前判断当前区间元素个数是否大于kkk，否则直接返回000。 时间复杂度：O(nlogn)O(nlogn)O(nlogn) 空间复杂度：O(
[主席树]HDOJ2665 && POJ2104 && POJ2761
aicheng4794的博客
07-16 135
主席树真是神奇的物种！ Orz一篇资料 题意：给n、m 　　 下面有n个数 (编号1到n) 　　　有m个询问，询问的是上面的数的编号在[l,r]之间第k小的数 n、m的范围都是$10^5$ 是主席树的入门题 借此来学习一下主席树 主席数利用函数式线段树来维护数列，一般用来解决区间第k大问题 空间时间的复杂度小于树套树(常数小) 划分树也可以解...
主席树总结（题目合集）
常胜将军的博客
03-04 1695
1、HDU 2665 题意：无修改区间第k大 思路：主席树（离线算法）网上都有各种详细的解释了，就不多说了。。。主席树的核心思想包括前缀和、二分查找、空间重复利用、转化（区间表示在此范围内的数的个数，即权值线段树）。时间和空间复杂度为nlogn。 代码： #include<iostream> #include<algorithm> using namespace...
CCNP学习笔记经典汇总
07-23
教程名称：CCNP学习笔记经典汇总       课程目录： 【】2010年第一季度CCNP学习笔记完整版 【】CCNA CCNP笔记 ccnp案例 实验 【】CCNA-CCNP讲义整理 【】CCNP全套笔记 【】...
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
Java学习笔记(必看经典).pdf
11-27
Java学习笔记(必看经典).pdf
python树的同构学习笔记
12-31
给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2，则我们称两棵树是“同构的”。现给定两棵树，请你判断它们是否是同构的。 输入格式：输入给出2棵二叉树的信息： 先在一行中给出该树的结点树，随后N...
学习笔记学习笔记学习笔记
最新发布
01-29
学习笔记学习笔记学习笔记
主席树题目整理
Harris-H的博客
07-13 452
主席树题目整理 前话：由于太菜，所以开个坑整理有关主席树的题目，可能会咕咕咕。 1.P3834 【模板】可持久化线段树 2（主席树） 区间第kkk小，转权值主席树，具体见代码。 #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N=2e6+5,M=N*21,inf=0x3f3f3f3f,mod=1e9+7; #define mst(a) memset(a,0,sizeof a) #define
【BZOJ 2653】middle 主席树好题推荐
pbihao的博客
12-25 507
谈谈这一道题的最强烈的感受在于，我的主席树入门是经典题目区间第k大树查询（当然，因为poj上不会强制在线，还用树套树和整体二分写过那道题），因此，对于主席树的理解仅仅是一个区间历史版本维护的理解，即类似于树套树的外层区间树内层全值树。但是忽略了主席树的真正伟大之处在于可持久化，而可持久化的也能是权值。 对于这一道题，由于我们不知道中位数是多少，因此考虑二分，而关键之处在于如何二分cheak，可以
P3293 [SCOI2016]美味【主席树好题】
slass-mot-odet
09-10 213
题目描述 一家餐厅有 n 道菜，编号 1…n ，大家对第 i 道菜的评价值为 ai(1<=i<=n)。有 m 位顾客，第 i 位顾客的期望值为 bi，而他的偏好值为 xi 。因此，第 i 位顾客认为第 j 道菜的美味度为 bi XOR (aj+xi)，XOR 表示异或运算。 第 i 位顾客希望从这些菜中挑出他认为最美味的菜，即美味值最大的菜，但由于价格等因素，他只能从第 li 道到第 ...
浅谈主席树
Renatus的博客
02-16 558
浅谈主席树
主席树模板总结及题集
jerans的博客
08-11 2692
介绍篇：http://blog.csdn.net/metalseed/article/details/8045038  -> 理解篇（配图比较生动）：http://blog.csdn.net/regina8023/article/details/41910615  -> 题目：poj2104 区间查询第k大元素，非递归写法，非递归不好进行回溯操作，递归更好写一些 #include #inc
【动态主席树】ZOJ 2112【树状数组+主席树】
Gene_I must wait for the sunrise
11-18 332
题意： 给定一个区间，求这个区间第k小的数，支持单点修改。 思路： 动态主席树裸题。 我们先来回顾一下静态主席树的做法，对于数组中每一个位置都维护一棵权值线段树，该权值线段树保存的是区间 [1,x] 的信息。因此我想要求区间 [l,r] 之间第k大的时候，只需要将root[r]-root[l-1]就是维护区间 [l,r] 信息的权值线段树，因此就可...
主席树模板题
No Program No Life
01-29 564
POJ2104 POJ2761 HDU2665 题意都是区间求第k小主席树插入是按数组序列从小到大后排名的插入。 所以之后查询才可以按左右子树的个数递归查询#include <cstdio> #include <iostream> #include <algorithm> using namespace std; const int maxn = 100000 + 1
主席树题目总结
cy41的博客
06-13 301
前置知识：基于值域的整体第k大（权值线段树） 写主席树必定需要注意空间的开销，一定要开够 若长度为n，修改为m次，则空间复杂度为n+m*logn。 可以在我的博客里翻一翻2333。 基础问题，求解区间第k大，或者区间小于等于k的个数： poj-2104 HDU-4417 下面两个前置知识LCA P2633 Count on a tree Distance on the tree ...
对主席树的一点理解 -- 例题POJ 2104
aozil_yang的博客
03-22 886
断断续续看了许久的主席树，简单记录一下。 什么样的题目用主席树呢，比如POJ 2104 求区间第K大的数是谁？ 当时做这个题时，感觉分块+二分可以搞，就写了好久，改了好久，始终TLE,还是学学主席树把= =。 先吐槽一下线段树： 线段树竟然是被一个黄嘉泰的大佬因不会划分树来代替的，，，，，因缩写是HJT取名为主席树= =！orz 主席树大体思路： 我们怎样求区间第K大数呢: 假如我们
ExtJs 2.1 学习笔记概览
"extJs+2.1学习笔记.pdf" 这篇学习笔记详尽地涵盖了ExtJs 2.1版本的关键概念和技术。ExtJs是一种基于JavaScript的富客户端框架，用于构建功能丰富的Web应用程序。笔记分为多个章节，逐步深入地介绍了ExtJs的核心...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值