数据结构小总结（成都磨子桥技工学校数据结构前12题）

[pixiv] https://www.pixiv.net/member_illust.php?mode=medium&illust_id=34352147
暑假的作业，颓颓的我总算是写完了

线段树

线段树是一个高级玩意，不仅可以求区间和，区间最大等等的简单问题，灵活运用还有好多变种。自从学了主席树，知道了null自环这种东西后，用在线段树上也是得心应手

c3

给一个长为N的数列，有M次操作，每次操作是以下两种之一：
（1）修改数列中的一个数
（2）求数列中某连续一段的和

赤裸裸的线段树

c4

给一个长为N的数列，有M次操作，每次操作时以下三种之一：
（1）修改数列中的一个数
（2）求数列中某连续一段所有数的两两乘积的和 mod 1000000007
（3）求数列中某连续一段所有相邻两数乘积的和 mod 1000000007

数据剧毒无比，有负数，取模就出问题了。对于区间维护答案，主要就是如何合并区间。操作3好合并，只要记录每个区间的头、尾的数，把左右儿子区间的和加起来，再加上中间两个数的乘积。关键是操作2，要是没有见识过这个脑筋急转弯，我可能一辈子都不会：

给出N个数， 每次可以合并两个数， 合并的代价是两个数的乘积， 合并得到的数是两个数的和。
问最后把所有数合并成一个数的最小代价。 求这个最小代价对10^9+7取模的结果。
N <= 5000000。

题解是：

显然无论怎么合并答案都是一样的， 任意两个数的乘积恰好会对答案贡献一次。
直接搞就好了

于是这道题的操作2就迎刃而解了
由于这道题坑很多，我就不放我wa掉的代码了
大神的AC代码

#include<iostream>#include<cstdio>#include<algorithm>using namespace std;const int maxn=100005;const int mod=1000000007;struct Node{    int s1,s2,s3;}node[maxn<<2];int a[maxn];int n,m;int slow_mult(int a,int p){    if(a<0)a=(a+(mod<<1))%mod;    if(p<0)p =(p+(mod<<1))%mod;    if(a<p)swap(a,p);    if(p==0)return 0;    if(p==1)return a%mod;    int tmp=slow_mult(a,p>>1);    if(p&1)return ((tmp<<1)%mod+a%mod)%mod;    else return (tmp<<1)%mod;}inline void update(int root,int l,int r){    node[root].s1=(node[root<<1].s1+node[root<<1|1].s1)%mod;    node[root].s2=(node[root<<1].s2+node[root<<1|1].s2)%mod;    int m=(l+r)>>1;    node[root].s3=((node[root<<1].s3+node[root<<1|1].s3)%mod+slow_mult(a[m],a[m+1]))%mod;}void build(int root,int l,int r){    if(l==r){        node[root].s1=a[l];        node[root].s2=slow_mult(a[l],a[r]);        node[root].s3=0;        return ;    }    int m=(l+r)>>1;    build(root<<1,l,m),build(root<<1|1,m+1,r);    update(root,l,r);}void modify(int root,int l,int r,int x,int val){    if(l==r){        node[root].s1=val;        node[root].s2=slow_mult(val , val);        node[root].s3=0;        a[x]=val;        return;    }    int m=(l+r)>>1;    if(x<=m)modify(root<<1,l,m,x,val);    else modify(root<<1|1,m+1,r,x,val);    update(root,l,r);}int query1(int root,int l,int r,int x,int y){    if(x<=l&&r<=y)return node[root].s1;    int m=(l+r)>>1,ret=0;    if(x<=m&&l<=y)ret+=query1(root<<1,l,m,x,y);    if(y>=m+1&&r>=x)ret+=query1(root<<1|1,m+1,r,x,y);    return ret % mod;}int query2(int root,int l,int r,int x,int y){    if(x<=l&&r<=y)return node[root].s2;    int m=(l+r)>>1,ret=0;    if(x<=m&&l<=y)ret+=query2(root<<1,l,m,x,y);    if(y>=m+1&&r>=x)ret+=query2(root<<1|1,m+1,r,x,y);    return ret % mod;}int query3(int root,int l,int r,int x,int y){    if(x<=l&&r<=y)return node[root].s3;    int m=(l+r)>>1,ret=0,flag=1;    if(x<=m&&l<=y)ret+=query3(root<<1,l,m,x,y),flag*=-1;    if(y>=m+1&&r>=x)ret+=query3(root<<1|1,m+1,r,x,y),flag*=-1;    if(flag^1)return ret%mod;    else return(ret%mod+slow_mult(a[m],a[m+1]))%mod;}void read(int &res){    int flag=1;static char ch;    while((ch=getchar())<'0'||ch>'9')if(ch=='-')flag=-1;res=ch-48;    while((ch=getchar())>='0'&&ch<='9')res=res*10+ch-48;res*=flag;}void reads(char &res){    static char ch;    while((ch=getchar())!='Q'&&ch!='M'&&ch!='A');res=ch;}int main(){    read(n),read(m);    for(int i=1;i<=n;i++)read(a[i]),a[i]%=mod;    build(1,1,n);    for(int i=1;i<=m;i++){        char cmd;        int x,y;        reads(cmd);read(x),read(y);        if(cmd=='M')modify(1,1,n,x,y%mod);        else if(cmd=='Q'){            int t1=query1(1,1,n,x,y);            int t2=query2(1,1,n,x,y);            t1=slow_mult(t1,t1);            int tmp=t1-t2;            if(tmp<0||tmp&1)tmp+=mod;            if(tmp&1)tmp+=mod;            printf("%d\n",(tmp>>1)%mod);        }else printf("%d\n",query3(1,1,n,x,y));    }    return 0;}

c5

给一个长为N的数列，有M次操作，每次操作是以下两种之一：
（1）将某连续一段同时改成一个数
（2）求数列中某连续一段的和

也是很基本的线段树

c6

给一个长为N的数列，有M次操作，每次操作是以下两种之一：
（1）修改数列中的一个数
（2）求数列中有多少个数比它前面的数都大

其实是裸的楼房重建，线段树代码见这里
然后听说这道题用分块也能过，为了练习练习，这次就用分块了

#include<cstdio>#include<cstring> #include<algorithm>#include<cmath>#include<vector> using namespace std;const int N=100000+5;const int B=400;const int oo=0x7fffffff;int n,m,hh[N];vector<int> a[B];int blk,pos[N];void getsort(int x){    int maxx=-oo;    a[x].clear();    for(int i=(x-1)*blk+1;i<=min(n,x*blk);i++){        if(hh[i]>maxx){            a[x].push_back(i);            maxx=hh[i];        }     }}void init(){    for(int i=1;i<=pos[n];i++){        getsort(i);    }}int erfen(int maxx,int x){    int le=1,ri=a[x].size();    while(le<ri){        int mid=(le+ri)>>1;        if(hh[a[x][mid-1]]<=maxx) le=mid+1;        else ri=mid;     }    if(hh[a[x][le-1]]<=maxx){        return 0;    }     return a[x].size()-le+1;}int query(){    int ans=0,maxx=-oo;    for(int i=1;i<=pos[n];i++){        ans+=erfen(maxx,i);        maxx=max(maxx,hh[a[i][a[i].size()-1]]);    }    return ans;}int main(){    scanf("%d%d",&n,&m);    blk=(int)sqrt((double)n);    for(int i=1;i<=n;i++){        scanf("%d",&hh[i]);        pos[i]=(i-1)/blk+1;    }     init();    while(m--){        char opt[2];        scanf("%s",opt);        if(opt[0]=='M'){            int x,y;            scanf("%d%d",&x,&y);            hh[x]=y;            getsort(pos[x]);        }        else{            printf("%d\n",query());        }    }    return 0;}

c7

给一个长为N的数列，有M次操作，每次操作是以下两种之一：
（1）修改数列中的一个数
（2）求数列中某个值出现了多少次

在做c8之前是没有想到用值域线段树的，以为会爆空间（int级别的），就偷了个懒，用map
如何处理值域线段树的空间问题，见c8

#include<cstdio> #include<cstring> #include<map> #include<algorithm> using namespace std;const int N=100000+5;map<int,int> mp;int a[N];int main(){    int n,m;    scanf("%d%d",&n,&m);    for(int i=1;i<=n;i++){        scanf("%d",&a[i]);        mp[a[i]]++;    }    while(m--){        char opt[2];        scanf("%s",opt);        if(opt[0]=='M'){            int x,y;            scanf("%d%d",&x,&y);            mp[a[x]]--;            mp[y]++;            a[x]=y;        }        else{            int x;            scanf("%d",&x);            printf("%d\n",mp[x]);        }    }    return 0;}

c8

给一个长为N的数列，有M次操作，每次操作是以下三种之一：
（1）插入一个数，若已存在则忽略
（2）删除一个数，若不存在则忽略
（3）求数列中任意两数之差绝对值的最小值

先不考虑空间问题，我一来就想到值域线段树。计算存在的数与最近的前后两数的差值的最小值。每个区间储存存在的最小数和最大数。合并时，左区间的ans，右区间的ans，左区间最大数和右区间的最小数的差，取min。
那么怎么处理空间大小问题呢？数据是2^31，但N,M的范围是10^5，也就是说最少都有2^31-10^5的数根本和此题无关，是浪费空间。其维护的值都是一样的，那么为什么不指向同一个空间呢？于是就把主席树里的null搬过来，不存在的值就由null代替
然后我猜数据里有负数，结果在划分区间是没注意向上还是向下取整的问题，结果T掉了，全部都加上正无穷就好了。之后又没开longlong，int加爆了。。。orz

#include<cstdio>#include<cstring>#include<algorithm>#define ll long longusing namespace std;const ll oo=2147483646;const ll N=100000+5;ll n,m;struct Node{    Node *ls,*rs;    ll ans,maxn,minn,cnt;}*root,*null,pool[N*80],*tail=pool;Node *newnode(){    Node *rt=++tail;    rt->ls=rt->rs=null;    rt->ans=oo;    rt->maxn=rt->minn=rt->cnt=0;    return rt;}void update(Node *nd){    nd->cnt=nd->ls->cnt+nd->rs->cnt;    nd->ans=oo;    if(nd->ls->cnt>1) nd->ans=min(nd->ans,nd->ls->ans);    if(nd->rs->cnt>1) nd->ans=min(nd->ans,nd->rs->ans);    if(nd->ls->cnt&&nd->rs->cnt) nd->ans=min(nd->ans,nd->rs->minn - nd->ls->maxn);    if(nd->rs->cnt) nd->maxn=nd->rs->maxn;    else nd->maxn=nd->ls->maxn;    if(nd->ls->cnt) nd->minn=nd->ls->minn;    else nd->minn=nd->rs->minn;}void insert(Node *&nd,ll le,ll ri,ll pos){    if(nd==null) nd=newnode();    if(le==ri){        nd->cnt=1;        nd->ans=oo;        nd->maxn=nd->minn=pos;        return;    }    ll mid=(le+ri)/2;    if(pos<=mid) insert(nd->ls,le,mid,pos);    else insert(nd->rs,mid+1,ri,pos);    update(nd);}void del(Node *&nd,ll le,ll ri,ll pos){    if(nd==null) return ;    if(le==ri){        nd->cnt=0;        nd->ans=nd->maxn=nd->minn=0;        return ;    }    ll mid=(le+ri)/2;    if(pos<=mid) del(nd->ls,le,mid,pos);    else del(nd->rs,mid+1,ri,pos);    update(nd);}int main(){    null=++tail;    null->ls=null->rs=null;    null->ans=null->minn=null->maxn=null->cnt=0;    root=null;    scanf("%lld%lld",&n,&m);    ll a;    for(ll i=1;i<=n;i++){        scanf("%lld",&a);        insert(root,0,oo+oo,a+oo);    }    while(m--){        char opt[2];        ll x;        scanf("%s",opt);        if(opt[0]=='I'){            scanf("%lld",&x);            insert(root,0,oo+oo,x+oo);        }        else if(opt[0]=='D'){            scanf("%lld",&x);            del(root,0,oo+oo,x+oo);        }        else {            if(root->cnt>1) printf("%lld\n",root->ans);            else printf("-1\n");        }    }}

c10

给一个长为N的数列，有M次操作，每次操作是以下两种之一：
（1）修改数列中的一个数
（2）求数列中第K小的值

第k大问题，想来都是线段树。由于每次要修改数据，离散化不太可能，那么就用上文提到的null来节省空间（哎呀我真是太机智了，自己yy出来的诶，也算是进步吧）

#include<cstdio>#include<cstring>#include<algorithm>#define ll long long using namespace std;const ll N=100000+5;const ll oo=2147483646;struct Node {    Node *ls,*rs;    ll cnt;}*root,*null,pool[N*80],*tail=pool;ll n,m,a[N];Node *newnode(){    Node *rt=++tail;    rt->ls=rt->rs=null;    rt->cnt=0;    return rt;}void modify(Node *&nd,ll le,ll ri,ll pos,ll val){    if(nd==null) nd=newnode();    if(le==ri){        nd->cnt+=val;        return ;    }    ll mid=(le+ri)>>1;    if(pos<=mid) modify(nd->ls,le,mid,pos,val);    else modify(nd->rs,mid+1,ri,pos,val);    nd->cnt=nd->ls->cnt+nd->rs->cnt;} ll query(Node *nd,ll le,ll ri,ll pos){    if(le==ri)        return le;    ll mid=(le+ri)>>1;    if(pos<=nd->ls->cnt) return query(nd->ls,le,mid,pos);    else return query(nd->rs,mid+1,ri,pos-nd->ls->cnt);}int main(){    null=++tail;    null->ls=null->rs=null;    null->cnt=0;    root=null;    scanf("%lld%lld",&n,&m);    for(ll i=1;i<=n;i++){        scanf("%lld",&a[i]);        modify(root,0,oo+oo,a[i]+oo,1);    }    while(m--){        char opt[2];        scanf("%s",opt);        if(opt[0]=='Q'){            ll x;            scanf("%lld",&x);            printf("%lld\n",query(root,0,oo+oo,x)-oo);        }        else {            ll x,y;            scanf("%lld%lld",&x,&y);            modify(root,0,oo+oo,a[x]+oo,-1);            modify(root,0,oo+oo,y+oo,1);            a[x]=y;        }    }    return 0;}

总结：
线段树可腻害可腻害了，其实很多的区间问题都可以解决，唯一的关键点就是如何快速的区间合并。俗话说“以不变应万变”，只要解决区间合并的方法就可以了。

主席树

c2

给一个空数列，有M次操作，每次操作是以下三种之一：
（1）在数列后加一个数
（2）求数列中某位置的值
（3）撤销掉最后进行的若干次操作（1和3）

感觉像是数组，又感觉像是主席树。但是数组又不易用指针写，于是一气之下杀鸡用牛刀，用线段树来解决数列问题。。。1A

#include<cstdio> #include<cstring> #include<algorithm> using namespace std;const int N=100000+5;struct Node{    Node *ls,*rs;    int val;}*root[N],*null,pool[N*50],*tail=pool;int len[N],m;Node *newnode(){    Node *rt=++tail;    rt->ls=rt->rs=null;    rt->val=0;    return rt;}void insert(Node *np,Node *&nd,int le,int ri,int pos,int val){    nd=newnode();    nd->ls=np->ls,nd->rs=np->rs;    nd->val=np->val;    if(le==ri){        nd->val=val;        return ;    }    int mid=(le+ri)>>1;    if(pos<=mid) insert(np->ls,nd->ls,le,mid,pos,val);    else insert(nd->rs,nd->rs,mid+1,ri,pos,val);}int query(Node *nd,int le,int ri,int pos){    if(le==ri) return nd->val;    int mid=(le+ri)>>1;    if(pos<=mid) return query(nd->ls,le,mid,pos);    else return query(nd->rs,mid+1,ri,pos);}int main(){    null=++tail;    null->ls=null->rs=null;    null->val=0;    root[0]=null;    scanf("%d",&m);    int cnt=0;    while(m--){        char opt[2];        int x;        scanf("%s%d",opt,&x);        if(opt[0]=='A'){            cnt++;            len[cnt]=len[cnt-1]+1;            insert(root[cnt-1],root[cnt],1,N,len[cnt],x);        }        else if(opt[0]=='Q'){            printf("%d\n",query(root[cnt],1,N,x));        }        else{            cnt++;            root[cnt]=root[cnt-x-1];            len[cnt]=len[cnt-x-1];         }    }    return 0;}

c11

给一个长为N的数列，有M次操作，每次操作是以下两种之一：
（1）修改数列中的一个数
（2）求某次操作后连续一段的和

裸主席树，就当练手速吧

#include<cstdio>#include<cstring>#include<algorithm>using namespace std;const int N=100000+5;struct Node{    Node *ls,*rs;    int sum;}*root[N],*null,pool[N*80],*tail=pool;int n,m,a[N];Node *newnode(){    Node *rt=++tail;    rt->ls=rt->rs=null;    rt->sum=0;    return rt;}void build(Node *&nd,int le,int ri){    nd=newnode();    if(le==ri){        nd->sum=a[le];        return ;    }    int mid=(le+ri)>>1;    build(nd->ls,le,mid);    build(nd->rs,mid+1,ri);    nd->sum=nd->ls->sum+nd->rs->sum;}void insert(Node *ne,Node *&nd,int le,int ri,int pos,int val){    nd=newnode();    nd->ls=ne->ls,nd->rs=ne->rs;    if(le==ri){        nd->sum=val;        return ;    }    int mid=(le+ri)>>1;    if(pos<=mid) insert(ne->ls,nd->ls,le,mid,pos,val);    else insert(ne->rs,nd->rs,mid+1,ri,pos,val);    nd->sum=nd->ls->sum+nd->rs->sum;}int query(Node *nd,int le,int ri,int L,int R){    if(L<=le&&ri<=R) return nd->sum;    int mid=(le+ri)>>1,rt=0;    if(L<=mid) rt+=query(nd->ls,le,mid,L,R);    if(mid<R) rt+=query(nd->rs,mid+1,ri,L,R);    return rt;}int main(){    null=++tail;    null->ls=null->rs=null;    null->sum=0;    scanf("%d%d",&n,&m);    for(int i=1;i<=n;i++) scanf("%d",&a[i]);    build(root[0],1,n);    for(int i=1;i<=m;i++){        char opt[2];        scanf("%s",opt);        if(opt[0]=='M'){            int x,y;            scanf("%d%d",&x,&y);            insert(root[i-1],root[i],1,n,x,y);        }        else{            int x,y,z;            scanf("%d%d%d",&x,&y,&z);            printf("%d\n",query(root[z],1,n,x,y));            root[i]=root[i-1];        }    }    return 0;}

c12

给一个长为N的数列，有M次操作，操作仅有一种：
求数列中某连续一段中第K小的值

还是裸的主席树，没错我是来挂代码的

#include<cstdio>#include<cstring>#include<algorithm>#define ll long long using namespace std;const ll N=100000+5;const ll oo=2147483646;struct Node {    Node *ls,*rs;    ll cnt;}*root[N],*null,pool[N*100],*tail=pool;ll n,m,a[N];Node *newnode(){    Node *rt=++tail;    rt->ls=rt->rs=null;    rt->cnt=0;    return rt;}void insert(Node *ne,Node *&nd,ll le,ll ri,ll pos){    nd=newnode();    nd->ls=ne->ls,nd->rs=ne->rs;    nd->cnt=ne->cnt+1;    if(le==ri) return;    ll mid=(le+ri)>>1;    if(pos<=mid) insert(ne->ls,nd->ls,le,mid,pos);    else insert(ne->rs,nd->rs,mid+1,ri,pos);}ll query(Node *ne,Node *nd,ll le,ll ri,ll k){    if(le==ri) return le;    ll mid=(le+ri)>>1;    ll lsc=nd->ls->cnt - ne->ls->cnt;    if(k<=lsc) return query(ne->ls,nd->ls,le,mid,k);    else return query(ne->rs,nd->rs,mid+1,ri,k-lsc);}int main(){    null=++tail;    null->ls=null->rs=null;    null->cnt=0;    root[0]=null;    scanf("%lld%lld",&n,&m);    for(ll i=1;i<=n;i++){        scanf("%lld",&a[i]);        insert(root[i-1],root[i],0,oo+oo,a[i]+oo);    }    while(m--){        ll x,y,z;        scanf("%lld%lld%lld",&x,&y,&z);        printf("%lld\n",query(root[x-1],root[y],0,oo+oo,z)-oo);    }    return 0;}

数组

c0，c1
太简单啦，寒假做的

平衡树

c9

给一个长为N的数列，有M次操作，每次操作是以下两种之一：
（1）删除某个位置的数
（2）求数列某位置的值

一来就想到treap，但是感觉大材小用了，就偷了个懒

#include<cstdio>#include<cstring>#include<algorithm>#include<vector>using namespace std;vector<int> vec;int n,m;int main(){    scanf("%d%d",&n,&m);    for(int i=1;i<=n;i++){        int a;        scanf("%d",&a);        vec.push_back(a);    }    while(m--){        char opt[2];        int x;        scanf("%s%d",opt,&x);        x--;        if(opt[0]=='D')            vec.erase(vec.begin()+x);        else printf("%d\n",vec[x]);    }    return 0;}

好啦，就是这样