主席树 【权值线段树】 && 例题K-th Number POJ - 2104
作者：互联网
一、主席树与权值线段树区别
主席树是由许多权值线段树构成，单独的权值线段树只能解决寻找整个区间第k大/小值问题（什么叫整个区间，比如你对区间[1,8]建立一颗对应权值线段树，那么你不能询问区间[2,5]第k大/小值，你只能询问[1,8]第k大/小值问题）
二、权值线段树是什么鬼
学权值线段树之前你肯定要知道线段树，线段树是对区间中的所有数进行维护
权值线段树维护的对象和它不同，权值<==>这个数在这个区间中出现的次数
例如1、5、3、2、4
建立的权值线段树：
你会发现，权值线段树的建立和线段树不一样，线段树要考虑每一个数在区间中的位置
但是权值线段树不用管，相当于排完序之后建立的一颗树 。 要注意：权值代表这个数出现了几次
例如：我们寻找这个区间的第3小值
我们从根节点[1,5]的左节点来判断，因为左节点的权值要大于3，所以区间内第3小值肯定在根节点的左区间内
我们再看区间[1,3]的左节点，发现它的左节点权值为2小于3，所以答案肯定在区间[1,3]的右节点内。注意：这个时候我们要在右节点内寻找第3-2小值
之后那区间[3,3]内第1小值肯定就是3本身了
要注意如果题目给你的数据特别大，例如1、1000、200000000这三个数，我们要是直接建立权值线段树，那内存就炸了
所以这个时候就要离散化处理
三、主席树构成
我们文章开头说过，主席树是由许多权值线段树构成，而且主席树可以解决：在对应区间建立的主席树，可以找寻该区间所有子区间内的第k大/小值
（即、对区间[1,5]建立主席树，那么我们也可以找寻区间[1,3]的第k大/小值）
1、解决方法1：
排序后找到那个位置输出（不用想了，暴力方法肯定会被卡）
2、解决方法2：
对于一个区间[l, r]我们用一个用这个区间内出现过的数的个数组成一颗权值线段树，然后查询就完事了
但是多次询问区间第k小，我们每次这样建立一个线段树，这样不仅空间复杂度非常之高，而且时间复杂度也非常高，甚至比普通排序还要高，那么我们只不是可以想一个办法，使得对于每次我们查询不同的区间我们不需要重新建树，如果这样。时间复杂度和空间复杂度就大大降低了。
3、解决方法3：
这就用到了前缀和，比如我们有一个问题。就是每次静态的求区间和，我们可以预处理所以的前缀和sum[i]，我们每次求解区间[l, r]和时，我们可以直接得到答案为sum[r] - sum[l -1],这样就不需要对区间中的每个数进行相加来求解了。（这里我们设sum[i]中放的是权值线段树上i节点的权值）
想到就写起来
我们可以对区间[1,5]建立6棵权值线段树，分别是[0,0],[1,1],[1,2],[1,3],[1,4],[1,5] （[0,0]是一颗空树）
这样我们处理任意区间[l, r]时就可以通过处理区间[1,l - 1], [1,r]，就行，然后两者的处理结果进行相加相减就行。为什么满足相加减的性质，我们简单分析一下就很容易得出。如果在区间[1,l - 1]中有x个数小于一个数，在[1,r]中有y个数小于那个数，那么在区间[l,r]中就有y - x 个数小于那个数了，这样就很好理解为什么可以相加减了，另外，每颗树的结构都一样，都是一颗叶节点为n个的线段树。
上述利用前缀和的思想只是解决了时间复杂度的问题，并没有解决空间复杂度的问题，要解决空间复杂度问题。我们需要用到线段树的性质，我们每次更新一个数，那么与更新之前相比，这颗线段树改变只是一条链（从根节点到某一叶节点），那么我们可以充分利用这个特点，因为第i颗树与第i- 1颗树相比，只是更新了第i个元素，那么实际上第i颗树与第i-1颗树之间只有log个节点的信息是不同的。.所以这两棵树有很多相同的节点，所以这两棵树可以共用很多节点，也就是说，我们在第i-1颗树上 插入一个节点a[i] 得到第i颗权值线段树，而单点插入过程中只会修改根到那个叶子节点的路径上的那log个节点。于是这样就解决空间复杂度问题。
还是以上面的1、3、2、5、4为例子：
1、刚开始的空树
2、加一个1节点
3、加一个2节点
4、加一个节点3
后面的4和5号节点就不写了，大家懂了就行。。。
四、主席树复杂度
插入一个点的时空复杂度都为O(log n),所以建立这颗主席树【权值线段树总体】的时空复杂度就是O(n log n),单次询问经过log n个节点，时间复杂度也为O(log n)
5、例题
K-th Number POJ - 2104
代码1：
1 #include<stdio.h>
2 #include<iostream>
3 #include<algorithm>
4 #include<string.h>
5 using namespace std;
6 const int maxn=1e5+10;
7 int cnt,ranks[maxn],v[maxn],root[maxn];
8 struct shudui
9 {
10 int value,id;
11 }w[maxn];
12 struct Node
13 {
14 int l,r,sum;
15 Node(){
16 sum=0;
17 }
18 }tree[maxn*20];
19 bool mmp(shudui x,shudui y)
20 {
21 return x.value<y.value;
22 }
23 void init()
24 {
25 cnt=1;
26 root[0]=0;
27 tree[0].l=tree[0].r=tree[0].sum=0;
28 }
29 void inserts(int num,int &rt,int l,int r)
30 {
31 tree[cnt++]=tree[rt];
32 rt=cnt-1;
33 tree[rt].sum++;
34 if(l==r) return;
35 int mid=(l+r)>>1;
36 if(num<=mid) inserts(num,tree[rt].l,l,mid);
37 else inserts(num,tree[rt].r,mid+1,r);
38 }
39 int query(int i,int j,int k,int l,int r)
40 {
41 int d=tree[tree[j].l].sum-tree[tree[i].l].sum;
42 if(l==r) return l;
43 int mid=(l+r)>>1;
44 if(k <= d) return query(tree[i].l, tree[j].l, k, l, mid); //这里是小写的L,mid可不是数字1
45 else return query(tree[i].r, tree[j].r, k - d, mid + 1, r);
46 }
47 int main()
48 {
49 int n,m;
50 scanf("%d%d",&n,&m);
51 for(int i=1;i<=n;++i)
52 {
53 scanf("%d",&w[i].value);
54 w[i].id=i;
55 }
56 sort(w+1,w+1+n,mmp);
57 w[0].value=-1;
58 int j=1;
59 for(int i=1;i<=n;++i)
60 {
61 if(w[i].value!=w[i-1].value)
62 ranks[w[i].id]=j,v[j]=w[i].value,j++;
63 else ranks[w[i].id]=j-1;
64 }
65 init();
66 for(int i=1;i<=n;++i)
67 {
68 //printf("%d %d\n",ranks[i],v[i]);
69 root[i]=root[i-1];
70 inserts(ranks[i],root[i],1,n);
71 }
72 while(m--)
73 {
74 int l,r,x;
75 scanf("%d%d%d",&l,&r,&x);
76 printf("%d\n",v[query(root[l-1],root[r],x,1,n)]);
77 }
78 return 0;
79 }
代码2：
1 //洛谷 P3834 可持久化线段树（主席树）
2
3 #include<cstdio>
4
5 #include<cstring>
6
7 #include<algorithm>
8
9 using namespace std;
10
11 const int N=200005;
12
13 int n,m,q,t=0;
14
15 int a[N],b[N],root[N];
16
17 struct node
18
19 {
20
21 int ls,rs,sum;
22
23 }tree[N*20];
24
25 void disc()
26
27 {
28
29 int i;
30
31 sort(b+1,b+n+1);
32
33 m=unique(b+1,b+n+1)-(b+1);
34
35 for(i=1;i<=n;++i)
36
37 a[i]=lower_bound(b+1,b+m+1,a[i])-b;
38
39 }
40
41
42
43 //insert函数就是说：当前插入的数p，会影响节点x，所以把x节点的sum加1.
44
45
46
47 //节点x代表一个权值区间，影响x就是说p在节点x所代表的权值区间内。
48
49 //那么先把前一个树的对应区间的节点复制过来，再加1，就行了。
50
51 //可以结合刚才的图感性理解一下。
52
53 void insert(int y,int &x,int l,int r,int p)
54
55 {
56
57 x=++t; //t相当于是一个节点的地址，每个节点是不同的。
58
59 tree[x]=tree[y]; //复制前一个树的对应节点【它们代表的权值区间相同】。
60
61 tree[x].sum++; //给这个节点的sum加1.（这个1指的就是p）
62
63 if(l==r) return; //搜索到根节点就返回。
64
65 int mid=(l+r)>>1;
66
67
68
69 //判断在哪个区间继续插入。
70
71 if(p<=mid) insert(tree[y].ls,tree[x].ls,l,mid,p);
72
73 else insert(tree[y].rs,tree[x].rs,mid+1,r,p);
74
75 }
76
77
78
79 //k是查询第k小
80
81 //x和y相当于是树的节点的地址。而l和r就是这两个节点的权值区间。
82
83 //一开始query(root[l-1],root[r],1,m,k)。
84
85 //root[l-1]就是第l-1颗树的根节点。root[r]就是第r颗树的根节点。
86
87 //比较它们左儿子代表的区间中的数的个数，差值为delta。根据delta判断这两个节点一起往哪个方向跳。
88
89 //分析过程和刚才二分的过程一样。
90
91 int query(int x,int y,int l,int r,int k)
92
93 {
94
95 if(l==r) return l; //查到权值线段树的叶子节点就返回这个值。
96
97 int delta=tree[tree[y].ls].sum-tree[tree[x].ls].sum;
98
99 int mid=(l+r)>>1;
100
101 if(k<=delta) return query(tree[x].ls,tree[y].ls,l,mid,k);
102
103 else return query(tree[x].rs,tree[y].rs,mid+1,r,k-delta);
104
105 }
106
107 int main()
108
109 {
110
111 int l,r,i,k;
112
113 scanf("%d%d",&n,&q);
114
115 for(i=1;i<=n;++i)
116
117 {
118
119 scanf("%d",&a[i]);
120
121 b[i]=a[i];
122
123 }
124
125 disc();
126
127 for(i=1;i<=n;++i)
128
129 insert(root[i-1],root[i],1,m,a[i]);
130
131 for(i=1;i<=q;++i)
132
133 {
134
135 scanf("%d%d%d",&l,&r,&k);
136
137
138
139 //query函数返回的是第k小的权值。
140
141 //把这个权值转化为原来这个权值对应的数就行了。
142
143 printf("%d\n",b[query(root[l-1],root[r],1,m,k)]);
144
145 }
146
147 return 0;
148
149 }
参考博客：
https://blog.csdn.net/g21glf/article/details/82986968
https://blog.csdn.net/creatorx/article/details/75446472
标签：复杂度,线段,Number,小值,&&,权值,区间,例题,节点 来源： https://www.cnblogs.com/kongbursi-2292702937/p/12059072.html