主席树模板整理

#include<bits/stdc++.h>
#define MAXN 200100
using namespace std;

int n,m,size_disc;					 	
int n_init[MAXN],n_disc[MAXN];		 	//n_init:原始数组;	n_disc:离散化数组
int rt[MAXN],lc[MAXN<<5],rc[MAXN<<5],sum[MAXN<<5];	//rt:不同版本的根节点; lc/rc:左儿子右儿子（公用）;	sum:和（公用）
int node_cnt,pnt_disc;				 	//node总计数;	pnt_disc: A中数字对应在B中的值

void build(int &last_node, int l, int r){
	last_node = ++node_cnt;
	sum[last_node]=0;
	if(l == r) return;
	int mid = (l + r) >> 1;
	build(lc[last_node],l,mid);
	build(rc[last_node],mid+1,r);
}

int modify(int pre_rt, int l, int r){
	int new_rt= ++node_cnt;

	lc[new_rt]=lc[pre_rt];
	rc[new_rt]=rc[pre_rt];
	sum[new_rt]=sum[pre_rt]+1;			//修改了这个节点，这个节点个数肯定+1

	int mid = (l+r)/2;
	if(l==r) return new_rt;
	if(mid>=pnt_disc) lc[new_rt]=modify(lc[new_rt],l,mid);		//现在的new lc/rc 与 pre lc/rc 完全等价
				else  rc[new_rt]=modify(rc[new_rt],mid+1,r);
	return new_rt;
}

int query(int rt1,int rt2,int k,int l,int r){				//rt1 rt2是旧版本与新版本两个规模完全相同的线段树;	k是期望达到值; l/r是在两颗树上完全同步的查询区间

	if(l==r){
		return l;			//返回当前所在的修改后的数组的为止
	}
	int mid=(l+r) >> 1;
	int temp=sum[lc[rt2]]-sum[lc[rt1]];
	int ans;
	if(temp>=k) ans=query(lc[rt1],lc[rt2],k,l,mid);		//由于是权值线段树记录的是点的个数	
	else ans=query(rc[rt1],rc[rt2],k-temp,mid+1,r);	//这里要减去前面（区间内）所有的数的个数,剩下的是在rc中要查询的个数nihao
	return ans;
}

int main(){
	scanf("%d%d",&n,&m);
	for(int i=1; i<=n; i++){
		scanf("%d",&n_init[i]);
		n_disc[i]=n_init[i];
	}
	sort(n_disc+1,n_disc+n+1);				//先排序再进行离散化
	size_disc=unique(n_disc+1,n_disc+n+1)-n_disc-1;//由于从1开始的数组故都要+(-)1;	unique为离散化函数
	//for(int i=1; i<=size_disc; i++) cout<<n_disc[i]<<" ";
	//1 1 3 3 5 5 5 8 10 10 离散化后是 1 3 5 8 10
	node_cnt=0;
	build(rt[0] , 1 , size_disc);
	for(register int i=1; i<=n; i++){
		pnt_disc = lower_bound(n_disc+1, n_disc+size_disc+1, n_init[i]) - n_disc;		//这个回合要modify的值，回合内不变
		//以上序列对应值: 1 1 2 2 3 3 3 4 5 5 
		rt[i]=modify(rt[i-1],1,size_disc);		//在上一个版本的基础上修改
	}

	for(int i=0; i<m; i++){
		int l,r,k;
		scanf("%d%d%d",&l,&r,&k);
		l--;
		int ans=query(rt[l],rt[r],k,1,size_disc);//查询l到r中第k小的数 
		printf("%d\n",n_disc[ans]);
	}

}

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<map>
#include<stack>
#include<set>
#include<ctime>
#define iss ios::sync_with_stdio(false)
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int mod=1e9+7;
const int MAXN=1e6+5;
const int inf=0x3f3f3f3f;
int a[MAXN];
int tree[MAXN];
int cnt=0;
std::vector<int> v;
int len;
struct Node
{
    int l,r;
    ll sum;
}node[MAXN*40];
int cal(int x)
{
    return lower_bound(v.begin(),v.end(),x)-v.begin()+1;
}
int cal_rk(ll x)
{
    if(v[len-1]<=x) return len;
    int pos=upper_bound(v.begin(),v.end(),x)-v.begin()+1;
    pos--;
    return pos;
}
void insert(int l,int r,int pre,int &now,int x,int val)
{
    node[++cnt]=node[pre];
    now=cnt;
    node[now].sum+=val;
    if(l==r) return;
    int mid=(l+r)>>1;
    if(x<=mid) insert(l,mid,node[pre].l,node[now].l,x,val);
    else insert(mid+1,r,node[pre].r,node[now].r,x,val);
}
ll query(int l,int r,int pre,int now,int find_right)
{
    if(r<=find_right) return node[now].sum-node[pre].sum;
    ll ans=0;
    int mid=(l+r)>>1;
    if(l<=find_right) ans+=query(l,mid,node[pre].l,node[now].l,find_right);
    if(mid+1<=find_right) ans+=query(mid+1,r,node[pre].r,node[now].r,find_right);
    return ans;   
}
int main()
{
    int n,m;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a[i]);
        v.push_back(a[i]);
    }
    sort(v.begin(),v.end());
    v.erase(unique(v.begin(),v.end()),v.end());
    len=v.size();
    for(int i=1;i<=n;i++)
    {
        insert(1,n,tree[i-1],tree[i],cal(a[i]),a[i]);
    }
    ll last=0;
    while(m--)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        l=(l+last)%n+1;
        r=(r+last)%n+1;
        if(l>r) swap(l,r);
        ll x=0;
        while(1)
        {
            int p=cal_rk(x+1);
            if(p==0) break;
            ll sum=query(1,n,tree[l-1],tree[r],p);//原数组中第p小的以及第比其小的数的和 
            if(sum==x) break;
            else x=sum;
        }
        printf("%lld\n",x+1);
        last=x+1;
    }

}

求区间第k大以及大于等于他的和

#include <bits/stdc++.h>
#define int long long
#define mid (left+right)/2
 
using namespace std;
 
const int maxn=1e5+10;
int n,m,q,tot=0;
int a[maxn],b[maxn],sum[maxn];
int T[maxn],tree[maxn*20],L[maxn*20],R[maxn*20];
int sumt[maxn*20];
// T[i]存的是第i棵树的root， tree[i]存的是正常线段树的值， l[i]存的是i号节点的左儿子
 
int built_tree( int left, int right )
{
    int node = tot++;
    if ( left<right ) {
        L[node] = built_tree(left,mid);
        R[node] = built_tree(mid+1,right);
    }
    return node;
}
 
int update( int pre, int left, int right, int x )
{
    int node = tot++;
    L[node] = L[pre];  // 必须要加
    R[node] = R[pre];
    tree[node] = tree[pre] + 1;
    sumt[node] = sumt[pre] + b[x];
    if ( left<right ) {
        if ( x<=mid ) L[node] = update(L[pre],left,mid,x);
        else R[node] = update(R[pre],mid+1,right,x);
    }
    return node;
}
 
// 求l~r，第1大，2大，3大...k大的和
int query( int node1, int node2, int left, int right, int k )
{
    if ( left==right ) return b[left]*k;
    int rsum = tree[ R[node2] ] - tree[ R[node1] ];
    // 找第k大及其更大的和
    if ( rsum>=k ) {
        return query( R[node1], R[node2], mid+1, right, k );
    }
    else {
        int sumr = sumt[ R[node2] ] - sumt[ R[node1] ];
        return sumr+query( L[node1],L[node2],left,mid,k-rsum );
    }
}
 
signed main()
{
    sum[0] = 0;
    for ( int i=1; i<=100000; i++ ) sum[i]=i*i+sum[i-1];
    int listt;
    cin >> listt;
    while ( listt-- ) {
        tot = 0; // 主席树动态开点，从0开始
        memset(T,0,sizeof(T));memset(tree,0,sizeof(tree));
        memset(L,0,sizeof(L));memset(R,0,sizeof(R));
        cin >> n ;
        for ( int i=1; i<=n; i++ ) {
            scanf("%lld",&a[i]); b[i]=a[i];
        }
        sort(b+1,b+1+n);
        m = unique(b+1,b+1+n) - b - 1; // 离散化
        T[0] = built_tree(1,m);
        for ( int i=1; i<=n; i++ ) {
            a[i] = lower_bound(b+1,b+1+m,a[i]) - b;
            T[i] = update(T[i-1],1,m,a[i]);
        }
        cin>>q;
        while ( q-- ) {
            int l,r,k;
            scanf("%lld %lld %lld",&l,&r,&k);
            printf("%lld\n",query(T[l-1],T[r],1,m,k)+sum[r-l+1]);
        }
    }
 
    return 0;
}
/*
1
5
1 2 3 4 5
3
1 5 5
1 3 2
3 3 1
l r k 求l~r，第1大，2大，3大...k大的和
*/