其他分享
首页 > 其他分享> > 主席树 【权值线段树】 && 例题K-th Number POJ - 2104

主席树 【权值线段树】 && 例题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