模板汇总1.1_数据结构1

1.并查集(Set Union)

#include<cstdio>
#include<algorithm>
using namespace std;
const int N=10005;
int n,m,t1,t2,t3;
int aset[N],siz[N];
int find(int x)
{
    return (aset[x]==x)?x:aset[x]=find(aset[x]);
}
int main ()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        aset[i]=i,siz[i]=1;
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&t1,&t2,&t3);
        if(t1==1)
        {
            int f1=find(t2),f2=find(t3);
            if(siz[f1]<siz[f2]) swap(f1,f2);
            siz[f1]+=siz[f2],aset[f2]=f1;
        }
        else if(t1==2)
            printf("%c\n",find(t2)==find(t3)?'Y':'N');
    }
    return 0;
}

 

·按秩合并单次操作$O(\log n)$，路径压缩单次操作$O(\log_{1+m/n} n)$，路径压缩+按秩合并单次操作$O(α(m,n))$

Tarjan的论文

2.树状树组(Binary Indexed Tree)

·前缀和思想

·lowbit

顾名思义(low-bit)，$lowbit$是一个数的二进制表示中最末的“$1$”(及其之后的“$0$”)所表示的数。

如何求一个数的$lowbit$？利用二进制补码的原理可知

int lowbit(int x)
{
     return x&-x;      
}

Why lowbit？

树状数组是这样存储原数组元素的↓

C1=A1
C2=A1+A2
C3=A3
C4=A1+A2+A3+A4
C5=A5
C6=A5+A6
C7=A7
C8=A1+A2+A3+A4+A5+A6+A7+A8

我们将总区间以$lowbit$拆分为小区间，以$C[x]$保存原数列里区间$[x-lowbit(x)+1,x]$中所有数的和

·时间复杂度：单次查询&修改皆为 $O(log$ $n)$

·具体实现

#include<cstdio>
const int N=100005;
int bit[N],n,m,q,t1,t2;
void change(int pos,int num)
{
    while(pos<=n)
        bit[pos]+=num,pos+=pos&-pos;
}
int query(int pos)
{
    int ret=0;
    while(pos)
        ret+=bit[pos],pos-=pos&-pos;
    return ret;
}
int main ()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%d",&rd),change(i,rd);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&q,&t1,&t2);
        if(q==1) change(t1,t2);
        else printf("%d\n",query(t2)-query(t1-1));
    }
}

·性质

引自李煜东的蓝书

将树状数组视作一个树形结构，它满足如下性质：

1.每个内部节点$C[n]$保存以它为根的子树的所有叶节点的和

2.每个内部节点$C[n]$的子节点数目等于$lowbit(n)$的位数

3.除去树的根(上图中的$C[8]$)，每个内部节点$C[n]$的父节点为$C[n+lowbit(n)]$

4.树的深度为$log$ $n$

3.线段树

·一棵二叉树，每个节点表示一段区间

·线段树的每个节点nde代表序列的一段区间[l,r]，左子节点nde*2代表[l,mid]，右子节点nde*2+1代表[mid+1,r]

·如何进行区间修改/查询？打标记+先拆后合并

如果当前节点代表的区间完全含于当前区间节点代表的区间，直接修改/查询节点并回溯，如果是修改就在这里打上标记

如果当前节点代表的区间完全不含于代表的区间，直接回溯

如果当前节点代表的区间不完全含于节点代表的区间，下放标记。拆开当前节点代表的区间，递归进入当前节点的两棵子树，最后合并答案。

·什么是标记，为什么要使用标记？

修改和查询的naive做法是，递归到叶节点后一级级修改，每次修改的时间复杂度为$O(nlog n)$，瞬间爆炸

打标记：每个节点带一个标记，记录这个区间还未执行的修改，在适当情况下才下放标记

在“完全包含”的情况下，修改数据时同时修改标记，在“不完全包含”的情况下对标记进行下放，时间复杂度$O(log n)$

总结和补充一下：线段树除了递归思想，有两个主要操作：更新(经常被称为$pushup$)和标记下放(经常被称为$pushdown$)。在建树和拆开区间进行修改时，我们通过更新操作维护节点信息，更新操作就是合并两个子节点的信息，一般和和有关的信息就是加起来，和最值有关的信息就是取一下最值，还有一些信息需要考虑左右两个儿子的信息。标记下放就是将根节点标记记录的信息“告知”子节点，具体操作和你“完全包含”时的操作是一样的，下放完后要清空根节点的标记

在建树中或者“拆区间”的更新结束后，你需要进行更新操作，在“拆区间”之前，你需要进行标记下放

一个需要注意的东西：如果线段树维护的几个信息在更新时互相（或者单向）依赖，要先更新依赖最大的。emmm比如说你维护区间和和区间平方和，更新时你要先更新区间平方和(因为$(a+b)^2=a^2+2ab+b^2$，假如你加上$b$要依赖原来的区间和更新$2ab$)

③线段树的时间复杂度与所需空间？

时间复杂度：查询&修改皆为 $O(log$ $n)$

所需空间：$4n$

④线段树的具体实现

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=100005;
long long num[N],maxx[4*N],val[4*N],laz1[4*N],laz2[4*N];
long long n,m,ask,x,y,k;
void create(int nde,int l,int r)//nde->当前节点，l->区间左端点，r->区间右端点
{
    laz2[nde]=1;//初始化加法懒惰标记为0,乘法懒惰标记为1
    if(l==r)//到达叶子级别，直接赋对应值
        val[nde]=maxx[nde]=num[l];
    else//向下建树
    {
        int mid=(l+r)/2,ls=2*nde,rs=2*nde+1;//区间中点,左右儿子 
        create(ls,l,mid),create(rs,mid+1,r);//建左右儿子
        val[nde]=val[ls]+val[rs],maxx[nde]=max(maxx[ls],maxx[rs]);
    }
}
void release(int nde,int l,int r)//标记下放
{
    int mid=(l+r)/2,ls=2*nde,rs=2*nde+1;
    if(laz2[nde]!=1)//如上所述，下放乘法标记
    {
        laz1[ls]*=laz1[nde],laz1[rs]*=laz1[nde];
        laz2[ls]*=laz2[nde],laz2[rs]*=laz2[nde];  
        val[ls]*=laz2[nde],val[rs]*=laz2[nde];  
        maxx[ls]*=laz2[nde],maxx[rs]*=laz2[nde];laz2[nde]=1;//下放结束，重置爸爸的乘法标记
    } 
    if(laz1[nde])//如上所述，下放加法标记
    {
        laz1[ls]+=laz1[nde],laz1[rs]+=laz1[nde];//儿子的标记直接加上爸爸的标记        
        val[ls]+=laz1[nde]*(mid-l+1),val[rs]+=laz1[nde]*(r-mid);//儿子的值和最值加上爸爸的标记与区间的乘积
        maxx[ls]+=laz1[nde],maxx[rs]+=laz1[nde];laz1[nde]=0;//下放结束，重置爸爸的加法标记
    }
}
long long vquery(int nde,int l,int r,int nl,int nr)//查询区间和操作，nl、nr分别为查询区间的左右端点
{
    if(l>nr||r<nl)//两个区间不重合
        return 0; 
    else if(l>=nl&&r<=nr)//待查询区间完全含于当前区间，返回当前节点值即可
        return val[nde];
    else//两个区间部分重合
    {
        release(nde,l,r);//下放当前节点标记，为在儿子里找答案做准备
        int mid=(l+r)/2,ls=2*nde,rs=2*nde+1;
        return vquery(ls,l,mid,nl,nr)+vquery(rs,mid+1,r,nl,nr);//在儿子里寻找
    }
}
long long mquery(int nde,int l,int r,int nl,int nr)//基本同上
{
    if(l>nr||r<nl)
        return 0; 
    else if(l>=nl&&r<=nr)
        return maxx[nde];
    else
    {
        release(nde,l,r);
        int mid=(l+r)/2,ls=2*nde,rs=2*nde+1;
        return max(mquery(ls,l,mid,nl,nr),mquery(rs,mid+1,r,nl,nr));
    }
}
void add(int nde,int l,int r,int nl,int nr,int task)//区间加，task->区间要修改的值
{
    if(l>nr||r<nl)
        return ;
    else if(l>=nl&&r<=nr)
        laz1[nde]+=task,maxx[nde]+=task,val[nde]+=task*(r-l+1);
    else
    {
        release(nde,l,r);       
        int mid=(l+r)/2,ls=2*nde,rs=2*nde+1;
        add(ls,l,mid,nl,nr,task),add(rs,mid+1,r,nl,nr,task);
        val[nde]=val[ls]+val[rs],maxx[nde]=max(maxx[ls],maxx[rs]);
    }
}
void mul(int nde,int l,int r,int nl,int nr,int task)
{
    if(l>nr||r<nl)
        return ;
     else if(l>=nl&&r<=nr)
        val[nde]*=task,maxx[nde]*=task,laz1[nde]*=task,laz2[nde]*=task;
    else
    {
        release(nde,l,r);
        int mid=(l+r)/2,ls=2*nde,rs=2*nde+1;
           mul(ls,l,mid,nl,nr,task),mul(rs,mid+1,r,nl,nr,task);
        val[nde]=val[ls]+val[rs],maxx[nde]=max(maxx[ls],maxx[rs]);
    }
}
int main()
{
    scanf("%lld%lld",&n,&m);
    for(int i=1;i<=n;i++)
        scanf("%lld",&num[i]);
    create(1,1,n);
    for(int i=1;i<=m;i++)
    {
        scanf("%lld",&ask);
        if(ask==1)
            scanf("%lld%lld%lld",&x,&y,&k),mul(1,1,n,x,y,k);
        else if(ask==2)
            scanf("%lld%lld%lld",&x,&y,&k),add(1,1,n,x,y,k);   
        else if(ask==3)
            scanf("%lld%lld",&x,&y),printf("%lld\n",vquery(1,1,n,x,y));
        else
            scanf("%lld%lld",&x,&y),printf("%lld\n",mquery(1,1,n,x,y));
    }
    return 0;
}

Upd on 2019.3.26 复习线段树扫描线

HDU1828 线段树扫描线模板题 注意是多组数据(沙茶的洛谷讨论，我居然信了。。。

#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=10005,M=80005;
int n,t1,t2,t3,t4,tot,lst,sum,ans;
int uni[N],val[M],len[M],cnt[M],lpt[M],rpt[M];
struct a
{
    int lp,rp,yp,tp;
}sca[N];
bool cmp(a x,a y)
{
    return x.yp==y.yp?x.tp<y.tp:x.yp<y.yp;
}
void Clean()
{
    tot=lst=sum=ans=0;
    memset(uni,0,sizeof uni);
    memset(val,0,sizeof val);
    memset(len,0,sizeof len);
    memset(cnt,0,sizeof cnt);
    memset(lpt,0,sizeof lpt);
    memset(rpt,0,sizeof rpt);
}
void Maintain(int nde,int l,int r)
{
    if(val[nde])
    {
        len[nde]=uni[r+1]-uni[l];
        lpt[nde]=rpt[nde]=cnt[nde]=1;
    }
    else
    {
        int ls=2*nde,rs=2*nde+1;
        len[nde]=len[ls]+len[rs];
        lpt[nde]=lpt[ls],rpt[nde]=rpt[rs];
        cnt[nde]=cnt[ls]+cnt[rs]-(rpt[ls]&&lpt[rs]);
    }
}
void Modify(int nde,int l,int r,int ll,int rr,int tsk)
{
    if(l>rr||r<ll)
        return;
    else if(l>=ll&&r<=rr)
        val[nde]+=tsk,Maintain(nde,l,r);
    else
    {
        int mid=(l+r)>>1,ls=2*nde,rs=2*nde+1;
        Modify(ls,l,mid,ll,rr,tsk);
        Modify(rs,mid+1,r,ll,rr,tsk);
        Maintain(nde,l,r);
    }
}
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        Clean();
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d%d",&t1,&t2,&t3,&t4);
            uni[++tot]=t1,sca[tot]=(a){t1,t3,t2,1};
            uni[++tot]=t3,sca[tot]=(a){t1,t3,t4,-1};
        }
        sort(uni+1,uni+1+tot);
        int lth=unique(uni+1,uni+1+tot)-uni-1;
        sort(sca+1,sca+1+tot,cmp);
        for(int i=1;i<=tot;i++)
        {
            int ll=lower_bound(uni+1,uni+1+lth,sca[i].lp)-uni;
            int rr=lower_bound(uni+1,uni+1+lth,sca[i].rp)-uni-1;
            if(ll<=rr) Modify(1,1,lth,ll,rr,sca[i].tp);
            ans+=abs(len[1]-lst)+(sca[i+1].yp-sca[i].yp)*cnt[1]*2,lst=len[1];
        }
        printf("%d\n",ans);
    }
    return 0;
}

TJOI2010污染的河流

线段树pushdown叶子，这人没救了

改改就行了，比上面那个简单

4.ST表

①ST表是啥

一种数据结构，利用了倍增、dp(和分治？)的思想，支持$O(1)$查询区间最值。

②ST表的原理

首先我们抓来一段数列，(对于一个学过高中必修一的人来说，他应该知道)一个长度为$n$的序列有$2^n$个子区间，我们由倍增的思想，规定$ST[i][j]$表示从第i个数起$2^j$个数中的最大值。显然$ST[i][0]=n[i]$。

由此我们开始递推，先计算总体范围：$logg=log(n)/log(2)+1$，其中$logg$是满足$2^{logg}>=n$的最小自然数。然后外层循环$j$从$1$到$logg-1$枚举各个幂，内层循环$i$从$1$到$n+1-2^j$枚举各个小区间，由此我们就枚举了所有的区间。接下来状态转移方程为：

$ST[i][j]=max(ST[i][j-1],ST[i+2^(j-1)][j-1])$

状态转移方程的意义如下：

我们把一个长度为$2^j$的区间拆成两个$2^{j-1}$的小区间，显然有

$ST[i][j]$->当前区间

$ST[i][j-1]$->左侧小区间

$ST[i+2^{(j-1)}][j-1]$->右侧小区间

自然简洁清晰明了(逃

对于查询，仍利用类似的思想，先计算一个$logg'=log$(区间长度)$/log(2)$，这样一来区间左端点开始的$2^{(logg'-1)}$个数和区间右端点结尾的$2^{(logg'-1)}$个数必定覆盖了整个区间，显然查询即

$max(ST[left][logg'],ST[right-(1<<logg')+1][logg'])$

③ST表的时间复杂度与所需空间？

时间复杂度：预处理为 $O(nlog$ $n)$，单次查询$O(1)$

所需空间：$nlog$ $n$

④ST表的代码实现

#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=100005;
int num[N],ST[N][18],n,m;
int main()
{
    int logg,left,right;
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&num[i]);
        ST[i][0]=num[i];
    }
    logg=log(n)/log(2)+1;
    for(int j=1;j<logg;j++)//枚举，预处理
        for(int i=1;i<=n-(1<<j)+1;i++)
            ST[i][j]=max(ST[i][j-1],ST[i+(1<<j-1)][j-1]);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&left,&right);
        logg=log(right-left+1)/log(2);
        printf("%d\n",max(ST[left][logg],ST[right-(1<<logg)+1][logg]));//查询
    }
    return 0;
}

 

https://www.researchgate.net/profile/Jan_Van_Leeuwen2/publication/220430653_Worst-case_Analysis_of_Set_Union_Algorithms/links/0a85e53cd28bfdf5eb000000/Worst-case-Analysis-of-Set-Union-Algorithms.pdf