程序博客网 > sql isnull用法

线段树

来源：互联网 发布：sql isnull用法 编辑：程序博客网 时间：2024/05/22 16:52


最主要的是，下面的两个模板，一个是求区间和，一个求区间最小值


转载：http://blog.csdn.net/metalseed/article/details/8039326 

转载： http://blog.csdn.net/ruangongshi/article/details/47376965



线段树


一：线段树基本概念

1：概述

线段树，类似区间树，是一个完全二叉树，它在各个节点保存一条线段（数组中的一段子数组），主要用于高效解决连续区间的动态查询问题，由于二叉结构的特性，它基本能保持每个操作的复杂度为O(lgN)!

性质：父亲的区间是[a,b],(c=(a+b)/2)左儿子的区间是[a,c]，右儿子的区间是[c+1,b]，线段树需要的空间为数组大小的四倍


2：基本操作（demo用的是查询区间最小值）

线段树的主要操作有：

(1)：线段树的构造 void build(int node, int begin, int end);

主要思想是递归构造，如果当前节点记录的区间只有一个值，则直接赋值，否则递归构造左右子树，最后回溯的时候给当前节点赋值

  1. #include <iostream>  
  2. using namespace std;  
  3.   
  4. const int maxind = 256;  
  5. int segTree[maxind * 4 + 10];  
  6. int array[maxind];   
  7. /* 构造函数，得到线段树 */  
  8. void build(int node, int begin, int end)    
  9. {    
  10.     if (begin == end)    
  11.         segTree[node] = array[begin]; /* 只有一个元素,节点记录该单元素 */  
  12.     else    
  13.     {     
  14.         /* 递归构造左右子树 */   
  15.         build(2*node, begin, (begin+end)/2);    
  16.         build(2*node+1, (begin+end)/2+1, end);   
  17.            
  18.         /* 回溯时得到当前node节点的线段信息 */    
  19.         if (segTree[2 * node] <= segTree[2 * node + 1])    
  20.             segTree[node] = segTree[2 * node];    
  21.         else    
  22.             segTree[node] = segTree[2 * node + 1];    
  23.     }    
  24. }  
  25.   
  26. int main()  
  27. {  
  28.     array[0] = 1, array[1] = 2,array[2] = 2, array[3] = 4, array[4] = 1, array[5] = 3;  
  29.     build(1, 0, 5);  
  30.     for(int i = 1; i<=20; ++i)  
  31.      cout<< "seg"<< i << "=" <<segTree[i] <<endl;  
  32.     return 0;  
  33. }   
 此build构造成的树如图：

(2)：区间查询int query(int node, int begin, int end, int left, int right);

（其中node为当前查询节点，begin,end为当前节点存储的区间，left,right为此次query所要查询的区间）

主要思想是把所要查询的区间[a,b]划分为线段树上的节点，然后将这些节点代表的区间合并起来得到所需信息

比如前面一个图中所示的树，如果询问区间是[0,2]，或者询问的区间是[3,3]，不难直接找到对应的节点回答这一问题。但并不是所有的提问都这么容易回答，比如[0,3]，就没有哪一个节点记录了这个区间的最小值。当然，解决方法也不难找到：把[0,2]和[3,3]两个区间（它们在整数意义上是相连的两个区间）的最小值“合并”起来，也就是求这两个最小值的最小值，就能求出[0,3]范围的最小值。同理，对于其他询问的区间，也都可以找到若干个相连的区间，合并后可以得到询问的区间。

  1. int query(int node, int begin, int end, int left, int right)    
  2. {   
  3.     int p1, p2;    
  4.     
  5.     /*  查询区间和要求的区间没有交集  */  
  6.     if (left > end || right < begin)    
  7.         return -1;    
  8.     
  9.     /*  if the current interval is included in  */    
  10.     /*  the query interval return segTree[node]  */  
  11.     if (begin >= left && end <= right)    
  12.         return segTree[node];    
  13.     
  14.     /*  compute the minimum position in the  */  
  15.     /*  left and right part of the interval  */   
  16.     p1 = query(2 * node, begin, (begin + end) / 2, left, right);   
  17.     p2 = query(2 * node + 1, (begin + end) / 2 + 1, end, left, right);    
  18.     
  19.     /*  return the expect value  */   
  20.     if (p1 == -1)    
  21.         return p2;    
  22.     if (p2 == -1)    
  23.         return p1;    
  24.     if (p1 <= p2)    
  25.         return  p1;    
  26.     return  p2;      
  27. }   

可见，这样的过程一定选出了尽量少的区间，它们相连后正好涵盖了整个[left,right]，没有重复也没有遗漏。同时，考虑到线段树上每层的节点最多会被选取2个，一共选取的节点数也是O(log n)的，因此查询的时间复杂度也是O(log n)。

线段树并不适合所有区间查询情况，它的使用条件是“相邻的区间的信息可以被合并成两个区间的并区间的信息”。即问题是可以被分解解决的。



(3)：区间或节点的更新 及 线段树的动态维护update （这是线段树核心价值所在，节点中的标记域可以解决N多种问题）

动态维护需要用到标记域，延迟标记等。

a:单节点更新

  1. void Updata(int node, int begin, int end, int ind, int add)/*单节点更新*/    
  2. {    
  3.     
  4.     if( begin == end )    
  5.     {    
  6.         segTree[node] += add;    
  7.         return ;    
  8.     }    
  9.     int m = ( left + right ) >> 1;    
  10.     if(ind <= m)    
  11.         Updata(node * 2,left, m, ind, add);    
  12.     else    
  13.         Updata(node * 2 + 1, m + 1, right, ind, add);    
  14.     /*回溯更新父节点*/    
  15.     segTree[node] = min(segTree[node * 2], segTree[node * 2 + 1]);     
  16.          
  17. }   

b：区间更新（线段树中最有用的）

需要用到延迟标记，每个结点新增加一个标记，记录这个结点是否被进行了某种修改操作(这种修改操作会影响其子结点)。对于任意区间的修改，我们先按照查询的方式将其划分成线段树中的结点，然后修改这些结点的信息，并给这些结点标上代表这种修改操作的标记。在修改和查询的时候，如果我们到了一个结点p，并且决定考虑其子结点，那么我们就要看看结点p有没有标记，如果有，就要按照标记修改其子结点的信息，并且给子结点都标上相同的标记，同时消掉p的标记。（优点在于，不用将区间内的所有值都暴力更新，大大提高效率，因此区间更新是最优用的操作）

void Change来自dongxicheng.org

  1. void Change(node *p, int a, int b) /* 当前考察结点为p，修改区间为(a,b]*/  
  2.    
  3. {  
  4.    
  5.   if (a <= p->Left && p->Right <= b)  
  6.    
  7.   /* 如果当前结点的区间包含在修改区间内*/  
  8.    
  9.   {  
  10.    
  11.      ...... /* 修改当前结点的信息，并标上标记*/  
  12.    
  13.      return;  
  14.    
  15.   }  
  16.    
  17.   Push_Down(p); /* 把当前结点的标记向下传递*/  
  18.    
  19.   int mid = (p->Left + p->Right) / 2; /* 计算左右子结点的分隔点 
  20.   
  21.   if (a < mid) Change(p->Lch, a, b); /* 和左孩子有交集，考察左子结点*/  
  22.    
  23.   if (b > mid) Change(p->Rch, a, b); /* 和右孩子有交集，考察右子结点*/  
  24.    
  25.   Update(p); /* 维护当前结点的信息（因为其子结点的信息可能有更改）*/  
  26.    
  27. }  



3:主要应用

(1)：区间最值查询问题 （见模板1）

(2)：连续区间修改或者单节点更新的动态查询问题 （见模板2）

(3)：多维空间的动态查询 （见模板3）


二：典型模板

模板1：

RMQ，查询区间最值下标---min

  1. #include<iostream>    
  2.   
  3. using namespace std;    
  4.     
  5. #define MAXN 100    
  6. #define MAXIND 256 //线段树节点个数    
  7.     
  8. //构建线段树,目的:得到M数组.    
  9. void build(int node, int b, int e, int M[], int A[])    
  10. {    
  11.     if (b == e)    
  12.         M[node] = b; //只有一个元素,只有一个下标    
  13.     else    
  14.     {     
  15.         build(2 * node, b, (b + e) / 2, M, A);    
  16.         build(2 * node + 1, (b + e) / 2 + 1, e, M, A);    
  17.   
  18.         if (A[M[2 * node]] <= A[M[2 * node + 1]])    
  19.             M[node] = M[2 * node];    
  20.         else    
  21.             M[node] = M[2 * node + 1];    
  22.     }    
  23. }    
  24.     
  25. //找出区间 [i, j] 上的最小值的索引    
  26. int query(int node, int b, int e, int M[], int A[], int i, int j)    
  27. {    
  28.     int p1, p2;    
  29.     
  30.     //查询区间和要求的区间没有交集    
  31.     if (i > e || j < b)    
  32.         return -1;    
  33.   
  34.     if (b >= i && e <= j)    
  35.         return M[node];    
  36.    
  37.     p1 = query(2 * node, b, (b + e) / 2, M, A, i, j);    
  38.     p2 = query(2 * node + 1, (b + e) / 2 + 1, e, M, A, i, j);    
  39.     
  40.     //return the position where the overall    
  41.     //minimum is    
  42.     if (p1 == -1)    
  43.         return M[node] = p2;    
  44.     if (p2 == -1)    
  45.         return M[node] = p1;    
  46.     if (A[p1] <= A[p2])    
  47.         return M[node] = p1;    
  48.     return M[node] = p2;    
  49.     
  50. }    
  51.     
  52.     
  53. int main()    
  54. {    
  55.     int M[MAXIND]; //下标1起才有意义,否则不是二叉树,保存下标编号节点对应区间最小值的下标.    
  56.     memset(M,-1,sizeof(M));    
  57.     int a[]={3,4,5,7,2,1,0,3,4,5};    
  58.     build(1, 0, sizeof(a)/sizeof(a[0])-1, M, a);    
  59.     cout<<query(1, 0, sizeof(a)/sizeof(a[0])-1, M, a, 0, 5)<<endl;    
  60.     return 0;    
  61. }    



模板2：

连续区间修改或者单节点更新的动态查询问题 （此模板查询区间和）

  1. #include <cstdio>    
  2. #include <algorithm>    
  3. using namespace std;    
  4.      
  5. #define lson l , m , rt << 1    
  6. #define rson m + 1 , r , rt << 1 | 1   
  7. #define root 1 , N , 1   
  8. #define LL long long    
  9. const int maxn = 111111;    
  10. LL add[maxn<<2];    
  11. LL sum[maxn<<2];    
  12. void PushUp(int rt) {    
  13.     sum[rt] = sum[rt<<1] + sum[rt<<1|1];    
  14. }    
  15. void PushDown(int rt,int m) {    
  16.     if (add[rt]) {    
  17.         add[rt<<1] += add[rt];    
  18.         add[rt<<1|1] += add[rt];    
  19.         sum[rt<<1] += add[rt] * (m - (m >> 1));    
  20.         sum[rt<<1|1] += add[rt] * (m >> 1);    
  21.         add[rt] = 0;    
  22.     }    
  23. }    
  24. void build(int l,int r,int rt) {    
  25.     add[rt] = 0;    
  26.     if (l == r) {    
  27.         scanf("%lld",&sum[rt]);    
  28.         return ;    
  29.     }    
  30.     int m = (l + r) >> 1;    
  31.     build(lson);    
  32.     build(rson);    
  33.     PushUp(rt);    
  34. }    
  35. void update(int L,int R,int c,int l,int r,int rt) {    
  36.     if (L <= l && r <= R) {    
  37.         add[rt] += c;    
  38.         sum[rt] += (LL)c * (r - l + 1);    
  39.         return ;    
  40.     }    
  41.     PushDown(rt , r - l + 1);    
  42.     int m = (l + r) >> 1;    
  43.     if (L <= m) update(L , R , c , lson);    
  44.     if (m < R) update(L , R , c , rson);    
  45.     PushUp(rt);    
  46. }    
  47. LL query(int L,int R,int l,int r,int rt) {    
  48.     if (L <= l && r <= R) {    
  49.         return sum[rt];    
  50.     }    
  51.     PushDown(rt , r - l + 1);    
  52.     int m = (l + r) >> 1;    
  53.     LL ret = 0;    
  54.     if (L <= m) ret += query(L , R , lson);    
  55.     if (m < R) ret += query(L , R , rson);    
  56.     return ret;    
  57. }    
  58. int main() {    
  59.     int N , Q;    
  60.     scanf("%d%d",&N,&Q);    
  61.     build(root);    
  62.     while (Q --) {    
  63.         char op[2];    
  64.         int a , b , c;    
  65.         scanf("%s",op);    
  66.         if (op[0] == 'Q') {    
  67.             scanf("%d%d",&a,&b);    
  68.             printf("%lld\n",query(a , b ,root));    
  69.         } else {    
  70.             scanf("%d%d%d",&a,&b,&c);    
  71.             update(a , b , c , root);    
  72.         }    
  73.     }    
  74.     return 0;    
  75. }    


线段树之区间更新

   线段树系列上一篇文章讲了基础的线段树的建树，单点更新，区间查询。那这篇文章主要讲线段树的区间更新，也就是延迟更新。其实延迟更新的本质和单点更新差不多，只不过差别在于单点更新每次都递归到底，但是区间更新则是做一个延迟标记，等到下次更新或查询的时候再去判断是不是往下更新。

    为什么这样？答案是显然的。线段树的查询和单点更新的时间复杂度是O(logn)的，如果我每次都只是更新一个节点，再去询问，那么复杂度是O(nlogn),这个复杂度是可以接受的，但是如果每次操作我都是更新一个区间，还是用单点更新去做，那么复杂度是O(n^2logn)，这个复杂度是很大的，一般来说，在ACM竞赛中是很难接受的或者说是直接摒弃的。所以我们要想办法去降低复杂度。于是我们就有了区间更新。

    以下我们以给某个区间增加x为例讲解：

    假设我要更新区间[a,b],那我开始由根节点开始递归查找区间，如果发现区间[l,r]完全包含在区间[a,b]里，我就在这停止，不在继续更新下去，并在这个节点做标记记录x，并更新这个节点的sum值。如果下次查询的时候，碰见标记就开始更新左右儿子，并把自己的标记消除，给儿子做标记，以此类推，直到找到符合查找的区间为止。

     这样为什么会快，当节点数很多的时候，如果我每次都把整个操作区间更新到底就会很浪费时间，通过标记，我可以更新到某一层就停止，不必更新到底，这样当然就很节省时间了。

    我们就以这个题意编写代码讲解：

    题意：在一组数中执行两种操作：

      (1) "C a b c" means adding c to each of Aa, Aa+1, ... , Ab. -10000 ≤ c ≤ 10000.

      (2)"Q a b" means querying the sum of Aa, Aa+1, ... , Ab.

[cpp] view plain copy
  1. const int maxn=10005;//假设点的个数  
  2. struct seg_tree//为线段树定义一个结构体  
  3. {  
  4.     int sum,seg;//sum表示区间和，seg作为标记  
  5. }tree[4*maxn];  
  6.   
  7. //更新父亲节点操作  
  8. void pushup(int root)  
  9. {  
  10.     tree[root].sum=tree[root<<1].sum+tree[root<<1|1].sum;  
  11.     return ;  
  12. }  
  13.   
  14. //更新左右儿子操作  
  15. void pushdown(int root,int l,int r)  
  16. {  
  17.     int mid=(l+r)>>1;  
  18.     //更新左儿子  
  19.     tree[root<<1].seg+=tree[root].seg;  
  20.     tree[root<<1].sum+=(mid-l+1)*tree[root].seg;  
  21.     //更新右儿子  
  22.     tree[root<<1|1].seg+=tree[root].seg;  
  23.     tree[root<<1|1].sum+=(r-(mid+1)+1)*tree[root].seg;  
  24.     //消除父亲节点的标记  
  25.     tree[root].seg=0;  
  26.   
  27.     return ;  
  28. }  
  29.   
  30. //建树操作  
  31. void build_tree(int root,int r,int l)  
  32. {  
  33.     tree[root].seg=0;  
  34.   
  35.     if(l==r)  
  36.     {  
  37.         tree[root].sum=A[l];  
  38.         return ;  
  39.     }  
  40.   
  41.     int mid=(r+l)>>1;  
  42.   
  43.     build_tree(root<<1,l,mid);  
  44.     build_tree(root<<1|1,mid+1,r);  
  45.   
  46.     pushup(root);  
  47. }  
  48.   
  49. //更新操作  
  50. void update(int root,int l,int r,int L,int R,int val )//L,R表示更新的区间的端点，val表示要加的值  
  51. {  
  52.      if(L<=l&&r<=R) //如果被操作区间完全包含，就不用往下更新了  
  53.      {  
  54.          tree[root].sum+=(r-l+1)*val;  
  55.          tree[root].seg+=val;  
  56.          return ;  
  57.      }  
  58.   
  59.      if(tree[root].seg!=0)   {  pushdown(root,l,r);}//延迟更新  
  60.   
  61.      int mid=(r+l)>>1;  
  62.   
  63.      if(L<=mid)  
  64.         update(root<<1,l,mid,L,R,val);  
  65.      if(mid<R)  
  66.         update(root<<1|1,mid+1,r,L,R,val);  
  67.   
  68.      pushup(root);    
  69. }  
  70.   
  71. //查询操作  
  72. int query(int root,int l,int r,int L,int R)//L,R表示查询的区间的端点  
  73. {  
  74.      if(L<=l&&r<=R)  
  75.      {  
  76.          return tree[root].sum;  
  77.      }  
  78.   
  79.      if(tree[root].seg!=0)//如果有标记就需要往下更新  
  80.         pushdown(root,l,r);  
  81.   
  82.      int mid=(r+l)>>1,sum=0;  
  83.   
  84.      if(L<=mid)  
  85.          sum+=query(root<<1,l,mid,L,R);  
  86.      if(mid<R)  
  87.          sum+=query(root<<1|1,mid+1,r,L,R);  
  88.   
  89.      return sum;  
  90. }  


阅读全文
0 0
sql isnull用法 sql isnull用法
原创粉丝点击
热门IT博客
骑兵转步兵软件骑兵转步兵软件
简易数控折弯机编程简易数控折弯机编程
js获取指定子节点
数据运营招聘要求
吴志雄 古天乐 知乎
怎么在淘宝上抢红包
表演系的故事知乎
何为p2p网络借贷
上海游族网络怎么样
60知天命
人工智能小说
员工生日提醒软件
nexus 配置阿里云仓库
linux vi 搜索 下一个
java输出金字塔
ubuntu 14.04
windows微信聊天记录
网络销售香烟
单片机电子钟原理图
java中定义二维数组
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 六福珠宝珍珠 六福铂金价格 六福珠宝金镶玉吊坠 六福珠宝旗舰店 六福珠宝白金价格 六福珠宝钻石手镯 六福珠宝 对戒 六福珠宝工作服 六福珠宝 戒指 六福黄金多少钱一克 六福结婚对戒 六福珠宝品牌 六福珠宝男士手链 六福和周六福哪个好 六福今天金价 六福珠宝爱很美钻戒 六福珠宝价格查询 六福珠宝鉴定 六福珠宝18k金项链 六福珠宝和周六福哪个好 六福珠宝男士戒指 六福金价走势图 六福翡翠手镯 六福珠宝goldstyle系列 lukfook 周六福钻戒 珠宝店 六桂福 周六福 六桂福珠宝 约德尔人阵容 约德尔人 六约德尔人阵容 约德尔 六约德尔人 六约德尔 六约德尔人双龙 六约德尔人装备搭配 六约德尔人配什么 约德尔阵容 约德尔人配什么

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里