线段树的代码模板（补充中）

简单的区间查询和点修改，代码来自hdoj 1166

#include <bits/stdc++.h>
using namespace std;
const int maxn=50001;
int segTree[4*maxn+1];//保存线段树
int mark[maxn],n;//mark为输入的数据
void build(int node,int beg,int e)//建树的过程
{
if(beg==e)
segTree[node]=mark[beg];
else
{
build(2*node,beg,(beg+e)/2);
build(2*node+1,(beg+e)/2+1,e);
//      segTree[node]=segTree[2*node]+segTree[2*node+1];求和
if(segTree[2*node]<=segTree[2*node+1])//求最小值
segTree[node]=segTree[2*node];
else
segTree[node]=segTree[2*node+1];
}
}

int query(int node,int beg,int e,int le,int ri)//区间查询beg和e分别为原来输入数据的区间，le和ri为线段树区间
{
int p1,p2;
if(le>e||ri<beg)
return 0;
if(beg>=le&&e<=ri)
return segTree[node];
p1=query(2*node,beg,(beg+e)/2,le,ri);
p2=query(2*node+1,(beg+e)/2+1,e,le,ri);
if(p1==-1)
return p2;
if(p2==-1)
return p1;
if(p1<=p2)
return p1;//最小值
//  return p2+p1;//求和
}
void add(int node,int beg,int e,int ind,int a)//把mark[ind]上的值增加a
{
if(beg==e)
{
//      cout<<beg<<" "<<node<<" "<<ind<<endl;
segTree[node]+=a;
return;
}
int m=(beg+e)/2;
if(ind<=m)
add(node*2,beg,m,ind,a);
else
add(node*2+1,m+1,e,ind,a);
//  segTree[node]=segTree[node*2]+segTree[node*2+1];求和
segTree[node]=min(segTree[node*2],segTree[node*2+1]);//最小值
}
void sub(int node,int beg,int e,int ind,int s)//把mark[ind]上的值减去s
{
if(beg==e)
{
segTree[node]-=s;
return;
}
int m=(beg+e)/2;
if(ind<=m)
sub(node*2,beg,m,ind,s);
else
sub(node*2+1,m+1,e,ind,s);
//  segTree[node]=segTree[node*2]+segTree[node*2+1];
segTree[node]=min(segTree[node*2],segTree[node*2+1]);
}
int main()
{
ios::sync_with_stdio(false);
int t,a,b,k=1;
cin>>t;
string s;
while(t--)
{
cout<<"Case "<<k++<<":"<<endl;
cin>>n;
for(int i=1;i<=n;i++)
cin>>mark[i];//输入值的过程
build(1,1,n);
while(true)
{
cin>>s;
if(s=="End")
break;
if(s=="Query")
{
cin>>a>>b;
cout<<query(1,1,n,a,b)<<endl;//查询过程
}
else
{
cin>>a>>b;
if(s=="Add")
add(1,1,n,a,b);
else
sub(1,1,n,a,b);
}
}
}
return 0;
}

延迟标记的区间更新方法，参考http://blog.csdn.net/u012860063/article/details/38322283

区间更新是指更新某个区间内的叶子节点的值，因为涉及到的叶子节点不止一个，而叶子节点会影响其相应的非叶父节点，那么回溯需要更新的非叶子节点也会有很多，如果一次性更新完，操作的时间复杂度肯定不是O(lgn)，例如当我们要更新区间[0,3]内的叶子节点时，需要更新除了叶子节点3,9外的所有其他节点。为此引入了线段树中的延迟标记概念，这也是线段树的精华所在。

延迟标记：每个节点新增加一个标记，记录这个节点是否进行了某种修改(这种修改操作会影响其子节点)，对于任意区间的修改，我们先按照区间查询的方式将其划分成线段树中的节点，然后修改这些节点的信息，并给这些节点标记上代表这种修改操作的标记。在修改和查询的时候，如果我们到了一个节点p，并且决定考虑其子节点，那么我们就要看节点p是否被标记，如果有，就要按照标记修改其子节点的信息，并且给子节点都标上相同的标记，同时消掉节点p的标记。

因此需要在线段树结构中加入延迟标记域，本文例子中我们加入标记与add，表示节点的子孙节点在原来的值的基础上加上add的值，同时还需要修改创建函数build()和 查询函数 query()，其中区间更新的函数为update();

void PushUp(int rt) //把当前结点的信息更新到父结点
{
sum[rt] = sum[rt<<1] + sum[rt<<1|1];
}
void PushDown(int rt,int len)//把当前结点的信息更新给儿子结点,len为分区间长度
{//对某一个区间进行改变，如果被标记了，在查询的时候就得把改变传给子节点，因为查询的并不一定是当前区间
if (add[rt])//已经标记过，该区间被改变过
{
//因为rt的儿子节点可能被多次延迟标记，并且rt的儿子节点的延迟标记没有向rt的孙子节点移动，所以用“+=”
add[rt<<1] += add[rt];
add[rt<<1|1] += add[rt];
/*此处用add[rt]乘以区间长度，不是add[rt<<1], 因为rt的儿子节点如果被

多次标记，之前被标记时， 就已经对sum[rt<<1]更新过了。 */
sum[rt<<1] += add[rt] * (len - (len >> 1));//更新左儿子的和
sum[rt<<1|1] += add[rt] * (len >> 1);//更新右儿子的和
add[rt] = 0;//将标记向儿子节点移动后，父节点的延迟标记去掉 ，传递后，当前节点标记域清空
}
}
void build(int l,int r,int rt)
{
add[rt] = 0;//初始化为所有结点未被标记
if (l == r)
{
scanf("%lld",&sum[rt]);
return ;
}
int mid = (l + r) >> 1;
build(lson);
build(rson);
PushUp(rt);
}
void update(int L,int R,int c,int l,int r,int rt)
{
if (L <= l && r <= R)
{
add[rt] += c;
sum[rt] += (LL)c * (r - l + 1);//更新代表某个区间的节点和，该节点不一定是叶子节点
return ;
}
/*当要对被延迟标记过的这段区间的儿子节点进行更新时，先要将延迟标记向儿子节

点移动 当然，如果一直没有对该段的儿子节点更新，延迟标记就不需要向儿子节点移动，这样就

使更新操作的时间复杂度仍为O（logn），也是使用延迟标记的原因。 */
PushDown(rt , r - l + 1);//----延迟标志域向下传递
int mid = (l + r) >> 1;
if (L <= mid)
update(L , R , c , lson);//更新左儿子
if (mid < R)
update(L , R , c , rson);//更新右儿子
PushUp(rt);//向上传递更新和
}
LL query(int L,int R,int l,int r,int rt)
{
if (L <= l && r <= R)
{
return sum[rt];
}//要取rt子节点的值时，也要先把rt的延迟标记向下移动
PushDown(rt , r - l + 1);
int mid = (l + r) >> 1;
LL ret = 0;
if (L <= mid)
ret += query(L , R , lson);
if (mid < R)
ret += query(L , R , rson);
return ret;
}

区间更新举例说明：当我们要对区间[0,2]的叶子节点增加2，利用区间查询的方法从根节点开始找到了非叶子节点[0-2]，把它的值设置为1+2 = 3，并且把它的延迟标记设置为2，更新完毕；当我们要查询区间[0,1]内的最小值时，查找到区间[0,2]时，发现它的标记不为0，并且还要向下搜索，因此要把标记向下传递，把节点[0-1]的值设置为2+2 = 4，标记设置为2，节点[2-2]的值设置为1+2 = 3，标记设置为2（其实叶子节点的标志是不起作用的，这里是为了操作的一致性），然后返回查询结果：[0-1]节点的值4；当我们再次更新区间[0,1]（增加3）时，查询到节点[0-1],发现它的标记值为2，因此把它的标记值设置为2+3 = 5，节点的值设置为4+3 = 7；

其实当区间更新的区间左右值相等时（[i,i]），就相当于单节点更新，单节点更新只是区间更新的特例。