线段树

线段树

线段树链接

typedef struct tree
{
    int summ;//和
	int lc,rc;//左右孩子的下标
    tree():summ(0),lc(0),rc(0){}
}Tree,*PTree;

//递归建树
//l,r代表线段的左右两边
//以i为根节点建树
void build(int i,int l,int r)//初始化build(1,1,n)
{
    tree[i].lc=l; tree[i].rc=r; 
    if(l==r)
    {//如果这个节点是叶子节点
        tree[i].summ=input[l];
        return;
    }
    int mid=(l+r)/2;
    build(2*i,l,mid);
    build(2*i+1,mid+1,r);
    tree[i].summ=tree[2*i].summ+tree[2*i+1].summ;
}

单点修改,区间查询

单点修改,区间查询

线段树的查询方法:
如果这个区间被完全包括在待查区间,直接返回这个区间的值
如果这个区间的左孩子和待查区间有交集,搜索左孩子
如果这个区间的右孩子和待查区间有交集,搜索右孩子

//查询代码,求[l,r]区间和
int search(int i,int l,int r)//i是当前所在的节点
{//l和r是目标区间
    if(tree[i].lc>=l&&tree[i].rc<=r)return tree[i].summ;
    //完全包含
    
    if(tree[i].rc<l||tree[i].lc>r)return 0;
    //不包含
    
    int res=0;
    if(tree[2*i].rc>=l)res+=search(2*i,l,r);
    //左孩子和目标区间有交集,搜索左孩子
    if(tree[i*2+1].lc<=r)res+=search(i*2+1,l,r);
    //右孩子和目标区间有交集,搜索右孩子
    return res;
}

//单点修改(增加)
void add(int i,int pos,int k)//k是要增加的值,pos是要增加值的目标位置
{//i是当前节点所在位置
    if(tree[i].lc==tree[i].rc)
    {//如果是叶子节点,找到这个值了
        tree[i].summ+=k;return;
    }
    //如果在左边
    if(pos<=tree[2*i].rc)add(2*i,pos,k);
    //在右边
    else add(2*i+1,pos,k);
    tree[i].summ=tree[i*2].summ+tree[2*i+1].summ;
    return;
}

区间修改,单点查询

如果这个区间被完全包括在目标区间,这个区间标记K
如果和左区间有交集,搜索左子树
如果和右区间有交集,搜索右子树

typedef struct tree
{
    int summ;//和
	int lc,rc;//左右孩子的下标
    int lz;//lazy_tag
     tree():summ(0),lc(0),rc(0),lz(0){}
}Tree,*PTree;

1、如果当前区间被完全覆盖在目标区间里，讲这个区间的sum+k*(tree[i].r-tree[i].l+1)

2、如果没有完全覆盖，则先下传懒标记

3、如果这个区间的左儿子和目标区间有交集，那么搜索左儿子

4、如果这个区间的右儿子和目标区间有交集，那么搜索右儿子

//区间修改
//线段树在进行区间更新的时候，为了提高更新的效率，所以每次更新只更新到更新区间完全覆盖线段树结点区间为止，这样就会导致被更新结点的子孙结点的区间得不到需要更新的信息，所以在被更新结点上打上一个标记，称为lazy-tag，等到下次访问这个结点的子结点时再将这个标记传递给子结点，所以也可以叫延迟标记。
void add(int i,int l,int r,int k)//区间l<=x<=r的值全部加上k
{
    if(tree[i].lc>=l&&tree[i].rc<=r)
    {
        tree[i].summ+=k*(tree[i].rc-tree[i].lc+1);
        tree[i].lz+=k; return;
    }
    if(tree[i].rc<l||tree[i].lc>r)return;
    //该区间没有被完全覆盖,先下传标记
    pushDown(i);//向下传递
    if(tree[2*i].rc>=l)add(2*i,l,r,k);
    if(tree[2*i+1].lc<=r)add(2*i+1,l,r,k);
    tree[i].summ=tree[2*i].summ+tree[2*i+1].summ;
    return;
}

//pushDown
void pushDown(int i)
{
    if(tree[i].lz==0)return;
    tree[2*i].lz+=tree[i].lz; tree[2*i+1].lz+=tree[i].lz;//左右孩子加上父亲的标记
    int mid=(tree[i].lc+tree[i].rc)/2;
    tree[2*i].summ+=tree[i].lz*(/*tree[2*i].rc*/mid-tree[2*i].lc+1);
    tree[2*i+1].summ+=tree[i].lz*(tree[2*i+1].rc-mid);
    tree[i].lz=0;//父亲的lz归零
}

//单点查询
//查询的时候一样要把pushDown加进去
int search(int i,int l,int r)
{
    if(tree[i].lc>=l&&tree[i].rc<=r)//如果被完全包含
    {
        return tree[i].summ;
    }
    if(tree[i].rc<l||tree[i].lc>r)return 0;
    pushDown(i);
    int res=0;
    if(tree[i*2].rc>=l)
    {
        res+=search(2*i,l,r);
    }
    if(tree[i*2+1].lc<=r)
    {
        res+=search(2*i+1,l,r);
    }
    return res;
}

乘法(根号线段树)(???)

只有乘法,将上述lazy_tag改成*就好了如果我们是又加又乘，那就不一样了。
当lazytage下标传递的时候，我们需要考虑，是先加再乘还是先乘再加。我们只需要对lazytage做这样一个处理。
lazytage分为两种，分别是加法的plz和乘法的mlz

typedef struct tree
{
    int summ;//和
	int lc,rc;//左右孩子的下标
    int mlz,plz;//lazy_tag
    
     tree():summ(0),lc(0),rc(0),mlz(1),plz(0){}
}Tree,*PTree;

//乘法和加法的pushDown
void pushDown(__int64 i)
{
    __int64 k1=tree[i].mlz,k2=tree[i].plz; 
    __int64 sit1=i<<1,sit2=i<<1|1;
    //左孩子节点先乘后加
    tree[sit1].summ=tree[sit1].summ*k1+k2*(treep[sit1].rc-tree[sit1].lc+1)%p;/%p
    //右孩子节点先乘后加
    tree[sit2].summ=(tree[sit2].summ*k1+k2*(tree[sit2].rc-tree[sit2].lc+1))%p;
    //更改左孩子的lazytag
    tree[sit1].mlz=(tree[sit1].mlz*k1)%p;
    //更改右孩子的lazytag
    tree[sit2].mlz=(tree[sit2].mlz*k1)%p;
    //更改左孩子的lazytag,plus
    tree[sit1].plz=(tree[sit1].plz*k1+k2)%p;
    //更改右孩子的lazytag,plus
    tree[sit2].plz=(tree[sit2].plz*k1+k2)%p;
    //更改本节点的plz和mlz
    tree[i].plz=0;
    tree[i].mlz=1;
    return ;
}

根号线段树