一:线段树基本概念
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);
-
-
- 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]范围的最小值。同理,对于其他询问的区间,也都可以找到若干个相连的区间,合并后可以得到询问的区间。
- int query(int node, int begin, int end, int left, int right)
- {
- int p1, p2;
-
-
- if (left > end || right < begin)
- return -1;
-
-
-
- if (begin >= left && end <= right)
- return segTree[node];
-
-
-
- p1 = query(2 * node, begin, (begin + end) / 2, left, right);
- p2 = query(2 * node + 1, (begin + end) / 2 + 1, end, left, right);
-
-
- if (p1 == -1)
- return p2;
- if (p2 == -1)
- return p1;
- if (p1 <= p2)
- return p1;
- return p2;
- }
可见,这样的过程一定选出了尽量少的区间,它们相连后正好涵盖了整个[left,right],没有重复也没有遗漏。同时,考虑到线段树上每层的节点最多会被选取2个,一共选取的节点数也是O(log n)的,因此查询的时间复杂度也是O(log n)。
线段树并不适合所有区间查询情况,它的使用条件是“相邻的区间的信息可以被合并成两个区间的并区间的信息”。即问题是可以被分解解决的。
(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)
-
- {
-
- if (a <= p->Left && p->Right <= b)
-
-
-
- {
-
- ......
-
- return;
-
- }
-
- Push_Down(p);
-
- int mid = (p->Left + p->Right) / 2;
-
-
-
- if (b > mid) Change(p->Rch, a, b);
-
- Update(p);
-
- }
3:主要应用
(1):区间最值查询问题 (见模板1)
(2):连续区间修改或者单节点更新的动态查询问题 (见模板2)
(3):多维空间的动态查询 (见模板3)
二:典型模板
模板1:
RMQ,查询区间最值下标---min
- #include<iostream>
-
- using namespace std;
-
- #define MAXN 100
- #define MAXIND 256 //线段树节点个数
-
-
- 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];
- }
- }
-
-
- 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);
-
-
-
- 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];
- 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;
- }
模板3:
多维空间的动态查询
三:练习题目
下面是hh线段树代码,典型练习哇~
在代码前先介绍一些我的线段树风格:
- maxn是题目给的最大区间,而节点数要开4倍,确切的来说节点数要开大于maxn的最小2x的两倍
- lson和rson分辨表示结点的左儿子和右儿子,由于每次传参数的时候都固定是这几个变量,所以可以用预定于比较方便的表示
- 以前的写法是另外开两个个数组记录每个结点所表示的区间,其实这个区间不必保存,一边算一边传下去就行,只需要写函数的时候多两个参数,结合lson和rson的预定义可以很方便
- PushUP(int rt)是把当前结点的信息更新到父结点
- PushDown(int rt)是把当前结点的信息更新给儿子结点
- rt表示当前子树的根(root),也就是当前所在的结点
整理这些题目后我觉得线段树的题目整体上可以分成以下四个部分:
单点更新:最最基础的线段树,只更新叶子节点,然后把信息用PushUP(int r)这个函数更新上来
code:
- #include<cstring>
- #include<iostream>
-
- #define M 50005
- #define lson l,m,rt<<1
- #define rson m+1,r,rt<<1|1
-
-
- 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询问到的时候
- #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;
- }
poj2528 Mayor’s posters
题意:在墙上贴海报,海报可以互相覆盖,问最后可以看见几张海报
思路:这题数据范围很大,直接搞超时+超内存,需要离散化:
离散化简单的来说就是只取我们需要的值来用,比如说区间[1000,2000],[1990,2012] 我们用不到[-∞,999][1001,1989][1991,1999][2001,2011][2013,+∞]这些值,所以我只需要1000,1990,2000,2012就够了,将其分别映射到0,1,2,3,在于复杂度就大大的降下来了
所以离散化要保存所有需要用到的值,排序后,分别映射到1~n,这样复杂度就会小很多很多
而这题的难点在于每个数字其实表示的是一个单位长度(并非一个点),这样普通的离散化会造成许多错误(包括我以前的代码,poj这题数据奇弱)
给出下面两个简单的例子应该能体现普通离散化的缺陷:
例子一:1-10 1-4 5-10
例子二:1-10 1-4 6-10
普通离散化后都变成了[1,4][1,2][3,4]
线段2覆盖了[1,2],线段3覆盖了[3,4],那么线段1是否被完全覆盖掉了呢?
例子一是完全被覆盖掉了,而例子二没有被覆盖
为了解决这种缺陷,我们可以在排序后的数组上加些处理,比如说[1,2,6,10]
如果相邻数字间距大于1的话,在其中加上任意一个数字,比如加成[1,2,3,6,7,10],然后再做线段树就好了.
线段树功能:update:成段替换 query:简单hash
- #include <cstdio>
- #include <cstring>
- #include <algorithm>
- using namespace std;
- #define lson l , m , rt << 1
- #define rson m + 1 , r , rt << 1 | 1
-
- const int maxn = 11111;
- bool hash[maxn];
- int li[maxn] , ri[maxn];
- int X[maxn*3];
- int col[maxn<<4];
- int cnt;
-
- void PushDown(int rt) {
- if (col[rt] != -1) {
- col[rt<<1] = col[rt<<1|1] = col[rt];
- col[rt] = -1;
- }
- }
- void update(int L,int R,int c,int l,int r,int rt) {
- if (L <= l && r <= R) {
- col[rt] = c;
- return ;
- }
- PushDown(rt);
- int m = (l + r) >> 1;
- if (L <= m) update(L , R , c , lson);
- if (m < R) update(L , R , c , rson);
- }
- void query(int l,int r,int rt) {
- if (col[rt] != -1) {
- if (!hash[col[rt]]) cnt ++;
- hash[ col[rt] ] = true;
- return ;
- }
- if (l == r) return ;
- int m = (l + r) >> 1;
- query(lson);
- query(rson);
- }
- int Bin(int key,int n,int X[]) {
- int l = 0 , r = n - 1;
- while (l <= r) {
- int m = (l + r) >> 1;
- if (X[m] == key) return m;
- if (X[m] < key) l = m + 1;
- else r = m - 1;
- }
- return -1;
- }
- int main() {
- int T , n;
- scanf("%d",&T);
- while (T --) {
- scanf("%d",&n);
- int nn = 0;
- for (int i = 0 ; i < n ; i ++) {
- scanf("%d%d",&li[i] , &ri[i]);
- X[nn++] = li[i];
- X[nn++] = ri[i];
- }
- sort(X , X + nn);
- int m = 1;
- for (int i = 1 ; i < nn; i ++) {
- if (X[i] != X[i-1]) X[m ++] = X[i];
- }
- for (int i = m - 1 ; i > 0 ; i --) {
- if (X[i] != X[i-1] + 1) X[m ++] = X[i-1] + 1;
- }
- sort(X , X + m);
- memset(col , -1 , sizeof(col));
- for (int i = 0 ; i < n ; i ++) {
- int l = Bin(li[i] , m , X);
- int r = Bin(ri[i] , m , X);
- update(l , r , i , 0 , m , 1);
- }
- cnt = 0;
- memset(hash , false , sizeof(hash));
- query(0 , m , 1);
- printf("%d\n",cnt);
- }
- return 0;
- }
poj3225 Help with Intervals
题意:区间操作,交,并,补等
思路:
我们一个一个操作来分析:(用0和1表示是否包含区间,-1表示该区间内既有包含又有不包含)
U:把区间[l,r]覆盖成1
I:把[-∞,l)(r,∞]覆盖成0
D:把区间[l,r]覆盖成0
C:把[-∞,l)(r,∞]覆盖成0 , 且[l,r]区间0/1互换
S:[l,r]区间0/1互换
成段覆盖的操作很简单,比较特殊的就是区间0/1互换这个操作,我们可以称之为异或操作
很明显我们可以知道这个性质:当一个区间被覆盖后,不管之前有没有异或标记都没有意义了
所以当一个节点得到覆盖标记时把异或标记清空
而当一个节点得到异或标记的时候,先判断覆盖标记,如果是0或1,直接改变一下覆盖标记,不然的话改变异或标记
开区间闭区间只要数字乘以2就可以处理(偶数表示端点,奇数表示两端点间的区间)
线段树功能:update:成段替换,区间异或 query:简单hash
- #include <cstdio>
- #include <cstring>
- #include <cctype>
- #include <algorithm>
- using namespace std;
- #define lson l , m , rt << 1
- #define rson m + 1 , r , rt << 1 | 1
-
- const int maxn = 131072;
- bool hash[maxn+1];
- int cover[maxn<<2];
- int XOR[maxn<<2];
- void FXOR(int rt) {
- if (cover[rt] != -1) cover[rt] ^= 1;
- else XOR[rt] ^= 1;
- }
- void PushDown(int rt) {
- if (cover[rt] != -1) {
- cover[rt<<1] = cover[rt<<1|1] = cover[rt];
- XOR[rt<<1] = XOR[rt<<1|1] = 0;
- cover[rt] = -1;
- }
- if (XOR[rt]) {
- FXOR(rt<<1);
- FXOR(rt<<1|1);
- XOR[rt] = 0;
- }
- }
- void update(char op,int L,int R,int l,int r,int rt) {
- if (L <= l && r <= R) {
- if (op == 'U') {
- cover[rt] = 1;
- XOR[rt] = 0;
- } else if (op == 'D') {
- cover[rt] = 0;
- XOR[rt] = 0;
- } else if (op == 'C' || op == 'S') {
- FXOR(rt);
- }
- return ;
- }
- PushDown(rt);
- int m = (l + r) >> 1;
- if (L <= m) update(op , L , R , lson);
- else if (op == 'I' || op == 'C') {
- XOR[rt<<1] = cover[rt<<1] = 0;
- }
- if (m < R) update(op , L , R , rson);
- else if (op == 'I' || op == 'C') {
- XOR[rt<<1|1] = cover[rt<<1|1] = 0;
- }
- }
- void query(int l,int r,int rt) {
- if (cover[rt] == 1) {
- for (int it = l ; it <= r ; it ++) {
- hash[it] = true;
- }
- return ;
- } else if (cover[rt] == 0) return ;
- if (l == r) return ;
- PushDown(rt);
- int m = (l + r) >> 1;
- query(lson);
- query(rson);
- }
- int main() {
- cover[1] = XOR[1] = 0;
- char op , l , r;
- int a , b;
- while ( ~scanf("%c %c%d,%d%c\n",&op , &l , &a , &b , &r) ) {
- a <<= 1 , b <<= 1;
- if (l == '(') a ++;
- if (r == ')') b --;
- if (a > b) {
- if (op == 'C' || op == 'I') {
- cover[1] = XOR[1] = 0;
- }
- } else update(op , a , b , 0 , maxn , 1);
- }
- query(0 , maxn , 1);
- bool flag = false;
- int s = -1 , e;
- for (int i = 0 ; i <= maxn ; i ++) {
- if (hash[i]) {
- if (s == -1) s = i;
- e = i;
- } else {
- if (s != -1) {
- if (flag) printf(" ");
- flag = true;
- printf("%c%d,%d%c",s&1?'(':'[' , s>>1 , (e+1)>>1 , e&1?')':']');
- s = -1;
- }
- }
- }
- if (!flag) printf("empty set");
- puts("");
- return 0;
- }
练习
poj1436 Horizontally Visible Segments
poj2991 Crane
Another LCIS
Bracket Sequence
区间合并
这类题目会询问区间中满足条件的连续最长区间,所以PushUp的时候需要对左右儿子的区间进行合并
poj3667 Hotel
题意:1 a:询问是不是有连续长度为a的空房间,有的话住进最左边
2 a b:将[a,a+b-1]的房间清空
思路:记录区间中最长的空房间
线段树操作:update:区间替换 query:询问满足条件的最左断点
- #include <cstdio>
- #include <cstring>
- #include <cctype>
- #include <algorithm>
- using namespace std;
- #define lson l , m , rt << 1
- #define rson m + 1 , r , rt << 1 | 1
-
- const int maxn = 55555;
- int lsum[maxn<<2] , rsum[maxn<<2] , msum[maxn<<2];
- int cover[maxn<<2];
-
- void PushDown(int rt,int m) {
- if (cover[rt] != -1) {
- cover[rt<<1] = cover[rt<<1|1] = cover[rt];
- msum[rt<<1] = lsum[rt<<1] = rsum[rt<<1] = cover[rt] ? 0 : m - (m >> 1);
- msum[rt<<1|1] = lsum[rt<<1|1] = rsum[rt<<1|1] = cover[rt] ? 0 : (m >> 1);
- cover[rt] = -1;
- }
- }
- void PushUp(int rt,int m) {
- lsum[rt] = lsum[rt<<1];
- rsum[rt] = rsum[rt<<1|1];
- if (lsum[rt] == m - (m >> 1)) lsum[rt] += lsum[rt<<1|1];
- if (rsum[rt] == (m >> 1)) rsum[rt] += rsum[rt<<1];
- msum[rt] = max(lsum[rt<<1|1] + rsum[rt<<1] , max(msum[rt<<1] , msum[rt<<1|1]));
- }
- void build(int l,int r,int rt) {
- msum[rt] = lsum[rt] = rsum[rt] = r - l + 1;
- cover[rt] = -1;
- if (l == r) return ;
- int m = (l + r) >> 1;
- build(lson);
- build(rson);
- }
- void update(int L,int R,int c,int l,int r,int rt) {
- if (L <= l && r <= R) {
- msum[rt] = lsum[rt] = rsum[rt] = c ? 0 : r - l + 1;
- cover[rt] = c;
- 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 , r - l + 1);
- }
- int query(int w,int l,int r,int rt) {
- if (l == r) return l;
- PushDown(rt , r - l + 1);
- int m = (l + r) >> 1;
- if (msum[rt<<1] >= w) return query(w , lson);
- else if (rsum[rt<<1] + lsum[rt<<1|1] >= w) return m - rsum[rt<<1] + 1;
- return query(w , rson);
- }
- int main() {
- int n , m;
- scanf("%d%d",&n,&m);
- build(1 , n , 1);
- while (m --) {
- int op , a , b;
- scanf("%d",&op);
- if (op == 1) {
- scanf("%d",&a);
- if (msum[1] < a) puts("0");
- else {
- int p = query(a , 1 , n , 1);
- printf("%d\n",p);
- update(p , p + a - 1 , 1 , 1 , n , 1);
- }
- } else {
- scanf("%d%d",&a,&b);
- update(a , a + b - 1 , 0 , 1 , n , 1);
- }
- }
- return 0;
- }
练习
hdu3308 LCIS
hdu3397 Sequence operation
hdu2871 Memory Control
hdu1540 Tunnel Warfare
CF46-D Parking Lot
扫描线
这类题目需要将一些操作排序,然后从左到右用一根扫描线(当然是在我们脑子里)扫过去
最典型的就是矩形面积并,周长并等题
hdu1542 Atlantis
题意:矩形面积并
思路:浮点数先要离散化;然后把矩形分成两条边,上边和下边,对横轴建树,然后从下到上扫描上去,用cnt表示该区间下边比上边多几个,sum代表该区间内被覆盖的线段的长度总和
这里线段树的一个结点并非是线段的一个端点,而是该端点和下一个端点间的线段,所以题目中r+1,r-1的地方可以自己好好的琢磨一下
线段树操作:update:区间增减 query:直接取根节点的值
- #include <cstdio>
- #include <cstring>
- #include <cctype>
- #include <algorithm>
- using namespace std;
- #define lson l , m , rt << 1
- #define rson m + 1 , r , rt << 1 | 1
-
- const int maxn = 2222;
- int cnt[maxn << 2];
- double sum[maxn << 2];
- double X[maxn];
- struct Seg {
- double h , l , r;
- int s;
- Seg(){}
- Seg(double a,double b,double c,int d) : l(a) , r(b) , h(c) , s(d) {}
- bool operator < (const Seg &cmp) const {
- return h < cmp.h;
- }
- }ss[maxn];
- void PushUp(int rt,int l,int r) {
- if (cnt[rt]) sum[rt] = X[r+1] - X[l];
- else if (l == r) sum[rt] = 0;
- else sum[rt] = sum[rt<<1] + sum[rt<<1|1];
- }
- void update(int L,int R,int c,int l,int r,int rt) {
- if (L <= l && r <= R) {
- cnt[rt] += c;
- PushUp(rt , l , r);
- return ;
- }
- int m = (l + r) >> 1;
- if (L <= m) update(L , R , c , lson);
- if (m < R) update(L , R , c , rson);
- PushUp(rt , l , r);
- }
- int Bin(double key,int n,double X[]) {
- int l = 0 , r = n - 1;
- while (l <= r) {
- int m = (l + r) >> 1;
- if (X[m] == key) return m;
- if (X[m] < key) l = m + 1;
- else r = m - 1;
- }
- return -1;
- }
- int main() {
- int n , cas = 1;
- while (~scanf("%d",&n) && n) {
- int m = 0;
- while (n --) {
- double a , b , c , d;
- scanf("%lf%lf%lf%lf",&a,&b,&c,&d);
- X[m] = a;
- ss[m++] = Seg(a , c , b , 1);
- X[m] = c;
- ss[m++] = Seg(a , c , d , -1);
- }
- sort(X , X + m);
- sort(ss , ss + m);
- int k = 1;
- for (int i = 1 ; i < m ; i ++) {
- if (X[i] != X[i-1]) X[k++] = X[i];
- }
- memset(cnt , 0 , sizeof(cnt));
- memset(sum , 0 , sizeof(sum));
- double ret = 0;
- for (int i = 0 ; i < m - 1 ; i ++) {
- int l = Bin(ss[i].l , k , X);
- int r = Bin(ss[i].r , k , X) - 1;
- if (l <= r) update(l , r , ss[i].s , 0 , k - 1, 1);
- ret += sum[1] * (ss[i+1].h - ss[i].h);
- }
- printf("Test case #%d\nTotal explored area: %.2lf\n\n",cas++ , ret);
- }
- return 0;
- }
hdu1828 Picture
题意:矩形周长并
思路:与面积不同的地方是还要记录竖的边有几个(numseg记录),并且当边界重合的时候需要合并(用lbd和rbd表示边界来辅助)
线段树操作:update:区间增减 query:直接取根节点的值
- #include <cstdio>
- #include <cstring>
- #include <cctype>
- #include <algorithm>
- using namespace std;
- #define lson l , m , rt << 1
- #define rson m + 1 , r , rt << 1 | 1
-
- const int maxn = 22222;
- struct Seg{
- int l , r , h , s;
- Seg() {}
- Seg(int a,int b,int c,int d):l(a) , r(b) , h(c) , s(d) {}
- bool operator < (const Seg &cmp) const {
- if (h == cmp.h) return s > cmp.s;
- return h < cmp.h;
- }
- }ss[maxn];
- bool lbd[maxn<<2] , rbd[maxn<<2];
- int numseg[maxn<<2];
- int cnt[maxn<<2];
- int len[maxn<<2];
- void PushUP(int rt,int l,int r) {
- if (cnt[rt]) {
- lbd[rt] = rbd[rt] = 1;
- len[rt] = r - l + 1;
- numseg[rt] = 2;
- } else if (l == r) {
- len[rt] = numseg[rt] = lbd[rt] = rbd[rt] = 0;
- } else {
- lbd[rt] = lbd[rt<<1];
- rbd[rt] = rbd[rt<<1|1];
- len[rt] = len[rt<<1] + len[rt<<1|1];
- numseg[rt] = numseg[rt<<1] + numseg[rt<<1|1];
- if (lbd[rt<<1|1] && rbd[rt<<1]) numseg[rt] -= 2;
- }
- }
- void update(int L,int R,int c,int l,int r,int rt) {
- if (L <= l && r <= R) {
- cnt[rt] += c;
- PushUP(rt , l , r);
- return ;
- }
- int m = (l + r) >> 1;
- if (L <= m) update(L , R , c , lson);
- if (m < R) update(L , R , c , rson);
- PushUP(rt , l , r);
- }
- int main() {
- int n;
- while (~scanf("%d",&n)) {
- int m = 0;
- int lbd = 10000, rbd = -10000;
- for (int i = 0 ; i < n ; i ++) {
- int a , b , c , d;
- scanf("%d%d%d%d",&a,&b,&c,&d);
- lbd = min(lbd , a);
- rbd = max(rbd , c);
- ss[m++] = Seg(a , c , b , 1);
- ss[m++] = Seg(a , c , d , -1);
- }
- sort(ss , ss + m);
- int ret = 0 , last = 0;
- for (int i = 0 ; i < m ; i ++) {
- if (ss[i].l < ss[i].r) update(ss[i].l , ss[i].r - 1 , ss[i].s , lbd , rbd - 1 , 1);
- ret += numseg[1] * (ss[i+1].h - ss[i].h);
- ret += abs(len[1] - last);
- last = len[1];
- }
- printf("%d\n",ret);
- }
- return 0;
- }
练习
hdu3265 Posters
hdu3642 Get The Treasury
poj2482 Stars in Your Window
poj2464 Brownie Points II
hdu3255 Farming
ural1707 Hypnotoad’s Secret
uva11983 Weird Advertisement
多颗线段树问题
此类题目主用特点是区间不连续,有一定规律间隔,用多棵树表示不同的偏移区间
题意:
维护一个有序数列{An},有三种操作:
1、添加一个元素。
2、删除一个元素。
3、求数列中下标%5 = 3的值的和。
由于有删除和添加操作,所以离线离散操作,节点中cnt存储区间中有几个数,sum存储偏移和
- #include<iostream>
- #include<cstdio>
- #include<cstring>
- #include<algorithm>
- using namespace std;
- const int maxn=100002;
-
- #define lson l , m , rt << 1
- #define rson m + 1 , r , rt << 1 | 1
-
- __int64 sum[maxn<<2][6];
- int cnt[maxn << 2];
-
- char op[maxn][20];
- int a[maxn];
-
- int X[maxn];
-
- void PushUp(int rt)
- {
- cnt[rt] = cnt[rt<<1] + cnt[rt<<1|1];
-
- int offset = cnt[rt<<1];
- for(int i = 0; i < 5; ++i)
- {
- sum[rt][i] = sum[rt<<1][i];
- }
- for(int i = 0; i < 5; ++i)
- {
- sum[rt][(i + offset) % 5] += sum[rt<<1|1][i];
- }
- }
-
- void Build(int l, int r, int rt)
- {
- cnt[rt] = 0;
- for(int i = 0; i < 5; ++i) sum[rt][i] = 0;
- if( l == r ) return;
- int m = ( l + r )>>1;
- Build(lson);
- Build(rson);
- }
-
- void Updata(int p, int op, int l, int r, int rt)
- {
- if( l == r )
- {
- cnt[rt] = op;
- sum[rt][1] = op * X[l-1];
- return ;
- }
- int m = ( l + r ) >> 1;
- if(p <= m)
- Updata(p, op, lson);
- else
- Updata(p, op, rson);
-
- PushUp(rt);
- }
-
- int main()
- {
- int n;
- while(scanf("%d", &n) != EOF)
- {
- int nn = 0;
- for(int i = 0; i < n; ++i)
- {
- scanf("%s", &op[i]);
-
- if(op[i][0] != 's')
- {
- scanf("%d", &a[i]);
- if(op[i][0] == 'a')
- {
- X[nn++] = a[i];
- }
- }
- }
-
- sort(X,X+nn);
- nn = unique(X, X + nn) - X;
-
- Build(1, nn, 1);
-
- for(int i = 0; i < n; ++i)
- {
- int pos = upper_bound(X, X+nn, a[i]) - X;
- if(op[i][0] == 'a')
- {
- Updata(pos, 1, 1, nn, 1);
- }
- else if(op[i][0] == 'd')
- {
- Updata(pos, 0, 1, nn, 1);
- }
- else printf("%I64d\n",sum[1][3]);
- }
- }
- return 0;
- }
题目:给出n个数,每次将一段区间内满足(i-l)%k==0 (r>=i>=l) 的数ai增加c, 最后单点查询。
这种题目更新的区间是零散的,如果可以通过某种方式让离散的都变得连续,那么问题就可以用线段树完美解决。解决方式一般也是固定的,那就是利用题意维护多颗线段树。此题虚维护55颗,更新最终确定在一颗上,查询则将查询点被包含的树全部叠加。
- #include<iostream>
- #include<cstdio>
- #include<cstring>
- #include<cmath>
- #include<algorithm>
- #include<set>
- #include<vector>
- #include<string>
- #include<map>
- #define eps 1e-7
- #define LL long long
- #define N 500005
- #define zero(a) fabs(a)<eps
- #define lson step<<1
- #define rson step<<1|1
- #define MOD 1234567891
- #define pb(a) push_back(a)
- using namespace std;
- struct Node{
- int left,right,add[55],sum;
- int mid(){return (left+right)/2;}
- }L[4*N];
- int a[N],n,b[11][11];
- void Bulid(int step ,int l,int r){
- L[step].left=l;
- L[step].right=r;
- L[step].sum=0;
- memset(L[step].add,0,sizeof(L[step].add));
- if(l==r) return ;
- Bulid(lson,l,L[step].mid());
- Bulid(rson,L[step].mid()+1,r);
- }
- void push_down(int step){
- if(L[step].sum){
- L[lson].sum+=L[step].sum;
- L[rson].sum+=L[step].sum;
- L[step].sum=0;
- for(int i=0;i<55;i++){
- L[lson].add[i]+=L[step].add[i];
- L[rson].add[i]+=L[step].add[i];
- L[step].add[i]=0;
- }
- }
- }
- void update(int step,int l,int r,int num,int i,int j){
- if(L[step].left==l&&L[step].right==r){
- L[step].sum+=num;
- L[step].add[b[i][j]]+=num;
- return;
- }
- push_down(step);
- if(r<=L[step].mid()) update(lson,l,r,num,i,j);
- else if(l>L[step].mid()) update(rson,l,r,num,i,j);
- else {
- update(lson,l,L[step].mid(),num,i,j);
- update(rson,L[step].mid()+1,r,num,i,j);
- }
- }
- int query(int step,int pos){
- if(L[step].left==L[step].right){
- int tmp=0;
- for(int i=1;i<=10;i++) tmp+=L[step].add[b[i][pos%i]];
- return a[L[step].left]+tmp;
- }
- push_down(step);
- if(pos<=L[step].mid()) return query(lson,pos);
- else return query(rson,pos);
- }
- int main(){
- int cnt=0;
- for(int i=1;i<=10;i++) for(int j=0;j<i;j++) b[i][j]=cnt++;
- while(scanf("%d",&n)!=EOF){
- for(int i=1;i<=n;i++) scanf("%d",&a[i]);
- Bulid(1,1,n);
- int q,d;
- scanf("%d",&q);
- while(q--){
- int k,l,r,m;
- scanf("%d",&k);
- if(k==2){
- scanf("%d",&m);
- printf("%d\n",query(1,m));
- }
- else{
- scanf("%d%d%d%d",&l,&r,&d,&m);
- update(1,l,r,m,d,l%d);
- }
- }
- }
- 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[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 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 <<span style="font-family: 'Courier New' !important;"> 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 <<span style="font-family: 'Courier New' !important;"> 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 <<span style="font-family: 'Courier New' !important;"> 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]),就相当于单节点更新,单节点更新只是区间更新的特例。