线段树

一：线段树基本概念

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

 

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

 

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

 

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

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

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

 


3:主要应用

 

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

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

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


二：典型模板

模板1：

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

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

 


模板2：

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

 

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

 

模板3：

多维空间的动态查询

 

原文地址：

http://blog.csdn.net/metalseed/article/details/8039326

另一总结（非常棒）

http://blog.csdn.net/shiqi_614/article/details/8228102

 

posted @ 2015-09-06 16:44  农民伯伯-Coding  阅读(243)  评论(0)  编辑  收藏  举报