HDU 2665.Kth number-可持久化线段树(无修改区间第K小)模板 (POJ 2104.K-th Number 、洛谷 P3834 【模板】可持久化线段树 1（主席树）只是输入格式不一样，其他几乎都一样的)

Kth number

Time Limit: 15000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 16941    Accepted Submission(s): 5190

Problem Description

Give you a sequence and ask you the kth big number of a inteval.

 

Input

The first line is the number of the test cases. 
For each test case, the first line contain two integer n and m (n, m <= 100000), indicates the number of integers in the sequence and the number of the quaere. 
The second line contains n integers, describe the sequence. 
Each of following m lines contains three integers s, t, k. 
[s, t] indicates the interval and k indicates the kth big number in interval [s, t]

 

Output

For each test case, output m lines. Each line contains the kth big number.

 

Sample Input

1

10 1

1 4 2 3 5 6 7 8 9 0

1 3 2

 

Sample Output

2

 

Source

HDU男生专场公开赛——赶在女生之前先过节（From WHU）

 

 

 

 

 

题意就是查询区间第K小，可持久化线段树就可以上场了。

 

没学可持久化数据结构之前，感觉这个东西是个很高大上，很厉害的东西，等到了解之后发现，就是因为问题的产生所以在原有线段树的基础上有所更新，支持查询历史版本。

如果每更新一次就新建一整棵线段树简直是丧心病狂，所以直接新开节点保存更新的那一条链就可以。

这种东西还是需要自己慢慢体会的，加油，咸鱼。

 

代码:

 //无修改区间第K小-可持久化线段树(权值线段树+可持久化)
 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<bitset>
 #include<cassert>
 #include<cctype>
 #include<cmath>
 #include<cstdlib>
 #include<ctime>
 #include<deque>
 #include<iomanip>
 #include<list>
 #include<map>
 #include<queue>
 #include<set>
 #include<stack>
 #include<vector>
 using namespace std;
 typedef long long ll;
 typedef pair<int,int> pii;

 const double PI=acos(-1.0);
 const double eps=1e-;
 const ll mod=1e9+;
 const int inf=0x3f3f3f3f;
 const int maxn=1e5+;
 const int maxm=+;
 #define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
 #define lson l,m
 #define rson m+1,r

 int a[maxn],b[maxn],sum[maxn<<],L[maxn<<],R[maxn<<];//sum线段树里保存的值，L左儿子，R右儿子
 int n,m,sz=;

 void build(int &rt,int l,int r)//建棵空树
 {
     rt=++sz;sum[rt]=;//动态开点，初始值为0，空树
     if(l==r){
         return ;
     }

     int m=(l+r)>>;
     build(L[rt],lson);
     build(R[rt],rson);
 }

 void update(int pr,int &rt,int l,int r,int x)
 {
     rt=++sz;sum[rt]=sum[pr]+;//插入序列，首先继承以前的线段树 然后直接单点+1就可以
     L[rt]=L[pr];R[rt]=R[pr];
     if(l==r){
         return ;
     }

     int m=(l+r)>>;
     if(x<=m) update(L[pr],L[rt],lson,x);//因为右边不需要更新，所以覆盖掉左边
     else     update(R[pr],R[rt],rson,x);
 }

 int query(int pr,int rt,int l,int r,int x)//查询l到r区间就是第r次插入减去第l-1次插入后的线段树的样子
 {
     if(l==r){
         return l;
     }
     //因为我们建立的是权值线段树，所以直接查找就可以
     int m=(l+r)>>;
     int now=sum[L[rt]]-sum[L[pr]];//now为左子树新树-旧树
     if(now>=x) return query(L[pr],L[rt],lson,x);
     else       return query(R[pr],R[rt],rson,x-now);
 }

 int rt[maxn];

 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--){
         scanf("%d%d",&n,&m);
         sz=;
         for(int i=;i<=n;i++){
             scanf("%d",&a[i]);
             b[i]=a[i];
         }
         sort(b+,b++n);//首先把值全部排序去重，用于建权值线段树，权值线段树保存的内容是值的数量。
         int d=unique(b+,b++n)-(b+);
         build(rt[],,d);
         for(int i=;i<=n;i++){//按照序列顺序插入值
             int x=lower_bound(b+,b++d,a[i])-b;
             update(rt[i-],rt[i],,d,x);
         }
         for(int i=;i<=m;i++){
             int l,r,k;
             scanf("%d%d%d",&l,&r,&k);
             printf("%d\n",b[query(rt[l-],rt[r],,d,k)]);
         }
     }
     return ;
 }

你来到人间，就是要看看太阳，看看外面有趣的世界。