线段树
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和乘法的mlztypedef 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 ;
}
根号线段树
标签：lc,int,线段,tree,summ,rc,区间 来源： https://blog.csdn.net/shen253135371/article/details/96170384
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。