hihocoder上的这一篇文章写得特别赞！很好理解。

转载于：http://hihocoder.com/contest/hiho19/problem/1

“在我介绍别的算法之前，你先来讲一讲你是准备如何使用线段树来解决这个问题的吧？”小Hi虽然做好了讲解的准备，但是还是希望能够一步步引导小Ho进行思考，于是这般说道。

“唔……那我先从线段树的定义说起吧：线段树其实本质就是用一棵树来维护一段区间上和某个子区间相关的值——例如区间和、区间最大最小值一类的。”小Ho说道：“它的具体做法是这样的，这棵树的根节点表示了整段区间，根节点的左儿子节点表示了这段区间的前半部分，根节点的右儿子节点表示了这段区间的后半部分——并以此类推，对于这棵树的每个节点，如果这个节点所表示的区间的长度大于1，则令其左儿子节点表示这段区间的前半部分，令其右儿子表示这段区间的后半部分。以一段长度为10的区间为例，我所建立出的线段树应该是这样子的。”

“画的还凑合，但是这样一棵树有什么用呢？”小Hi明知故问道。

“就以RMQ问题为例吧——RMQ问题要求的是求解一段区间中的最小值，那么我不妨效仿ST算法，先对一些可能会用到的区间求解这个最小值！而既然我要是用线段树来解决这个问题的，那么我不妨就将每一个节点对应的区间中的最小值都求解出来。”小Ho道。

“那我给你这样一组数据，你将这个预处理的结果给我计算一下？”小Hi又出难题。

“好啊！你这数据正好也只有10个位置，那么我便直接用这棵树了。”只见小Ho刷刷两笔便在之前绘下的二叉树上写下了每个节点对应的区间中的最小值：“事实上这样一步相当好计算，由于每个非叶子节点所对应的区间都正好由它的两个儿子节点所对应的区间拼凑而成——那么只需要像ST那样，这样一个节点所对应的区间中的最小值便是它的两个儿子节点所对应的区间中的最小值中更小的那一个。这样我只需要O(N)的时间复杂度就可以计算出这棵树来。”

小Hi点了点头，继续问道：“我算是明白了，但是你这样一棵树统计出来的区间比ST算法统计出来的区间要少了很多，你还能够使用很快的算法进行查询么？更何况还有修改呢？”

小Ho笑了笑：“我先从简单的说起吧——修改，当某个位置的商品的重量发生改变的时候，对应的，就是这棵树的某个叶子节点的值发生了变化——但是和ST算法不同，包含这个节点的区间，便只有这个节点的所有祖先节点，而这样的节点数量事实上是很少的——只有O(log(N))级别。也就是说，当一次修改操作发生的时候，我只需要改变数量在O(log(N))级别的节点的值就可以完成操作了，修改的时间复杂度是O(log(N))。”

小Hi道：“是这样没错~算你过关！但是呢，还是像我之前所说的，你是准备如何使用数量在O(N)级别的区间来应付所有的询问呢？”

小Ho的笑容仍未退去：“这个其实也很简单！我要做的事情其实就是——将一个询问的区间拆成若干个我已经计算出来的区间（在ST算法中是拆成了2个的区间），这样对于这些区间已经计算出的最小值求最小值的话，我就可以知道询问的整个区间中的最小值是多少了！”

“那你准备如何分解询问的区间呢？”小Hi问道。

小Ho思索了一会，道：“这个问题其实很简单！我从线段树的根开始，对于当前访问的线段树节点t, 设其对应的区间为[A, B], 如果询问的区间[l, r]完全处于前半段或者后半段——即r <= (A + B)/2或者l > (A + B) / 2，那么递归进入t对应的子节点进行处理（因为另一棵子树中显然不会有任何区间需要用到）。否则的话，则把询问区间分成2部分[l, (A + B) / 2]和[(A + B) / 2 + 1, r]，并且分别进入t的左右子树处理这两段询问区间（因为2棵子树中显然都有区间需要用到）！当然了，如果[A, B]正好覆盖了[l, r]的话，就可以直接返回之前计算的t这棵子树中的最小值了。还是之前那个例子，如果我要询问[3, 9]这段区间，我的最终结果会是这样的——橙色部分标注的区间。”

“首先[3, 9]分解成了[3, 5]和[6, 9]两个区间，而[3, 5]分解成了[3, 3]和[4, 5]——均没有必要继续分解，[6, 9]分解成了[6, 8]和[9, 9]——同样也没有必要继续分解了。每一步的分解都是必要的，所以这已经是最好的分解方法了。”

小Hi满意的点了点头，道：“听起来还不错？但是你这样分解的话，区间的个数你能保证么？万一很多怎么办？”

小Ho思索了一会，接着道：“不会的，除了第一次分解成2个区间的操作可能会将区间个数翻倍外，之后每一次分解的时候所处理的区间都肯定有一条边是和当前节点对应的重合的（即l=A或者r=B），也就是说即使再进行分解，分解出的两个区间中也一定会有一个区间是不需要再进行分解的，也就是区间的总数是在深度这个级别的，所以也是O(logN)的。”

“看来你还挺清楚的，那么要不你再总结一下，我就算你过关，然后我们就可以开始讲解后面的问题了~”

小Ho道：“好的！首先我会根据初始数据，使用O(N)的时间构建一棵最原始的线段树，这个过程中我会使用子节点的值来计算父亲节点的值，从而避免冗余计算。然后对于每一次操作，如果是一次修改的话，我就将修改的节点和这个节点的所有祖先节点的值都进行更新，可以用O(logN)的时间复杂度完成。而如果是一次询问的话，我会使用上面描述的方法来对询问区间进行分解，这样虽然不像ST算法那样是O(1)，但是却实现了上一次所提到的‘平衡’，无论是修改还是查询的时间复杂度都是O(logN)的，所以我这个算法最终的时间复杂度会是O(N + Q * log(N))，在这个数据规模下是绰绰有余的！”

“嗯~ o(*￣▽￣*)o 不错哟~那么就到这里吧！”小Hi笑容满满道：“赶紧去吃早饭吧！”

对hdu 1166 经典题目敌兵布阵  （单点更新） 加了详细的解释 

题意为给定n个数的序列，编号1到n，提供三种操作  add p  x 把第p个数增加x， sub p x 把第p个数减去x， query l r, 查询从l到r个数的和（即区间[l,r]的和）.

#include <iostream>
#include <algorithm>
#include <stdio.h>
#include <string.h>
using namespace std;
const int maxn=50010;

struct SegTree
{
    int l,r;
    int sum;
}segTree[maxn<<2];

void Build(int i,int l,int r)
{
    segTree[i].l=l;
    segTree[i].r=r;
    int mid=(l+r)>>1;
    if(segTree[i].l==segTree[i].r)
    {
        scanf("%d",&segTree[i].sum);
        return;//千万别忘了这一句!!!
    }
    Build(i<<1,l,mid);
    Build((i<<1)|1,mid+1,r);
    segTree[i].sum=segTree[i<<1].sum+segTree[(i<<1)|1].sum;
}

void Add(int i,int p,int add)
{
    segTree[i].sum+=add;
    int l=segTree[i].l;
    int r=segTree[i].r;
    if(l==r)
        return;
    int mid=(l+r)>>1;

    //为什么这么写呢？修改某个点，只要修改该点以及包含该点的祖先节点就好了；
    //我们是从根节点开始相加的。那么最重要的任务就是判断根节点的左右孩子哪个包含所要修改的那个点，该点只存在于一个孩子中，因为
    //根节点的两个孩子所代表的区间是不相交的。所以我们要么去左孩子节点增加值，要么去右孩子节点增加值，怎么判断呢；对于根节点区间[L,R];
    //令mid=(L+R)/2; 其左孩子代表的区间为[L,mid],右孩子区间代表的是[mid+1,R],这样就很明显了，如果要修改的位置<=mid时，那我们肯定是要去左
    //孩子的，因为只有左孩子的区间才包括该点啊，相反如果>mid时，就只能去右孩子了。这里就是关键，所以增加的操作就是从根节点开始向下，不断拐弯
    //不断增加值，直到找到叶子节点为止。
    if(p<=mid)
        Add(i<<1,p,add);
    else
        Add((i<<1)|1,p,add);

}

int Sum(int i,int l,int r)
{
    //为什么这么写呢？该功能是查询区间[l,r]的和，我们称其为目标区间；
    //我们是从根节点开始查询的。
    //首先考虑的是到底是查询根节点本身，还是它的左孩子，还是它的右孩子呢，如果l,r正好是根节点所代表的区间，那么直接返回根节点的sum值就可以了
    //如果不是的话，就要考虑到左右孩子去了，设根节点区间[L,R]，令mid=(L+R)/2,则左孩子区间为[L,mid],右孩子区间为[mid+1,R],怎样根据孩子区间去找目标区间呢
    //如果目标区间的r<=mid时，那么该目标区间一定存在左孩子中，如果目标区间的l>mid时，那么目标区间一定存在右孩子中，如果mid在l,r之间时，那么我们就要
    //查询左右两个孩子。
    //注意，如果所建的树中当查询到某一个节点时，其节点代表的区间正好是该函数的参数时，那么查到该节点就直接返回其sum值即可，无需向下查询到叶子节点
    // 如果没有的话，那么就得查询到叶子节点，把叶子节点的sum值相加
     // if(segTree[i].l==segTree[i].r)//这一句写的大错特错!!!定要注意
     //   return segTree[i].sum;
    if(segTree[i].l==l&&segTree[i].r==r)
        return segTree[i].sum;
    int ans=0;
    int mid=((segTree[i].l+segTree[i].r)>>1);
    if(r<=mid)
        ans=Sum(i<<1,l,r);
    else if(l>mid)
        ans=Sum((i<<1)|1,l,r);
    else
        ans=Sum(i<<1,l,mid)+Sum((i<<1)|1,mid+1,r);
    return ans;
}


int main()
{
    char cm[10];
    int n;
    int t;scanf("%d",&t);
    int p,add,l,r;
    for(int cas=1;cas<=t;++cas)
    {
        printf("Case %d:\n",cas);
        scanf("%d",&n);
        Build(1,1,n);
        while(scanf("%s",cm))
        {
            if(cm[0]=='E')
                break;
            if(cm[0]=='A')
            {
                scanf("%d%d",&p,&add);
                Add(1,p,add);
            }
            else if(cm[0]=='S')
            {
                scanf("%d%d",&p,&add);
                Add(1,p,-add);
            }
            else
            {
                scanf("%d%d",&l,&r);
                printf("%d\n",Sum(1,l,r));
            }
        }
    }
    return 0;
}

[数据结构]线段树