线段树

先摆模板。。。

//线段树模板
struct line
{

int left,right;//左端点、右端点
int n;//记录这条线段出现了多少次，默认为0
};
struct line a[100];
int sum;
//建立
void build(int s,int t,int n)
{

int mid=(s+t)/2;
a[n].left=s;
a[n].right=t;
if (s==t) return;
a[n].left=s;
a[n].right=t; 
build(s,mid,2*n);
build(mid+1,t,2*n+1);
} 
//插入
void insert(int s,int t,int step)//要插入的线段的左端点和右端点、以及当前线段树中的某条线段
{     if (s==a[step].left && t==a[step].right)
      {
            a[step].n++;//插入的线段匹配则此条线段的记录+1
            return;//插入结束返回
      }
      if (a[step].left==a[step].right)   return;//当前线段树的线段没有儿子，插入结束返回
      int mid=(a[step].left+a[step].right)/2;
      if (mid>=t)    insert(s,t,step*2);//如果中点在t的右边，则应该插入到左儿子
      else if (mid<s)    insert(s,t,step*2+1);//如果中点在s的左边，则应该插入到右儿子
      else//否则，中点一定在s和t之间，把待插线段分成两半分别插到左右儿子里面
      {
            insert(s,mid,step*2);
            insert(mid+1,t,step*2+1);
      }
}
//访问
void count (int s,int t,int step)
{   

 if (a[step].n!=0)

sum=sum+a[step].n*(t-s+1);
 if (a[step].left==a[step].right)

return;
     int mid=(a[step].left+a[step].right)/2;
     if (mid>=t)

count(s,t,step*2);
     else

 if (mid<s)

 count(s,t,step*2+1);
     else
     {
            count(s,mid,step*2);
            count(mid+1,t,step*2+1);
      }
}

下面来自某大牛解释：

线段树的定义

定义1 长度为1的线段称为元线段。

定义2 一棵树被成为线段树，当且仅当这棵树满足如下条件：

（1）    该树是一棵二叉树。

（2）    树中每一个结点都对应一条线段[a,b]。

（3）    树中结点是叶子结点当且仅当它所代表的线段是元线段。

（4）    树中非叶子结点都有左右两个子树，做子树树根对应线段[a , (a + b ) / 2]，右子树树根对应线段[( a + b ) / 2 , b]。

但是这种二叉树较为平衡，和静态二叉树一样，提前根据应用的部分建立好树形结构。针对性强，所以效率要高。一般来说，动态结构较为灵活，但是速度较慢；静态结构节省内存，速度较快。

              线段树的性质与时空复杂度简介

下面介绍线段树的两个性质（证明略）。

性质1 长度范围为[1,L]的一棵线段树的深度不超过log(L-1) + 1。

性质2 线段树把区间上的任意一条长度为L的线段都分成不超过2logL条线段。

空间复杂度 存储一棵线段树的空间复杂度一般为O（L）。

时间复杂度 对于插入线段、删除线段，查找元素，查找区间最值等操作，复杂度一般都是O（log L）。

线段树主要应用了平衡与分治的性质，所以基本时间复杂度都和log有关。我们在应用线段树解决问题的时候，应尽量在构造好线段树的时候，使每种操作在同一层面上操作的次数为O（1），这样能够维持整体的复杂度O（log L）。

例题：

在自然数，且所有的数不大于30000的范围内讨论一个问题：现在已知n条线段，把端点依次输入告诉你，然后有m个询问，每个询问输入一个点，要求这个点在多少条线段上出现过；

最基本的解法当然就是读一个点，就把所有线段比一下，看看在不在线段中；

每次询问都要把n条线段查一次，那么m次询问，就要运算m*n次，复杂度就是O(m*n)

这道题m和n都是30000，那么计算量达到了10^9；而计算机1秒的计算量大约是10^8的数量级，所以这种方法无论怎么优化都是超时

-----

因为n条线段是固定的，所以某种程度上说每次都把n条线段查一遍有大量的重复和浪费；

线段树就是可以解决这类问题的数据结构

举例说明：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次

在[0,7]区间上建立一棵满二叉树：（为了和已知线段区别，用【】表示线段树中的线段）

                                【0,7】
                         /                  \
                  【0,3】                      【4,7】
                  /      \                     /     \
             【0,1】     【2,3】          【4,5】      【6,7】
             /      \   /      \        /      \      /     \
        【0,0】【1,1】【2,2】 【3,3】【4,4】 【5,5】 【6,6】【7,7】

每个节点用结构体：

struct line
{
      int left,right;//左端点、右端点
      int n;//记录这条线段出现了多少次，默认为0
}a[16];

和堆类似，满二叉树的性质决定a[i]的左儿子是a[2*i]、右儿子是a[2*i+1];

然后对于已知的线段依次进行插入操作：

从树根开始调用递归函数insert

void insert(int s,int t,int step)//要插入的线段的左端点和右端点、以及当前线段树中的某条线段
{
      if (s==a[step].left && t==a[step].right)
      {
            a[step].n++;//插入的线段匹配则此条线段的记录+1
            return;//插入结束返回
      }
      if (a[step].left==a[step].right)   return;//当前线段树的线段没有儿子，插入结束返回
      int mid=(a[step].left+a[step].right)/2;
      if (mid>=t)    insert(s,t,step*2);//如果中点在t的右边，则应该插入到左儿子
      else if (mid<s)    insert(s,t,step*2+1);//如果中点在s的左边，则应该插入到右儿子
      else//否则，中点一定在s和t之间，把待插线段分成两半分别插到左右儿子里面
      {
            insert(s,mid,step*2);
            insert(mid+1,t,step*2+1);
      }
}

三条已知线段插入过程：

[2,5]

--[2,5]与【0,7】比较，分成两部分：[2,3]插到左儿子【0,3】，[4,5]插到右儿子【4,7】

--[2,3]与【0,3】比较，插到右儿子【2,3】；[4,5]和【4,7】比较，插到左儿子【4,5】

--[2,3]与【2,3】匹配，【2,3】记录+1；[4,5]与【4,5】匹配，【4,5】记录+1

[4,6]

--[4,6]与【0,7】比较，插到右儿子【4,7】

--[4,6]与【4,7】比较，分成两部分，[4,5]插到左儿子【4,5】；[6,6]插到右儿子【6,7】

--[4,5]与【4,5】匹配，【4,5】记录+1；[6,6]与【6,7】比较，插到左儿子【6,6】

--[6,6]与【6,6】匹配，【6,6】记录+1

[0,7]

--[0,7]与【0,7】匹配，【0,7】记录+1

插入过程结束，线段树上的记录如下（红色数字为每条线段的记录n）：

                      【0,7】
                                                    1
                               /                                            \
                     【0,3】                                           【4,7】
                         0                                                     0
                 /                 \                                     /                 \
       【0,1】                 【2,3】                【4,5】                【6,7】
            0                           1                          2                         0
          /    \                      /      \                     /     \                    /      \
【0,0】 【1,1】 【2,2】 【3,3】 【4,4】 【5,5】 【6,6】 【7,7】
     0            0            0            0            0            0           1           0

询问操作和插入操作类似，也是递归过程，略

2——依次把【0,7】 【0,3】 【2,3】【2,2】的记录n加起来，结果为2

4——依次把【0,7】 【4,7】 【4,5】【4,4】的记录n加起来，结果为3

7——依次把【0,7】 【4,7】 【6,7】【7,7】的记录n加起来，结果为1

不管是插入操作还是查询操作，每次操作的执行次数仅为树的深度——logN

建树有n次插入操作，n*logN，一次查询要logN，m次就是m*logN；总共复杂度O(n+m)*logN，这道题N不超过30000，logN约等于14，所以计算量在10^5～10^6之间，比普通方法快了1000倍；

线段树至少支持下列操作：

Insert(t,x）：将包含在区间 int 的元素 x 插入到树t中；

Delete(t,x）：从线段树 t 中删除元素 x；

Search(t,x）：返回一个指向树 t 中元素 x 的指针。

编辑本段基本结构

线段树是建立在线段的基础上，每个结点都代表了一条线段[a,b]。长度为1的线段称为元线段。非元线段都有两个子结点，左结点代表的线段为[a,(a + b) / 2]，右结点代表的线段为[((a + b) / 2）+1,b]。

右图就是一棵长度范围为[1,5]的线段树。

长度范围为[1,L] 的一棵线段树的深度为log (L) + 1。这个显然，而且存储一棵线段树的空间复杂度为O(L）。

线段树支持最基本的操作为插入和删除一条线段。下面以插入为例，详细叙述，删除类似。

将一条线段[a,b] 插入到代表线段[l,r]的结点p中，如果p不是元线段，那么令mid=（l+r）/2。如果b<mid，那么将线段[a,b] 也插入到p的左儿子结点中，如果a>mid，那么将线段[a,b] 也插入到p的右儿子结点中。

插入（删除）操作的时间复杂度为O (Log N）。

编辑本段实际应用

上面的都是些基本的线段树结构，但只有这些并不能做什么，就好比一个程序有输入没输出，根本没有任何用处。

最简单的应用就是记录线段有否被覆盖，并随时查询当前被覆盖线段的总长度。那么此时可以在结点结构中加入一个变量int count；代表当前结点代表的子树中被覆盖的线段长度和。这样就要在插入（删除）当中维护这个count值，于是当前的覆盖总值就是根节点的count值了。

另外也可以将count换成bool cover；支持查找一个结点或线段是否被覆盖。

实际上，通过在结点上记录不同的数据，线段树还可以完成很多不同的任务。例如，如果每次插入操作是在一条线段上每个位置均加k，而查询操作是计算一条线段上的总和，那么在结点上需要记录的值为sum。

这里会遇到一个问题：为了使所有sum值都保持正确，每一次插入操作可能要更新O(N）个sum值，从而使时间复杂度退化为O(N）。

解决方案是Lazy思想：对整个结点进行的操作，先在结点上做标记，而并非真正执行，直到根据查询操作的需要分成两部分。

根据Lazy思想，我们可以在不代表原线段的结点上增加一个值toadd，即为对这个结点，留待以后执行的插入操作k值的总和。对整个结点插入时，只更新sum和toadd值而不向下进行，这样时间复杂度可证明为O(logN）。

对一个toadd值为0的结点整个进行查询时，直接返回存储在其中的sum值；而若对toadd不为0的一部分进行查询，则要更新其左右子结点的sum值，然后把toadd值传递下去，再对这个查询本身，左右子结点分别递归下去。时间复杂度也是O(logN）。

补充几点说明：

（1）我采用静态方法构建线段树，即用数组来做，左子树为 2*i，右子树为 2*i+1。按照保守估计，数组空间一般开Ｎ*4，用到的空间实质上是Ｎ*2-1，但是考虑到中间会有一些空间没有使用，特别是最底层的。粗略地想，假设最底层只有最后两个空间有用到，那么这一层前面的空余空间就约为Ｎ*2了。所以Ｎ*4是足够的。

（2）这部分一般来说涉及到下面几个函数：pushUp（由下往上更新修改后的数据），build（初始化线段树），update（修改叶子结点的数据），query（查询区间数据）

（3）线段树本身并不保存当前区间具体是什么，而是由函数传递两个变量l, r 来记录当前的具体区间，这样做可节省大量空间开销，详细参见代码。

（4）前文已出现过的，后面不再重复，包括函数参数的说明。

题目：

hdu 1166 敌兵布阵

大意：敌人有N个营地，一开始知道每个营地的人数。

            接下来会询问四种命令：(1) Add i j，i 和 j 为正整数，表示第i个营地增加j个人（j不超过30）；
                                                        (2) Sub i j ，i 和 j 为正整数，表示第i个营地减少j个人（j不超过30）；
                                                        (3) Query i j , i 和 j 为正整数，i <= j，表示询问第i到第j个营地的总人数；
                                                        (4) End 表示结束，这条命令在每组数据最后出现。

            遇到Query则作出回答，遇到End则结束本次数据的询问。其他则修改相关营地的数据。（显然，Sub 可以归并到 Add 操作）

思路：

对于每一组数据，用build初始化线段树，每个结点保存区间[i, j]内的总人数。叶子结点即是每个营地的人数，这个由输入给出，对于内结点，则采取pushUp由下往上传递值。

对于Add 操作（包括Sub操作），可以用update来修改叶子结点的值，与build相似，内结点采取pushUp更新其值。

对于Query 操作，用query来查看区间的人数。对于没有在一个存储区间表示出来的空间，则采取同时向两边走，覆盖后返回其值的方式取值，详细见代码。

函数接口：

pushUp(int cur)      // cur 表示当前数组的实际下标。

build(int l, int r, int cur)     // [l, r] 表示当前数组存储的值的区间，即前面所说的由函数传入值表示。

update(int i, int val, int l, int r, int cur)     // i 表示需要更新值的数组实际下标，即线段树的相应的叶子结点，val 表示需要增加的值（对于Sub操作，主函数传入-val）。

query(int curL, int curR, int l, int r, int cur)    // [curL, curR] 表示需要查询的区间

代码如下：

[cpp] view plaincopy

1. #include<cstdio>  
2. using namespace std;  
3. const int MAX = 50000 + 10;         //数据范围  
4. int sum[MAX << 2];          //保存各个范围的sum值  
5. void pushUp(int cur){  
6.     //检查下层数据，更新当前的sum值  
7.     sum[cur] = sum[cur << 1] + sum[cur << 1 | 1];  
8. }  
9. void build(int l, int r, int cur){  
10.     //初始化线段树  
11.     if(l == r){  
12.         scanf("%d",&sum[cur]);  
13.         return;  
14.     }  
15.     int mid = (l + r) >> 1;  
16.     build(l, mid, cur << 1);  
17.     build(mid + 1, r, cur << 1 | 1);  
18.     //更新当前的sum  
19.     pushUp(cur);  
20. }  
21. void update(int i, int val, int l, int r, int cur){  
22.     //更新范围i的值，并向上传递sum  
23.     if(l == r){  
24.         sum[cur] += val;  
25.         return;  
26.     }  
27.     int mid = (l + r) >> 1;  
28.     if(i <= mid){  
29.         update(i, val, l, mid, cur << 1);  
30.     }  
31.     else{  
32.         update(i, val, mid+1, r, cur << 1 | 1);  
33.     }  
34.     //传递sum值  
35.     pushUp(cur);  
36. }  
37. int query(int curL, int curR, int l, int r, int cur){  
38.     //查询curL 至 curR 的 sum  
39.     if(curL <= l && curR >= r){  
40.         return sum[cur];  
41.     }  
42.     int mid = (l + r) >> 1;  
43.     int result = 0;  
44.     if(curL <= mid){  
45.         result += query(curL, curR, l, mid, cur << 1);  
46.     }  
47.     if(curR > mid){  
48.         result += query(curL, curR, mid+1, r, cur << 1 | 1);  
49.     }  
50.     return result;  
51. }  
52. int main(){  
53.     int k = 1;  //当前例子编号  
54.     int t;      //样例数  
55.     int n;      //营地数  
56.     scanf("%d",&t);  
57.     while(t--){  
58.         scanf("%d",&n);  
59.         build(1,n,1);  
60.         printf("Case %d:\n",k++);  
61.         char s[10];  
62.         int i,j;  
63.         while(scanf("%s",s) != EOF){  
64.             if(s[0] == 'E')break;  
65.             scanf("%d %d",&i, &j);  
66.             switch(s[0]){  
67.                 case 'A': update(i, j, 1, n, 1); break;  
68.                 case 'S': update(i, -j, 1, n, 1); break;  
69.                 case 'Q': printf("%d\n",query(i, j, 1, n, 1)); break;  
70.             }  
71.         }  
72.     }  
73.     return 0;  
74. }  

   建议把这几个典型题目看一遍.因为线段树太灵活了. http://blog.csdn.net/that163/article/details/8249482