静态主席树，动态主席树(一种可持久化线段树)

前置知识：

动态开点

study from：

静态主席树：https://blog.csdn.net/a1351937368/article/details/78884526

动态主席树：https://blog.csdn.net/WilliamSun0122/article/details/77885781

原理：

静态主席树

1~i和1~i+1的相似性

动态主席树

树状数组

记录变化

得到1~i的结果

时间上是两个log

第一个log为树状数组（k->k-lowbit(k)->...）

第二个log为每个数（k,k-lowbit(k),...）的线段树操作

静态主席树

https://www.luogu.org/problemnew/show/P3834

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <time.h>
#include <string>
#include <set>
#include <map>
#include <list>
#include <stack>
#include <queue>
#include <vector>
#include <bitset>
#include <ext/rope>
#include <algorithm>
#include <iostream>
using namespace std;
#define ll long long
#define minv 1e-6
#define inf 1e9
#define pi 3.1415926536
#define nl 2.7182818284
const ll mod=1e9+7;//998244353
const int maxn=2e5+10;

struct rec
{
    int a,b;
}f[maxn];

struct node
{
    int l,r,sum,number;
}tr[maxn*20];

int a[maxn],_index=0,value,tnum=0,result;
int be[maxn],v[maxn];

int cmp(rec a,rec b)
{
    return a.a<b.a;
}

void ini_build(int l,int r)
{
    tr[_index].sum=0;
    if (l==r)
    {
        tr[_index].l=0;
        tr[_index].r=0;
        tr[_index].number=++tnum;
    }
    else
    {
        int m=(l+r)>>1,cur=_index;
        tr[cur].l=++_index;
        ini_build(l,m);

        tr[cur].r=++_index;
        ini_build(m+1,r);
    }
}

void build(int l,int r,int pos)
{
    if (l==r)
    {
        tr[_index].l=0;
        tr[_index].r=0;
        tr[_index].sum=tr[pos].sum+1;   ///not 1
        tr[_index].number=tr[pos].number;
    }
    else
    {
        int m=(l+r)>>1,cur=_index;
        tr[cur].sum=tr[pos].sum+1;
        if (value<=m)
        {
            tr[cur].l=++_index;
            tr[cur].r=tr[pos].r;
            build(l,m,tr[pos].l);
        }
        else
        {
            tr[cur].l=tr[pos].l;
            tr[cur].r=++_index;
            build(m+1,r,tr[pos].r);
        }
        tr[cur].sum=tr[tr[cur].l].sum+tr[tr[cur].r].sum;
    }
}

void query(int _indexl,int _indexr,int z)
{
    if (tr[_indexl].l==0)
    {
        result=tr[_indexl].number;
        return;
    }
    if (tr[tr[_indexr].l].sum-tr[tr[_indexl].l].sum>=z)
        query(tr[_indexl].l,tr[_indexr].l,z);
    else
        query(tr[_indexl].r,tr[_indexr].r,z-tr[tr[_indexr].l].sum+tr[tr[_indexl].l].sum);
}

int main()
{
    int n,m,i,num,x,y,z;
    scanf("%d%d",&n,&m);
    for (i=1;i<=n;i++)
    {
        scanf("%d",&f[i].a);
        f[i].b=i;
    }
    sort(f+1,f+n+1,cmp);
    num=0;
    f[0].a=2e9;
    for (i=1;i<=n;i++)
    {
        if (f[i].a!=f[i-1].a)
        {
            num++;
            v[num]=f[i].a;
        }
        a[f[i].b]=num;
    }
    be[0]=++_index;
    ini_build(1,num);
    for (i=1;i<=n;i++)
    {
        be[i]=++_index;
        value=a[i];
        build(1,num,be[i-1]);
    }

    while (m--)
    {
        scanf("%d%d%d",&x,&y,&z);
        query(be[x-1],be[y],z);
        printf("%d
",v[result],m);
    }
    return 0;
}
/*
5 100
1 5 1 5 5
1 5 2
1 5 3
*/

动态主席树

P2617 Dynamic Rankings

数值离散化

#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;
#define ll long long

const double eps=1e-8;
const ll inf=1e9;
const ll mod=1e9+7;
const int maxn=1e5+10;
const int maxm=1e5+10;

/**
T*m*log(n)*log(value_range)
1*1e5*17*18=
**/

/**
离散化，减少范围
可减少空间，时间

1e9->1e5+1e5
log
30(actually slight larger)->18
**/

int maxv=1e5+1e5;

struct node
{
    int l,r,siz;
}f[(maxn+maxm)*17*20];
///17:log(n) 20:log(value_range)

int be[maxn],a[maxn],num[maxn],add[maxn],id;
///num: max log(n)*2

int in[maxm][3];
char in_mode[maxm][5];

struct rec
{
    int x,y;
    bool operator<(const rec &b) const
    {
        return x<b.x;
    }
}ls[maxn+maxm];
int value_rev[maxn+maxm];

void update(int ind,int l,int r,int x,int y)
{
    f[ind].siz+=y;
    if (l==r)   ///not l==x
        return;
    int m=(l+r)>>1;
    if (x<=m)
    {
        if (!f[ind].l)
        {
            f[ind].l=++id;
            f[id].l=f[id].r=f[id].siz=0;    ///init
        }
        update(f[ind].l,l,m,x,y);
    }
    else
    {
        if (!f[ind].r)
        {
            f[ind].r=++id;
            f[id].l=f[id].r=f[id].siz=0;    ///init
        }
        update(f[ind].r,m+1,r,x,y);
    }
}

int main()
{
    char mode[5];
    int t,n,m,i,j,k,pos,g,l,r,v,M,cnt_ls;
    t=1;
//    scanf("%d",&t);
    while (t--)
    {
//        memset(f,0,sizeof(f));  ///or each point initialize

        scanf("%d%d",&n,&m);
        for (i=1;i<=n;i++)
        {
            be[i]=i;
            f[i].l=f[i].r=f[i].siz=0;
        }
        id=n;

        for (i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            ls[i]={a[i],i};
        }
        cnt_ls=n;
        for (M=1;M<=m;M++)
        {
            scanf("%s",in_mode[M]);
            if (in_mode[M][0]=='Q')
                scanf("%d%d%d",&in[M][0],&in[M][1],&in[M][2]);
            else
            {
                scanf("%d%d",&in[M][0],&in[M][1]);
                ls[++cnt_ls]={in[M][1],n+M};
            }
        }

        sort(ls+1,ls+cnt_ls+1);
        pos=0;
        ls[0].x=ls[1].x-1;
        for (i=1;i<=cnt_ls;i++)
        {
            if (ls[i].x!=ls[i-1].x)
            {
                pos++;
                value_rev[pos]=ls[i].x;
            }
            if (ls[i].y<=n)
                a[ls[i].y]=pos;
            else
                in[ls[i].y-n][1]=pos;
        }

        for (i=1;i<=n;i++)
        {
//            scanf("%d",&a[i]);
            k=i;
            while (k<=n)
            {
                update(be[k],1,maxv,a[i],1);
                k+=k&-k;
            }
        }

        for (M=1;M<=m;M++)
//        while (m--)
        {
//            scanf("%s",mode);
            strcpy(mode,in_mode[M]);
            if (mode[0]=='Q')
            {
//                scanf("%d%d%d",&i,&j,&pos);
                i=in[M][0],j=in[M][1],pos=in[M][2];
                g=0;

                k=i-1;
                while (k)
                {
                    num[++g]=be[k];
                    add[g]=-1;
                    k-=k&-k;
                }

                k=j;
                while (k)
                {
                    num[++g]=be[k];
                    add[g]=1;
                    k-=k&-k;
                }

                l=1,r=maxv;///也可以设置叶子标志
                while (l!=r)
                {
                    v=0;
                    for (i=1;i<=g;i++)
                        v+=f[f[num[i]].l].siz*add[i];
                    if (v>=pos)
                    {
                        for (i=1;i<=g;i++)
                            num[i]=f[num[i]].l;
                        r=(l+r)>>1;
                    }
                    else
                    {
                        pos-=v;
                        for (i=1;i<=g;i++)
                            num[i]=f[num[i]].r;
                        l=((l+r)>>1)+1;
                    }
                }
                printf("%d
",value_rev[l]);
            }
            else
            {
//                scanf("%d%d",&i,&j);
                i=in[M][0],j=in[M][1];

                k=i;
                while (k<=n)
                {
                    update(be[k],1,maxv,a[i],-1);
                    update(be[k],1,maxv,j,1);
                    k+=k&-k;
                }
                a[i]=j;
            }
        }
    }

    return 0;
}
/*
1
5 13
100000000 100000000 100000000 100000000 100000000
Q 1 5 1
Q 1 5 2
Q 1 5 3
Q 1 5 4
Q 1 5 5
C 3 10123445
Q 1 5 1
Q 1 5 2
Q 1 5 3
Q 1 5 4
Q 1 5 5
Q 2 2 1
Q 3 3 1
*/

不离散化，TLE了

==============================

不同的数据范围

http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=2112

使用上述方法，会超空间

空间优化：

读入a[1]~a[n]，

使用静态主席树的方式建树

n[5e4]*log(value_range)[18]

然后对于每个询问（与之前一样）

m[1e4]*2[修改数字，删除原来，增加现在]*log(n)[16]*log(value_range)[18]

即使优化了，然而还是会超空间的，感觉数据不严谨。