线段树区间更新区间求和(转延迟标记精讲)
2014-06-22 22:36
519 查看
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
[align=left]Problem Description[/align]
You have N integers, A1, A2, ... ,AN. 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.
[align=left]Input[/align]
The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A1,A2, ... ,AN. -1000000000 ≤
Ai ≤ 1000000000.
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of Aa,
Aa+1, ... , Ab. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of Aa, Aa+1, ... ,Ab.
[align=left]Output[/align]
You need to answer all Q commands in order. One answer in a line.
[align=left]Sample Input[/align]
10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4
[align=left]Sample Output[/align]
4
55
9
15
[align=left]Source[/align]
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-6 typedef 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 100005 struct 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 ; 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虽然没有左右子树,但是的确占用了数组空间,实际空间是满二叉树的节点数目:
,
是树的高度,但是这个空间复杂度也是O(n)的 )。
struct SegTreeNode
{
int val;
};
定义包含n个节点的线段树 SegTreeNode segTree
,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 else 19 { 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]),就相当于单节点更新,单节点更新只是区间更新的特例。
相关文章推荐
- POJ3468 线段树(区间更新,区间求和,延迟标记)
- poj3468 A Simple Problem with Integers 线段树延迟标记区间更新区间求和
- 杭电 HDU ACM 1698 Just a Hook(线段树 区间更新 延迟标记)
- 线段树区间更新模板(lazy延迟标记)(1698)
- FZU1608(线段树成段更新,区间求和pushdown延迟标记结构体版)
- 区间更新 区间和查询 带有延迟标记 线段树 hdu1698; 附:csa 区间加值,维护最大值
- hdu1698-Just a Hook (线段树区间更新)(延迟标记)
- 杭电 HDU ACM 1698 Just a Hook(线段树 区间更新 延迟标记)
- codevs 1082 线段树练习 3 区间更新+延迟标记
- hdu1698 Just a Hook 线段树延迟标记区间更新 求加权区间总和
- poj3468---线段树----区间单点更新、区间和查询----有延迟标记
- HDU 1698 JUST a hook (线段树 成段替换 区间求和 延迟标记)
- [线段树]poj3667 Hotel(区间合并、更新、延迟/懒惰标记
- poj 3667 hotel - 线段树-区间更新-延迟标记
- POJ 3468 线段树成段更新区间求和 + 延迟标记详解 A Simple Problem with Integers
- Poj 3468 A Simple Problem with Integers(线段树 区间更新 延迟标记)
- [uva11992]Fast Matrix Operations(多延迟标记,线段树,区间更新)
- kuangbin专题七:E题 Just a Hook ( 延迟标记,区间更新(赋值)求和 )
- HDU1698 Just a Hook(线段树成段替换、区间求和,延迟标记的应用)
- 线段树专题#4_蒟蒻训练历程记录_HDU1698_ 延迟标记、区间更新