线段树区间更新区间求和（转延迟标记精讲）

来源：互联网发布：seo自学编辑：程序博客网时间：2024/04/30 02:50

A Simple Problem with Integers

Time Limit : 10000/5000ms (Java/Other) Memory Limit : 262144/131072K (Java/Other)

Total Submission(s) : 50 Accepted Submission(s) : 23

Problem Description

You have N integers, A₁, A₂, ... ,A_N. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.

Input

The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A₁,A₂, ... ,A_N. -1000000000 ≤A_i ≤ 1000000000.
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of A_a, A_a₊₁, ... , A_b. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of A_a, A_a₊₁, ... ,A_b.

Output

You need to answer all Q commands in order. One answer in a line.

Sample Input

10 51 2 3 4 5 6 7 8 9 10Q 4 4Q 1 10Q 2 4C 3 6 3Q 2 4

Sample Output

Source

PKU

#define DeBUG#include <iostream>#include <cstdio>#include <cstring>#include <cmath>#include <cstdlib>#include <algorithm>#include <vector>#include <stack>#include <queue>#include <string>#include <set>#include <sstream>#include <map>#include <bitset>using namespace std ;#define zero {0}#define INF 0x3f3f3f3f#define EPS 1e-6typedef long long LL;const double PI = acos(-1.0);//#pragma comment(linker, "/STACK:102400000,102400000")inline int sgn(double x){    return fabs(x) < EPS ? 0 : (x < 0 ? -1 : 1);}#define N 100005struct Node{    int l, r;    int mid;    int id;    long long sum;    long long add;    void get(long long tm)    {        add+=tm;        sum+=(r-l+1)*tm;    }};long long y[N];Node tree[N * 10];void build(int id, int l, int r){    Node &t = tree[id];    t.l = l;    t.r = r;    t.mid = (l + r) >> 1;    t.id = id;    t.sum = t.add = 0;    if (l == r)    {        t.sum = y[l];        return;    }    build(id << 1, l, t.mid);    build(id << 1 | 1, t.mid + 1, r);    t.sum = tree[id << 1].sum + tree[id << 1 | 1].sum;}void relax(int id){    if (tree[id].add)    {        tree[id << 1].get(tree[id].add);        tree[id << 1 | 1].get(tree[id].add);        tree[id].add = 0;    }}void update2(int id, int st, int ed, int add){    Node &t = tree[id];    if (st <= t.l && t.r <= ed)    {        t.get(add);        return;    }    relax(id);    if (st <= t.mid)        update2(id << 1, st, ed, add);    if (ed > t.mid)        update2(id << 1 | 1, st, ed, add);    tree[id].sum = tree[id << 1].sum + tree[id << 1 | 1].sum;}long long query2(int id, int l, int r){    Node &t = tree[id];    if (l <= t.l && r >= t.r)        return t.sum;    relax(id);    long long sum1 = 0, sum2 = 0;    if (t.mid >= l)        sum1 = query2(id << 1, l, r);    if (t.mid < r)        sum2 = query2(id << 1 | 1, l, r);    return sum1 + sum2;}int main(){#ifdef DeBUGs    freopen("C:\\Users\\Sky\\Desktop\\1.in", "r", stdin);#endif    int n, m;    while (scanf("%d%d", &n, &m) + 1)    {        for (int i = 1; i <= n; i++)        {            scanf("%lld", &y[i]);        }        build(1, 1, n);        char op[10];        int a, b, c;        for (int i = 1; i <= m; i++)        {            scanf("%s", op);            if (op[0] == 'Q')            {                scanf("%d%d", &a, &b);                printf("%lld\n", query2(1, a, b));            }            else            {                scanf("%d%d%d", &a, &b, &c);                update2(1, a, b, c);            }        }    }    return 0;}

转自：http://www.cnblogs.com/TenosDoIt/p/3453089.html#b

一概述

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

线段树的每个节点表示一个区间，子节点则分别表示父节点的左右半区间，例如父亲的区间是[a,b]，那么(c=(a+b)/2)左儿子的区间是[a,c]，右儿子的区间是[c+1,b]。

二从一个例子理解线段树

下面我们从一个经典的例子来了解线段树，问题描述如下:从数组arr[0...n-1]中查找某个数组某个区间内的最小值，其中数组大小固定，但是数组中的元素的值可以随时更新。

对这个问题一个简单的解法是：遍历数组区间找到最小值，时间复杂度是O(n),额外的空间复杂度O(1)。当数据量特别大，而查询操作很频繁的时候，耗时可能会不满足需求。

另一种解法：使用一个二维数组来保存提前计算好的区间[i,j]内的最小值，那么预处理时间为O(n^2)，查询耗时O(1), 但是需要额外的O(n^2)空间，当数据量很大时，这个空间消耗是庞大的，而且当改变了数组中的某一个值时，更新二维数组中的最小值也很麻烦。

我们可以用线段树来解决这个问题：预处理耗时O(n)，查询、更新操作O(logn)，需要额外的空间O(n)。根据这个问题我们构造如下的二叉树

叶子节点是原始组数arr中的元素
非叶子节点代表它的所有子孙叶子节点所在区间的最小值

例如对于数组[2, 5, 1, 4, 9, 3]可以构造如下的二叉树（背景为白色表示叶子节点，非叶子节点的值是其对应数组区间内的最小值，例如根节点表示数组区间arr[0...5]内的最小值是1）：本文地址

由于线段树的父节点区间是平均分割到左右子树，因此线段树是完全二叉树，对于包含n个叶子节点的完全二叉树，它一定有n-1个非叶节点，总共2n-1个节点，因此存储线段是需要的空间复杂度是O(n)。那么线段树的操作：创建线段树、查询、节点更新是如何运作的呢（以下所有代码都是针对求区间最小值问题）？

2.1 创建线段树

对于线段树我们可以选择和普通二叉树一样的链式结构。由于线段树是完全二叉树，我们也可以用数组来存储，下面的讨论及代码都是数组来存储线段树，节点结构如下（注意到用数组存储时，有效空间为2n-1,实际空间确不止这么多，比如上面的线段树中叶子节点1、3虽然没有左右子树，但是的确占用了数组空间，实际空间是满二叉树的节点数目： $2 * 2 ^{\lceil \log_2{n} \rceil} - 1$ ， $\lceil \log_2{n} \rceil$ 是树的高度，但是这个空间复杂度也是O(n)的）。

struct SegTreeNode

{

　　int val;

}；

定义包含n个节点的线段树 SegTreeNode segTree[n]，segTree[0]表示根节点。那么对于节点segTree[i]，它的左孩子是segTree[2*i+1],右孩子是segTree[2*i+2]。

我们可以从根节点开始，平分区间，递归的创建线段树，线段树的创建函数如下：

 1 const int MAXNUM = 1000; 2 struct SegTreeNode 3 { 4     int val; 5 }segTree[MAXNUM];//定义线段树 6  7 14 void build(int root, int arr[], int istart, int iend)15 {16     if(istart == iend)//叶子节点17         segTree[root].val = arr[istart];18     else19     {20         int mid = (istart + iend) / 2;21         build(root*2+1, arr, istart, mid);//递归构造左子树22         build(root*2+2, arr, mid+1, iend);//递归构造右子树23         //根据左右子树根节点的值，更新当前根节点的值24         segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);25     }26 }

2.2 查询线段树

已经构建好了线段树，那么怎样在它上面超找某个区间的最小值呢？查询的思想是选出一些区间，使他们相连后恰好涵盖整个查询区间，因此线段树适合解决“相邻的区间的信息可以被合并成两个区间的并区间的信息”的问题。代码如下，具体见代码解释

 1  7 int query(int root, int nstart, int nend, int qstart, int qend) 8 { 9     //查询区间和当前节点区间没有交集10     if(qstart > nend || qend < nstart)11         return INFINITE;12     //当前节点区间包含在查询区间内13     if(qstart <= nstart && qend >= nend)14         return segTree[root].val;15     //分别从左右子树查询，返回两者查询结果的较小值16     int mid = (nstart + nend) / 2;17     return min(query(root*2+1, nstart, mid, qstart, qend),18                query(root*2+2, mid + 1, nend, qstart, qend));19 20 }

举例说明（对照上面的二叉树）：

1、当我们要查询区间[0,2]的最小值时，从根节点开始，要分别查询左右子树，查询左子树时节点区间[0,2]包含在查询区间[0,2]内，返回当前节点的值1，查询右子树时，节点区间[3,5]和查询区间[0,2]没有交集，返回正无穷INFINITE，查询结果取两子树查询结果的较小值1，因此结果是1.

2、查询区间[0,3]时，从根节点开始，查询左子树的节点区间[0,2]包含在区间[0,3]内，返回当前节点的值1；查询右子树时，继续递归查询右子树的左右子树，查询到非叶节点4时，又要继续递归查询：叶子节点4的节点区间[3,3]包含在查询区间[0,3]内，返回4，叶子节点9的节点区间[4,4]和[0,3]没有交集，返回INFINITE,因此非叶节点4返回的是min(4, INFINITE) = 4，叶子节点3的节点区间[5,5]和[0,3]没有交集，返回INFINITE,因此非叶节点3返回min(4, INFINITE) = 4, 因此根节点返回 min(1,4) = 1。

2.3单节点更新

单节点更新是指只更新线段树的某个叶子节点的值，但是更新叶子节点会对其父节点的值产生影响，因此更新子节点后，要回溯更新其父节点的值。

 1  8 void updateOne(int root, int nstart, int nend, int index, int addVal) 9 {10     if(nstart == nend)11     {12         if(index == nstart)//找到了相应的节点，更新之13             segTree[root].val += addVal;14         return;15     }16     int mid = (nstart + nend) / 2;17     if(index <= mid)//在左子树中更新18         updateOne(root*2+1, nstart, mid, index, addVal);19     else updateOne(root*2+2, mid+1, nend, index, addVal);//在右子树中更新20     //根据左右子树的值回溯更新当前节点的值21     segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);22 }

比如我们要更新叶子节点4（addVal = 6）,更新后值变为10，那么其父节点的值从4变为9，非叶结点3的值更新后不变，根节点更新后也不变。

2.4 区间更新

区间更新是指更新某个区间内的叶子节点的值，因为涉及到的叶子节点不止一个，而叶子节点会影响其相应的非叶父节点，那么回溯需要更新的非叶子节点也会有很多，如果一次性更新完，操作的时间复杂度肯定不是O(lgn)，例如当我们要更新区间[0,3]内的叶子节点时，需要更新出了叶子节点3,9外的所有其他节点。为此引入了线段树中的延迟标记概念，这也是线段树的精华所在。

延迟标记：每个节点新增加一个标记，记录这个节点是否进行了某种修改(这种修改操作会影响其子节点)，对于任意区间的修改，我们先按照区间查询的方式将其划分成线段树中的节点，然后修改这些节点的信息，并给这些节点标记上代表这种修改操作的标记。在修改和查询的时候，如果我们到了一个节点p，并且决定考虑其子节点，那么我们就要看节点p是否被标记，如果有，就要按照标记修改其子节点的信息，并且给子节点都标上相同的标记，同时消掉节点p的标记。

因此需要在线段树结构中加入延迟标记域，本文例子中我们加入标记与addMark，表示节点的子孙节点在原来的值的基础上加上addMark的值，同时还需要修改创建函数build 和查询函数 query，修改的代码用红色字体表示，其中区间更新的函数为update，代码如下：

  1 const int INFINITE = INT_MAX;  2 const int MAXNUM = 1000;  3 struct SegTreeNode  4 {  5     int val;  6     int addMark;//延迟标记  7 }segTree[MAXNUM];//定义线段树  8   9  16 void build(int root, int arr[], int istart, int iend) 17 { 18     segTree[root].addMark = 0;//----设置标延迟记域 19     if(istart == iend)//叶子节点 20         segTree[root].val = arr[istart]; 21     else 22     { 23         int mid = (istart + iend) / 2; 24         build(root*2+1, arr, istart, mid);//递归构造左子树 25         build(root*2+2, arr, mid+1, iend);//递归构造右子树 26         //根据左右子树根节点的值，更新当前根节点的值 27         segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val); 28     } 29 } 30  31  35 void pushDown(int root) 36 { 37     if(segTree[root].addMark != 0) 38     { 39         //设置左右孩子节点的标志域，因为孩子节点可能被多次延迟标记又没有向下传递 40         //所以是 “+=” 41         segTree[root*2+1].addMark += segTree[root].addMark; 42         segTree[root*2+2].addMark += segTree[root].addMark; 43         //根据标志域设置孩子节点的值。因为我们是求区间最小值，因此当区间内每个元 44         //素加上一个值时，区间的最小值也加上这个值 45         segTree[root*2+1].val += segTree[root].addMark; 46         segTree[root*2+2].val += segTree[root].addMark; 47         //传递后，当前节点标记域清空 48         segTree[root].addMark = 0; 49     } 50 } 51  52  58 int query(int root, int nstart, int nend, int qstart, int qend) 59 { 60     //查询区间和当前节点区间没有交集 61     if(qstart > nend || qend < nstart) 62         return INFINITE; 63     //当前节点区间包含在查询区间内 64     if(qstart <= nstart && qend >= nend) 65         return segTree[root].val; 66     //分别从左右子树查询，返回两者查询结果的较小值 67     pushDown(root); //----延迟标志域向下传递 68     int mid = (nstart + nend) / 2; 69     return min(query(root*2+1, nstart, mid, qstart, qend), 70                query(root*2+2, mid + 1, nend, qstart, qend)); 71  72 } 73  74  81 void update(int root, int nstart, int nend, int ustart, int uend, int addVal) 82 { 83     //更新区间和当前节点区间没有交集 84     if(ustart > nend || uend < nstart) 85         return ; 86     //当前节点区间包含在更新区间内 87     if(ustart <= nstart && uend >= nend) 88     { 89         segTree[root].addMark += addVal; 90         segTree[root].val += addVal; 91         return ; 92     } 93     pushDown(root); //延迟标记向下传递 94     //更新左右孩子节点 95     int mid = (nstart + nend) / 2; 96     update(root*2+1, nstart, mid, ustart, uend, addVal); 97     update(root*2+2, mid+1, nend, ustart, uend, addVal); 98     //根据左右子树的值回溯更新当前节点的值 99     segTree[root].val = min(segTree[root*2+1].val, segTree[root*2+2].val);100 }

区间更新举例说明：当我们要对区间[0,2]的叶子节点增加2，利用区间查询的方法从根节点开始找到了非叶子节点[0-2]，把它的值设置为1+2 = 3，并且把它的延迟标记设置为2，更新完毕；当我们要查询区间[0,1]内的最小值时，查找到区间[0,2]时，发现它的标记不为0，并且还要向下搜索，因此要把标记向下传递，把节点[0-1]的值设置为2+2 = 4，标记设置为2，节点[2-2]的值设置为1+2 = 3，标记设置为2（其实叶子节点的标志是不起作用的，这里是为了操作的一致性），然后返回查询结果：[0-1]节点的值4；当我们再次更新区间[0,1]（增加3）时，查询到节点[0-1],发现它的标记值为2，因此把它的标记值设置为2+3 = 5，节点的值设置为4+3 = 7；

其实当区间更新的区间左右值相等时（[i,i]），就相当于单节点更新，单节点更新只是区间更新的特例。

0 0