权值线段树+ 主席树（区间第K大或子区间某原素出现次数）

首先先上一个主席树求区间第K小的板子

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define mid (l+r)/2
using namespace std;
const int N = 1e6+4;
int L[N<<5],R[N<<5],sum[N<<5];
int a[N],b[N],T[N];
int cnt,ss;
int build(int l,int r)
{
	int rt = ++cnt;
	sum[rt] = 0;
	if(l < r){
		L[rt] = build(l,mid);
		R[rt] = build(mid+1,r);
 	}
	return rt;
}
int update(int pre,int l,int r, int k){
	int rt = ++cnt;
	L[rt] = L[pre],R[rt] = R[pre],sum[rt] = sum[pre] +1; 
	if(l<r){
		if(k <= mid)L[rt] = update(L[rt],l,mid,k);
		else R[rt] = update(R[rt],mid+1,r,k);
	}
	return rt;
}
int query(int u,int v,int l,int r,int k)
{
	if(l >= r)return l;
	int x = sum[L[v]] - sum[L[u]];
	if(x >= k )return query(L[u] ,L[v] , l, mid ,k);
	else  return query(R[u] ,R[v] ,mid+1 ,r ,k-x);
} 
int main(){
	int n,m,q,p;
	scanf("%d%d",&n,&p);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		b[i]=a[i];
	}
	sort(b+1,b+1+n);
	m = unique(b+1,b+1+n)-b-1;
	T[0] = build(1,m);
//离散化
	for(int i = 1;i<=n;i++)
	{
		int t = lower_bound(b+1,b+1+m,a[i])-b;
		T[i] = update(T[i-1],1,m,t);
	}
	while(p--){
		int z,y,x;
		scanf("%d%d%d",&x,&y,&z); 
		int t = query( T[x-1],T[y],1,m,z);
		printf("%d\n",b[t]);
	}
	return 0;

这就是普通的主席树啦
当然这种连注释都没有的用不上
所以我们先来聊一下权值线段树
例题
杭电多校2019 第三场Find the answer
题意：Q组样例。每组样例第一行给出n、m，接下来一行n个数(a[i])。对于每一元素，删掉之前最少的元素使其和小于等于m;
建立一颗权值线段树，离散化之后查一下多少个凑到m就可以了
代码如下

#include<bits/stdc++.h>
#define LL long long
#define PLL pair<LL,LL>
using namespace std;
const int INF=0x3f3f3f3f;
const int maxn=2e5+50;
int n,N;
LL m,a[maxn],b[maxn],sum[maxn<<2],num[maxn<<2];
void init(){
    sort(b+1,b+1+n);
     N = unique(b+1,b+1+n)-b-1;
     for(int i=1;i<=n;i++)
     {
         a[i] = lower_bound(b+1,b+1+N,a[i])-b;
     }
}//离散化 
void updata(int rt,int l,int r,int p)
{
    if(l==r)
    {
        sum[rt]+=b[l];    //记录权值p的总和
        num[rt]++;        //记录权值p的个数
        return;
    }
    int mid=(l+r)>>1;
    if(p<=mid)
        updata(rt<<1,l,mid,p);
    else
        updata(rt<<1|1,mid+1,r,p);
    sum[rt]=sum[rt<<1]+sum[rt<<1|1];
    num[rt]=num[rt<<1]+num[rt<<1|1];
}
PLL query1(int rt,int l,int r,LL k) //二分找到需删除权值的分界点
{
    if(l==r)
    {
        if(k%b[l]==0)
            return PLL(l,k/b[l]);    //返回分界点权值
        else                         //以及需要删除的该分界点权值的具体个数
            return PLL(l,k/b[l]+1);
    }
    int mid=(l+r)>>1;
    if(sum[rt<<1|1]>=k)    //若右子树总和大于k，往右子树找
        return query1(rt<<1|1,mid+1,r,k);
    else
        return query1(rt<<1,l,mid,k-sum[rt<<1|1]); //否则往左子树找，注意k要减去右子树的权值
                                                 //（说明右子树的元素都要删除）
}
LL query2(int rt,int l,int r,int ql,int qr)  //查询个数
{
    if(ql<=l&&r<=qr)
        return num[rt];
    if(r<ql||l>qr)
        return 0;
    int mid=(l+r)>>1;
    return query2(rt<<1,l,mid,ql,qr)+query2(rt<<1|1,mid+1,r,ql,qr);
}
int main()
{
    int Q;
    scanf("%d",&Q);
    while(Q--)
    {
        scanf("%d %lld",&n,&m);
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",&a[i]);
            b[i]=a[i];
        }
        init();    //离散化
        memset(sum,0,sizeof(sum));
        memset(num,0,sizeof(num));        
        LL sum=0,ans[maxn];
        
        for(int i=1;i<=n;i++)
        {
            sum+=b[a[i]];
            if(sum>m)                 
            {
                PLL temp=query1(1,1,N,sum-m);
                ans[i]=temp.second;   //需删除的分界点权值的具体个数
                if(temp.first+1<=m)
                    ans[i]+=query2(1,1,N,temp.first+1,m);  //大于分界点权值的元素个数
            }
            else
                ans[i]=0;
            updata(1,1,N,a[i]);
        }
        
        for(int i=1;i<=n;i++)
            printf("%lld ",ans[i]);
        printf("\n");
    }
    return 0;
}

很明显这样子建树只能查之前的元素，无法在某一子区间中进行查询，所以我们把他可持久化一下，就成为了主席树
主席树可以查询区间第K大，也可以查询某元素出现了几次（???)
例题杭电多校2019 第四场K-th Closest Distance
题意：给定n个数字，q次询问，每次给出l，r，p，k。询问区间l，r内所有数字与p的差值的绝对值中排名第k大的是多少。
主席树+二分 没了

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
const int M = 1e6;
struct node{
    int val ,l,r;
}tree[N*40]; //
int root[N],cnt;
int n,q,a[N];
int update(int pre,int L,int R,int k)
{
    int ctt = ++cnt;
    tree[ctt] = tree[pre];
    tree[ctt].val ++ ;
    if(L==R)return ctt;
    int mid = (R+L)/2;
    if(mid >= k) tree[ctt].l = update(tree[pre].l,L,mid,k);
    else tree[ctt].r = update(tree[pre].r,mid+1,R,k);
    return ctt; 
}
int query(int pl, int pr, int l, int r, int rt, int lt) {
    if(pl <= l && r <= pr) {
        return tree[rt].val - tree[lt].val;
    }
    int mid = (l + r) >> 1;
    int res = 0;
    if(pl <= mid) res += query(pl, pr, l, mid, tree[rt].l, tree[lt].l);
    if(pr > mid) res += query(pl, pr, mid + 1, r, tree[rt].r, tree[lt].r);
    return res;
} 
int main(){
    int t;
    scanf("%d",&t);
    while(t--)
    {
        cnt = 0;
        scanf("%d%d",&n,&q);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            root[i] = update(root[i-1],1,M,a[i]);
        }
        int prex=0,l,r,p,k;
        while(q--)
        {
            scanf("%d%d%d%d",&l,&r,&p,&k);
            l^= prex,r^=prex,p^=prex,k^=prex;
                   int     pl = 0, pr = M;
                while(pl <= pr) 
                {
                         int mid = (pl + pr) >> 1;
                             if(query(max(1, p - mid), min(M, p + mid), 1, M, root[r], root[l - 1]) >= k) 
                        {
                                prex = mid;
                                pr = mid - 1;
                                
                            }
                         else pl = mid + 1;
                    }
                printf("%d\n",prex);
        }
        
    }
    return 0;
}

谢谢观看啊啊啊