线段树入门详解

线段树

转载出处：http://blog.csdn.net/metalseed/article/details/8039326#t4

一：线段树基本概念

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);

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

    #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;  
    }   

(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]范围的最小值。同理，对于其他询问的区间，也都可以找到若干个相连的区间，合并后可以得到询问的区间。

    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;      
    }   

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

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

a:单节点更新

    void Updata(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的标记。（优点在于，不用将区间内的所有值都暴力更新，大大提高效率，因此区间更新是最优用的操作）

void Change来自dongxicheng.org

    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); /* 维护当前结点的信息（因为其子结点的信息可能有更改）*/  
       
    }  

二：典型模板

模板1：

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

    #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：

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

    #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;    
    }    

三：练习题目

• hdu1166 敌兵布阵
  
• 题意:O(-1)
• 思路:O(-1)
  线段树功能:update:单点增减 query:区间求和

code:

    #include<cstring>  
    #include<iostream>  
      
    #define M 50005  
    #define lson l,m,rt<<1  
    #define rson m+1,r,rt<<1|1  
    /*left,right,root,middle*/  
      
    int sum[M<<2];  
      
    inline void PushPlus(int rt)  
    {  
        sum[rt] = sum[rt<<1] + sum[rt<<1|1];  
    }  
      
    void Build(int l, int r, int rt)  
    {  
        if(l == r)  
        {  
            scanf("%d", &sum[rt]);  
            return ;  
        }  
        int m = ( l + r )>>1;  
      
        Build(lson);  
        Build(rson);  
        PushPlus(rt);  
    }  
      
    void Updata(int p, int add, int l, int r, int rt)  
    {  
      
        if( l == r )  
        {  
            sum[rt] += add;  
            return ;  
        }  
        int m = ( l + r ) >> 1;  
        if(p <= m)  
            Updata(p, add, lson);  
        else  
            Updata(p, add, rson);  
      
        PushPlus(rt);  
    }  
      
    int Query(int L,int R,int l,int r,int rt)  
    {  
        if( L <= l && r <= R )  
        {  
            return sum[rt];  
        }  
        int m = ( l + r ) >> 1;  
        int ans=0;  
        if(L<=m )  
            ans+=Query(L,R,lson);  
        if(R>m)  
            ans+=Query(L,R,rson);  
      
        return ans;  
    }  
    int main()  
    {     
        int T, n, a, b;  
        scanf("%d",&T);  
        for( int i = 1; i <= T; ++i )  
        {  
            printf("Case %d:\n",i);  
            scanf("%d",&n);  
            Build(1,n,1);  
      
            char op[10];  
      
            while( scanf("%s",op) &&op[0]!='E' )  
            {  
      
                scanf("%d %d", &a, &b);  
                if(op[0] == 'Q')  
                    printf("%d\n",Query(a,b,1,n,1));  
                else if(op[0] == 'S')  
                    Updata(a,-b,1,n,1);  
                else  
                    Updata(a,b,1,n,1);  
      
            }  
        }  
        return 0;  
    }  

hdu1754 I Hate It
题意:O(-1)
思路:O(-1)
线段树功能:update:单点替换 query:区间最值

    #include <cstdio>  
    #include <algorithm>  
    using namespace std;  
       
    #define lson l , m , rt << 1  
    #define rson m + 1 , r , rt << 1 | 1  
    const int maxn = 222222;  
    int MAX[maxn<<2];  
    void PushUP(int rt) {  
        MAX[rt] = max(MAX[rt<<1] , MAX[rt<<1|1]);  
    }  
    void build(int l,int r,int rt) {  
        if (l == r) {  
            scanf("%d",&MAX[rt]);  
            return ;  
        }  
        int m = (l + r) >> 1;  
        build(lson);  
        build(rson);  
        PushUP(rt);  
    }  
    void update(int p,int sc,int l,int r,int rt) {  
        if (l == r) {  
            MAX[rt] = sc;  
            return ;  
        }  
        int m = (l + r) >> 1;  
        if (p <= m) update(p , sc , lson);  
        else update(p , sc , rson);  
        PushUP(rt);  
    }  
    int query(int L,int R,int l,int r,int rt) {  
        if (L <= l && r <= R) {  
            return MAX[rt];  
        }  
        int m = (l + r) >> 1;  
        int ret = 0;  
        if (L <= m) ret = max(ret , query(L , R , lson));  
        if (R > m) ret = max(ret , query(L , R , rson));  
        return ret;  
    }  
    int main() {  
        int n , m;  
        while (~scanf("%d%d",&n,&m)) {  
            build(1 , n , 1);  
            while (m --) {  
                char op[2];  
                int a , b;  
                scanf("%s%d%d",op,&a,&b);  
                if (op[0] == 'Q') printf("%d\n",query(a , b , 1 , n , 1));  
                else update(a , b , 1 , n , 1);  
            }  
        }  
        return 0;  
    }  

hdu1394 Minimum Inversion Number
题意:求Inversion后的最小逆序数
思路:用O(nlogn)复杂度求出最初逆序数后,就可以用O(1)的复杂度分别递推出其他解
线段树功能:update:单点增减 query:区间求和

    #include <cstdio>  
    #include <algorithm>  
    using namespace std;  
       
    #define lson l , m , rt << 1  
    #define rson m + 1 , r , rt << 1 | 1  
    const int maxn = 5555;  
    int sum[maxn<<2];  
    void PushUP(int rt) {  
        sum[rt] = sum[rt<<1] + sum[rt<<1|1];  
    }  
    void build(int l,int r,int rt) {  
        sum[rt] = 0;  
        if (l == r) return ;  
        int m = (l + r) >> 1;  
        build(lson);  
        build(rson);  
    }  
    void update(int p,int l,int r,int rt) {  
        if (l == r) {  
            sum[rt] ++;  
            return ;  
        }  
        int m = (l + r) >> 1;  
        if (p <= m) update(p , lson);  
        else update(p , rson);  
        PushUP(rt);  
    }  
    int query(int L,int R,int l,int r,int rt) {  
        if (L <= l && r <= R) {  
            return sum[rt];  
        }  
        int m = (l + r) >> 1;  
        int ret = 0;  
        if (L <= m) ret += query(L , R , lson);  
        if (R > m) ret += query(L , R , rson);  
        return ret;  
    }  
    int x[maxn];  
    int main() {  
        int n;  
        while (~scanf("%d",&n)) {  
            build(0 , n - 1 , 1);  
            int sum = 0;  
            for (int i = 0 ; i < n ; i ++) {  
                scanf("%d",&x[i]);  
                sum += query(x[i] , n - 1 , 0 , n - 1 , 1);  
                update(x[i] , 0 , n - 1 , 1);  
            }  
            int ret = sum;  
            for (int i = 0 ; i < n ; i ++) {  
                sum += n - x[i] - x[i] - 1;  
                ret = min(ret , sum);  
            }  
            printf("%d\n",ret);  
        }  
        return 0;  
    }  

hdu2795 Billboard
题意:h*w的木板,放进一些1*L的物品,求每次放空间能容纳且最上边的位子
思路:每次找到最大值的位子,然后减去L
线段树功能:query:区间求最大值的位子(直接把update的操作在query里做了)

    #include <cstdio>  
    #include <algorithm>  
    using namespace std;  
       
    #define lson l , m , rt << 1  
    #define rson m + 1 , r , rt << 1 | 1  
    const int maxn = 222222;  
    int h , w , n;  
    int MAX[maxn<<2];  
    void PushUP(int rt) {  
        MAX[rt] = max(MAX[rt<<1] , MAX[rt<<1|1]);  
    }  
    void build(int l,int r,int rt) {  
        MAX[rt] = w;  
        if (l == r) return ;  
        int m = (l + r) >> 1;  
        build(lson);  
        build(rson);  
    }  
    int query(int x,int l,int r,int rt) {  
        if (l == r) {  
            MAX[rt] -= x;  
            return l;  
        }  
        int m = (l + r) >> 1;  
        int ret = (MAX[rt<<1] >= x) ? query(x , lson) : query(x , rson);  
        PushUP(rt);  
        return ret;  
    }  
    int main() {  
        while (~scanf("%d%d%d",&h,&w,&n)) {  
            if (h > n) h = n;  
            build(1 , h , 1);  
            while (n --) {  
                int x;  
                scanf("%d",&x);  
                if (MAX[1] < x) puts("-1");  
                else printf("%d\n",query(x , 1 , h , 1));  
            }  
        }  
        return 0;  
    }  

成段更新(通常这对初学者来说是一道坎),需要用到延迟标记(或者说懒惰标记),简单来说就是每次更新的时候不要更新到底,用延迟标记使得更新延迟到下次需要更新or询问到的时候

hdu1698 Just a Hook
题意:O(-1)
思路:O(-1)

线段树功能:update:成段替换 (由于只query一次总区间,所以可以直接输出1结点的信息)

    #include <cstdio>  
    #include <algorithm>  
    using namespace std;  
       
    #define lson l , m , rt << 1  
    #define rson m + 1 , r , rt << 1 | 1  
    const int maxn = 111111;  
    int h , w , n;  
    int col[maxn<<2];  
    int sum[maxn<<2];  
    void PushUp(int rt) {  
        sum[rt] = sum[rt<<1] + sum[rt<<1|1];  
    }  
    void PushDown(int rt,int m) {  
        if (col[rt]) {  
            col[rt<<1] = col[rt<<1|1] = col[rt];  
            sum[rt<<1] = (m - (m >> 1)) * col[rt];  
            sum[rt<<1|1] = (m >> 1) * col[rt];  
            col[rt] = 0;  
        }  
    }  
    void build(int l,int r,int rt) {  
        col[rt] = 0;  
        sum[rt] = 1;  
        if (l == r) 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) {  
            col[rt] = c;  
            sum[rt] = c * (r - l + 1);  
            return ;  
        }  
        PushDown(rt , r - l + 1);  
        int m = (l + r) >> 1;  
        if (L <= m) update(L , R , c , lson);  
        if (R > m) update(L , R , c , rson);  
        PushUp(rt);  
    }  
    int main() {  
        int T , n , m;  
        scanf("%d",&T);  
        for (int cas = 1 ; cas <= T ; cas ++) {  
            scanf("%d%d",&n,&m);  
            build(1 , n , 1);  
            while (m --) {  
                int a , b , c;  
                scanf("%d%d%d",&a,&b,&c);  
                update(a , b , c , 1 , n , 1);  
            }  
            printf("Case %d: The total value of the hook is %d.\n",cas , sum[1]);  
        }  
        return 0;  
    }  

poj3468 A Simple Problem with Integers
题意:O(-1)
思路:O(-1)
线段树功能:update:成段增减 query:区间求和

    #include <cstdio>  
    #include <algorithm>  
    using namespace std;  
       
    #define lson l , m , rt << 1  
    #define rson m + 1 , r , rt << 1 | 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(1 , N , 1);  
        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 , 1 , N , 1));  
            } else {  
                scanf("%d%d%d",&a,&b,&c);  
                update(a , b , c , 1 , N , 1);  
            }  
        }  
        return 0;  
    }