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-6;
const ll mod=1e9+7;
const int inf=0x3f3f3f3f;
const int maxn=1e5+10;
const int maxm=100+10;
#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<<5],L[maxn<<5],R[maxn<<5];//sum线段树里保存的值，L左儿子，R右儿子
int n,m,sz=0;

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

    int m=(l+r)>>1;
    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;//插入序列，首先继承以前的线段树 然后直接单点+1就可以
    L[rt]=L[pr];R[rt]=R[pr];
    if(l==r){
        return ;
    }

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

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