线段树的学习之：如何用线段树计算矩形面积

    线段树是一种灵活的具有区间管理功能的数据结构，其用途跨越离散和线性思想！

我们最常用到的线段树就是区间求和：

1. /* 
2.  * InterverTree.cpp 
3.  * 
4.  *  Created on: 2012-11-1 
5.  *      Author: Administrator 
6.  */ 
7. #include<stdio.h> 
8. #define M 100 
9. #define Mid(a,b) ((a)+(b))>>1 
10. int a[11]={0,1,2,3,4,5,6,7,8,9,10}; 
11. struct Tree{ 
12.     int left,right; 
13.     int key,sum; 
14. }tree[M]; 
15. /* 
16.  * 建树 
17.  * */ 
18. void build(int id,int left,int right){ 
19.     tree[id].left=left; 
20.     tree[id].right=right; 
21.     if(left==right){ 
22.         tree[id].sum=tree[id].key=a[left]; 
23.         return; 
24.     } 
25.     int mid=Mid(left,right); 
26.     build(id*2,left,mid); 
27.     build(id*2+1,mid+1,right); 
28.     tree[id].sum=tree[id*2].sum+tree[id*2+1].sum; 
29. } 
30. /* 
31.  * 更新点 
32.  * */ 
33. void update(int id,int pos,int key){ 
34.     if(tree[id].left==tree[id].right){ 
35.         tree[id].sum=tree[id].key=key; 
36.         return ; 
37.     } 
38.     int mid=Mid(tree[id].left,tree[id].right); 
39.  
40.     pos<=mid?update(id*2,pos,key):update(id*2+1,pos,key); 
41.  
42.     tree[id].sum=tree[id*2].sum+tree[id*2+1].sum; 
43. } 
44. /* 
45.  * 查询区间 
46.  * */ 
47. int query(int id,int left,int right){ 
48.     if(tree[id].left==left&&tree[id].right==right){ 
49.         return tree[id].sum; 
50.     } 
51.     int mid=Mid(tree[id].left,tree[id].right); 
52.  
53.     if(right<=mid){ 
54.         return query(id*2,left,right); 
55.     }else if(left>mid){ 
56.         return query(id*2+1,left,right); 
57.     }else{ 
58.         return query(id*2,left,mid)+query(id*2+1,mid+1,right); 
59.     } 
60. } 
61. int main(){ 
62.     build(1,1,10);//利用a数组中的元素建树 ，0号元素不用 
63.     int ans=query(1,1,5);//查询区间[1,5]元素的和 
64.     printf("sum=%d\n",ans); 
65.     update(1,5,0);//更新5号位置的点的值 
66.     ans=query(1,1,10); 
67.     printf("sum=%d\n",ans); 
68.     return 0; 
69. } 

    像上面这样是最最基础的线段树，典型的用空间换时间的做法！而且线段树也继承了树形数据结构一惯的特点：把查询复杂度从O(n)降低到log(n)。

    但是通常用线段树，我们不会用得这么直白，会加一些技巧，比如懒操作！懒操作通常用在什么地方呢？比如更新区间！更新区间的时候，我们一般不会直接去傻呼呼地去更新每一个点，而是把需要更新的区间先记录起来，然后如果要用到区间的子区间的时候，我们才去真正更新！

1. /* 
2.  * InterverTree.cpp 
3.  * 
4.  *  Created on: 2012-11-1 
5.  *      Author: Administrator 
6.  */ 
7. #include<stdio.h> 
8. #define M 100 
9. #define Mid(a,b) ((a)+(b))>>1 
10. int a[11]={0,1,2,3,4,5,6,7,8,9,10}; 
11. struct Tree{ 
12.     int left,right; 
13.     int sum,add; 
14. }tree[M]; 
15. /* 
16.  * 建树 
17.  * */ 
18. void build(int id,int left,int right){ 
19.     tree[id].left=left; 
20.     tree[id].right=right; 
21.     if(left==right){ 
22.         tree[id].sum=a[left]; 
23.         tree[id].add=0; 
24.         return; 
25.     } 
26.     int mid=Mid(left,right); 
27.     build(id*2,left,mid); 
28.     build(id*2+1,mid+1,right); 
29.     tree[id].sum=tree[id*2].sum+tree[id*2+1].sum; 
30. } 
31.  
32. void push_down(int id){ 
33.     if(tree[id].add>0){ 
34.         tree[id].sum+=(tree[id].right-tree[id].left+1)*tree[id].add; 
35.         if(tree[id].left<tree[id].right){//非叶子结点 
36.             tree[id*2].add+=tree[id].add; 
37.             tree[id*2+1].add+=tree[id].add; 
38.         } 
39.         tree[id].add=0; 
40.     } 
41. } 
42. /* 
43.  * 更新点 
44.  * */ 
45. void update(int id,int pos,int key){ 
46.     push_down(id); 
47.     if(tree[id].left==tree[id].right){ 
48.         tree[id].sum=key; 
49.         return ; 
50.     } 
51.     int mid=Mid(tree[id].left,tree[id].right); 
52.  
53.     pos<=mid?update(id*2,pos,key):update(id*2+1,pos,key); 
54.  
55.     tree[id].sum=tree[id*2].sum+tree[id*2+1].sum; 
56. } 
57. /* 
58.  * 更新区间：把区间[left,right]同时增加key 
59.  * */ 
60. void update_add(int id,int left,int right,int key){ 
61.     push_down(id); 
62.     if(tree[id].left==left&&tree[id].right==right){//找到操作区间了 
63.         tree[id].add=key; 
64.         return; 
65.     } 
66.     int mid=Mid(tree[id].left,tree[id].right); 
67.     if(right<=mid){ 
68.         update_add(id*2,left,right,key); 
69.     }else if(left>mid){ 
70.         update_add(id*2+1,left,right,key); 
71.     }else{ 
72.         update_add(id*2,left,mid,key); 
73.         update_add(id*2+1,mid+1,right,key); 
74.     } 
75. } 
76. /* 
77.  * 查询区间 
78.  * */ 
79. int query(int id,int left,int right){ 
80.     push_down(id); 
81.     if(tree[id].left==left&&tree[id].right==right){ 
82.         return tree[id].sum; 
83.     } 
84.     int mid=Mid(tree[id].left,tree[id].right); 
85.     if(right<=mid){ 
86.         return query(id*2,left,right); 
87.     }else if(left>mid){ 
88.         return query(id*2+1,left,right); 
89.     }else{ 
90.         return query(id*2,left,mid)+query(id*2+1,mid+1,right); 
91.     } 
92. } 
93. int main(){ 
94.     build(1,1,10);//利用a数组中的元素建树 ，0号元素不用 
95.     int ans=query(1,1,5);//查询区间[1,5]元素的和 
96.     printf("sum=%d\n",ans); 
97.     update(1,6,10); 
98.     //懒操作 
99.     update_add(1,1,5,10); 
100.     ans=query(1,1,6); 
101.     printf("ans=%d\n",ans); 
102.     return 0; 
103. } 

    这也是线段树的基础操作，一般初学线段树容易进入一个误区，那就是线段树只能对数组进行操作，而且线段树建树也一定是build(id*2,left,mid),build(id*2+1，mid+1,right); 如果这样来理解线段树的话，就大错特错了！

   线段树是一种数据结构，而数据结构是我们生活中现实的事物极度抽象的结晶！我们要做的就是学习分析事物，透过现象看本质。这一点说起来很容易，做起来却极难！

虽然难，但是我们还是要做！那就是线段树在几何上的应用。说得更直接一点：

我们怎么把一条线段用线段树来表示！比如线段[1,5]怎么用线段树来表示：还是像前面建树那样：[1,1] [2,2] [3,3] [4,4] [5,5]? 那是行不通嘀!

我们这样建树：[1,2][2,3][3,4][4,5]，这里面就涉及到一个元线段的概念！

    而且如果线段的长度很大，或者线段是浮点型数据，那么我们就需要对线段进行离散化！ 离散化的方法也很简单！比如有三条线段：1.1-2.2   3.3-5.5  8.8-1000.1 我们就可以用一个长度为6的数组存储起来。然后用下标加key的方式来建树(后面的源代码中会展示出来）。这样的话，一条线段就离散化出来了！

    思路分析出来后，可以用一道题来加深一下领悟：线段树水题poj1151

参考博客：http://blog.csdn.net/tsaid/article/details/6706893

 

1. #include<stdio.h> 
2. #include<algorithm> 
3. using namespace std; 
4. #define M 1000 
5. #define eps 1e-8 
6. struct Tree{ 
7.     int ll,rr,cover;//这里的cover之所以用int而不用bool是因为可能出现多条边重叠 
8.     double lf,rf; 
9.     double len; 
10. }tree[4*M]; 
11. struct Line{ 
12.     double x,y1,y2; 
13.     int flag; 
14. }line[M]; 
15. double y[M];//用来离散化y坐标轴 
16. int cmp_double(const double &d1,const double &d2){ 
17.     double d=d1-d2; 
18.     if(d>eps)//d1>d2 
19.         return 1; 
20.     else if(d<-eps)//d1<d2 
21.         return -1; 
22.     else //d1==d2 
23.         return 0; 
24. } 
25. //比较函数 
26. bool cmp(const Line &l1,const Line &l2){//排序的比较函数 
27.         return l1.x<l2.x; 
28. } 
29. //建树 
30. void build(int id,int ll,int rr){ 
31.     tree[id].ll=ll;tree[id].rr=rr; 
32.     tree[id].lf=y[ll],tree[id].rf=y[rr]; 
33.     tree[id].len=tree[id].cover=0; 
34.     if(ll+1==rr)return;//如果已经是元线段，则不用拆分了 
35.     int mid=(ll+rr)>>1; 
36.     build(id*2,ll,mid); 
37.     build(id*2+1,mid,rr); 
38. } 
39. void lenght(int id){//求用于计算的线段实际长度 
40.     if(tree[id].cover>0){ 
41.         tree[id].len=tree[id].rf-tree[id].lf; 
42.     }else if(tree[id].ll+1==tree[id].rr){//元线段 
43.         tree[id].len=0; 
44.     }else 
45.         tree[id].len=tree[id*2].len+tree[id*2+1].len; 
46. } 
47. //更新树 
48. void update(int id,Line line){ 
49.     if(cmp_double(tree[id].lf,line.y1)==0&&cmp_double(tree[id].rf,line.y2)==0){ 
50.         tree[id].cover+=line.flag; 
51.         lenght(id); 
52.         return; 
53.         //这里的比较有点特别，值得关注一下， 
54.         // 由于是浮点型的数据，所以不能直接用mid来比较 
55.  
56.     }else if(cmp_double(line.y1,tree[2*id+1].lf)>=0){//用右孩子的左边界来比较 
57.         update(id*2+1,line); 
58.     }else if(cmp_double(line.y2,tree[id*2].rf)<=0){// 左孩子的右边界来比较 
59.         update(id*2,line); 
60.     }else{//分跨两个边界 
61.         Line tmp; 
62.         tmp=line;tmp.y2=tree[id*2].rf; 
63.         update(2*id,tmp); 
64.         tmp=line;tmp.y1=tree[id*2+1].lf; 
65.         update(2*id+1,tmp); 
66.     } 
67.     lenght(id);//回溯的时候 修改，使根结点的len实时更新 
68. } 
69. int main(){ 
70.     int n; 
71.     int i,t,ti=0; 
72.     while(scanf("%d",&n)&&n){ 
73.         double x1,y1,x2,y2; 
74.         for(t=i=1;i<=n;i++){ 
75.             scanf("%lf %lf %lf %lf",&x1,&y1,&x2,&y2); 
76.             line[t].x=x1; 
77.             line[t].y1=y1; 
78.             line[t].y2=y2; 
79.             line[t].flag=1; 
80.             y[t]=y1; 
81.             t++; 
82.             line[t].x=x2; 
83.             line[t].y1=y1; 
84.             line[t].y2=y2; 
85.             line[t].flag=-1; 
86.             y[t]=y2; 
87.             t++; 
88.         } 
89.         sort(line+1,line+t,cmp); 
90.         sort(y+1,y+t);//线段的离散化 
91.  
92.         build(1,1,t-1); 
93.         update ( 1, line[1] );//第一条边一定是入边 
94.         double ans=0.00; 
95.         for(i=2;i<t;i++){ 
96.             ans+=tree[1].len*(line[i].x-line[i-1].x); 
97.             update(1,line[i]);//最后一条边肯定是出边，不用考虑 
98.         } 
99.         printf("Test case #%d\n",++ti); 
100.         printf("Total explored area: %.2lf\n\n",ans); 
101.  
102.     } 
103.     return 0; 
104. } 

       此外，矩形分割也可以求解矩形面积相关的题！