线段树单点更新

最新推荐文章于 2018-10-17 13:15:47 发布

include-LSS

最新推荐文章于 2018-10-17 13:15:47 发布

阅读量654

点赞数

本文链接：https://blog.csdn.net/u010126535/article/details/8984145

版权

最近开始接触线段树的内容，我发现线段树非常灵活和强大，很多问题都可以用线段树来做。但是，对于初次接触的人来说，可能比较难。根据大牛的博客，我开始一步步练习。现在把已经做好的单点更新的习题贴出来，讲讲自己的想法。欢迎拍砖~

补充几点说明：

（1）我采用静态方法构建线段树，即用数组来做，左子树为 2*i，右子树为 2*i+1。按照保守估计，数组空间一般开Ｎ*4，用到的空间实质上是Ｎ*2-1，但是考虑到中间会有一些空间没有使用，特别是最底层的。粗略地想，假设最底层只有最后两个空间有用到，那么这一层前面的空余空间就约为Ｎ*2了。所以Ｎ*4是足够的。

（2）这部分一般来说涉及到下面几个函数：pushUp（由下往上更新修改后的数据），build（初始化线段树），update（修改叶子结点的数据），query（查询区间数据）

（3）线段树本身并不保存当前区间具体是什么，而是由函数传递两个变量l, r 来记录当前的具体区间，这样做可节省大量空间开销，详细参见代码。

（4）前文已出现过的，后面不再重复，包括函数参数的说明。

题目：

hdu 1166 敌兵布阵

大意：敌人有N个营地，一开始知道每个营地的人数。

            接下来会询问四种命令：(1) Add i j，i 和 j 为正整数，表示第i个营地增加j个人（j不超过30）；
                                                        (2) Sub i j ，i 和 j 为正整数，表示第i个营地减少j个人（j不超过30）；
                                                        (3) Query i j , i 和 j 为正整数，i <= j，表示询问第i到第j个营地的总人数；
                                                        (4) End 表示结束，这条命令在每组数据最后出现。

遇到Query则作出回答，遇到End则结束本次数据的询问。其他则修改相关营地的数据。（显然，Sub 可以归并到 Add 操作）

思路：

对于每一组数据，用build初始化线段树，每个结点保存区间[i, j]内的总人数。叶子结点即是每个营地的人数，这个由输入给出，对于内结点，则采取pushUp由下往上传递值。

对于Add 操作（包括Sub操作），可以用update来修改叶子结点的值，与build相似，内结点采取pushUp更新其值。

对于Query 操作，用query来查看区间的人数。对于没有在一个存储区间表示出来的空间，则采取同时向两边走，覆盖后返回其值的方式取值，详细见代码。

函数接口：

pushUp(int cur) // cur 表示当前数组的实际下标。

build(int l, int r, int cur) // [l, r] 表示当前数组存储的值的区间，即前面所说的由函数传入值表示。

update(int i, int val, int l, int r, int cur) // i 表示需要更新值的数组实际下标，即线段树的相应的叶子结点，val 表示需要增加的值（对于Sub操作，主函数传入-val）。

query(int curL, int curR, int l, int r, int cur) // [curL, curR] 表示需要查询的区间

代码如下：

[cpp]view plaincopy 
   
 #include<cstdio>  
 using namespace std;  
 const int MAX = 50000 + 10;         //数据范围  
 int sum[MAX << 2];          //保存各个范围的sum值  
 void pushUp(int cur){  
     //检查下层数据，更新当前的sum值  
     sum[cur] = sum[cur << 1] + sum[cur << 1 | 1];  
 }  
 void build(int l, int r, int cur){  
     //初始化线段树  
     if(l == r){  
         scanf("%d",&sum[cur]);  
         return;  
     }  
     int mid = (l + r) >> 1;  
     build(l, mid, cur << 1);  
     build(mid + 1, r, cur << 1 | 1);  
     //更新当前的sum  
     pushUp(cur);  
 }  
 void update(int i, int val, int l, int r, int cur){  
     //更新范围i的值，并向上传递sum  
     if(l == r){  
         sum[cur] += val;  
         return;  
     }  
     int mid = (l + r) >> 1;  
     if(i <= mid){  
         update(i, val, l, mid, cur << 1);  
     }  
     else{  
         update(i, val, mid+1, r, cur << 1 | 1);  
     }  
     //传递sum值  
     pushUp(cur);  
 }  
 int query(int curL, int curR, int l, int r, int cur){  
     //查询curL 至 curR 的 sum  
     if(curL <= l && curR >= r){  
         return sum[cur];  
     }  
     int mid = (l + r) >> 1;  
     int result = 0;  
     if(curL <= mid){  
         result += query(curL, curR, l, mid, cur << 1);  
     }  
     if(curR > mid){  
         result += query(curL, curR, mid+1, r, cur << 1 | 1);  
     }  
     return result;  
 }  
 int main(){  
     int k = 1;  //当前例子编号  
     int t;      //样例数  
     int n;      //营地数  
     scanf("%d",&t);  
     while(t--){  
         scanf("%d",&n);  
         build(1,n,1);  
         printf("Case %d:\n",k++);  
         char s[10];  
         int i,j;  
         while(scanf("%s",s) != EOF){  
             if(s[0] == 'E')break;  
             scanf("%d %d",&i, &j);  
             switch(s[0]){  
                 case 'A': update(i, j, 1, n, 1); break;  
                 case 'S': update(i, -j, 1, n, 1); break;  
                 case 'Q': printf("%d\n",query(i, j, 1, n, 1)); break;  
             }  
         }  
     }  
     return 0;  
 }  

hdu 1754 I Hate It

大意：给出N个学生的成绩，下面有M个操作。

接下来有M行。每一行有一个字符 C (只取'Q'或'U') ，和两个正整数A，B。

当C为'Q'的时候，表示这是一条询问操作，它询问ID从A到B(包括A,B)的学生当中，成绩最高的是多少。

当C为'U'的时候，表示这是一条更新操作，要求把ID为A的学生的成绩更改为B。

思路：和上题类似，不同的是这次线段树保存的不是总和，而是最大值。

build 与 update 和上题的一样，只是 pushUp 和 query 不再是累加两个子结点，而是比较两个子结点（如果有的话），然好返回其较大值。

函数接口：

基本上和上题相同，只是update不再是累加val，而是直接修改数据为val。

代码如下：

[cpp]view plaincopy 
   
 #include<cstdio>  
 #include<cstring>  
 using namespace std;  
 const int MAX = 200000 + 10;  
 int highest[MAX << 2];          //构建最高成绩线段树  
 void pushUp(int cur){  
     //更新 highest 的值  
     if(highest[cur << 1] > highest[cur << 1 | 1]){  
         highest[cur] = highest[cur << 1];  
     }  
     else{  
         highest[cur] = highest[cur << 1 | 1];  
     }  
 }  
 void build(int l, int r, int cur){  
     //初始化线段树  
     if(l == r){  
         scanf("%d",&highest[cur]);  
         return;  
     }  
     int mid = (l + r) >> 1;  
     build(l, mid, cur << 1);  
     build(mid+1, r, cur << 1 | 1);  
     //由下往上传递 highest 值  
     pushUp(cur);  
 }  
 void update(int i, int val, int l, int r, int cur){  
     //更新 i 的值 为 val  
     if(l == r){  
         highest[cur] = val;  
         return;  
     }  
     int mid = (l + r) >> 1;  
     if(i <= mid){  
         update(i, val, l, mid, cur << 1);  
     }  
     else{  
         update(i, val, mid+1, r, cur << 1 | 1);  
     }  
     pushUp(cur);  
 }  
 int query(int a, int b, int l, int r, int cur){  
     //返回[a, b]的最高成绩  
     if(a <= l && b >= r){  
         return highest[cur];  
     }  
     int mid = (l + r) >> 1;  
     int result = 0,temp;  
     if(a <= mid){  
         temp = query(a, b, l, mid, cur << 1);  
         if(result < temp){  
             result = temp;  
         }  
     }  
     if(b > mid){  
         temp = query(a, b, mid+1, r, cur << 1 | 1);  
         if(result < temp){  
             result = temp;  
         }  
     }  
     return result;  
 }  
 int main(){  
     int n;      //人数  
     int m;      //操作次数  
     while(scanf("%d %d",&n,&m) != EOF){  
         build(1,n,1);  
         char s;  
         int a,b;  
         for(int i = 0; i < m; i++){  
             getchar();  
             scanf("%c %d %d",&s,&a,&b);  
             switch(s){  
                 case 'U': update(a, b, 1, n, 1); break;  
                 case 'Q': printf("%d\n",query(a, b, 1, n, 1)); break;  
             }  
         }  
     }  
     return 0;  
 }  

hdu 1394 Minimun Inversion Number

大意：给定一个N和关于0-N-1的序列，通过不断把首元素放到最后得出变换后的序列和其逆序数，求出最小逆序数（包括一开始那个序列）。

思路：

（1）用线段树求初始序列的逆序数。用build构建线段树保存区间[l, r]中出现过的元素个数（pushUp 求子树之和），对于每一个query查询[0, val] 已经出现过的元素个数（累加这个值即逆序数），然后用update 表示 val 已出现过一次。

（2）得到最初的逆序数后，对于后面出现的每一个序列，其逆序数为前一个序列的逆序数count 减去首元素的值val，再加上 N - val - 1，即 count = count - val + N - val - 1（注意到，序列中的每个元素均小于N，那么首元素val值则表示其后有val 个元素小于它，所以将val 移到最后即逆序数要减去这个值；而移动后，val 前面必有 N - val - 1 个元素大于它，则逆序数需要加上这个值。）

函数接口：

和之前的类似，只是update没有了val，因为这次只需要将 i 结点表示出现过1次。

代码如下：

[cpp]view plaincopy 
   
 #include<cstdio>  
 using namespace std;  
 const int MAX = 5000 + 10;  
 int sum[MAX << 2];              //保存每个范围的数字出现次数  
 void build(int l, int r, int cur){  
     //创建空线段树  
     sum[cur] = 0;  
     if(l == r){  
         return;  
     }  
     int mid = (l + r) >> 1;  
     build(l, mid, cur << 1);  
     build(mid+1, r, cur << 1 | 1);  
 }  
 void pushUp(int cur){  
     //更新范围出现次数  
     sum[cur] = sum[cur << 1] + sum[cur << 1 | 1];  
 }  
 void update(int i, int l, int r, int cur){  
     //更新结点i出现一次  
     if(l == r){  
         sum[cur] ++;  
         return;  
     }  
     int mid = (l + r) >> 1;  
     if(i <= mid){  
         update(i, l, mid, cur << 1);  
     }  
     else{  
         update(i, mid+1, r, cur << 1 | 1);  
     }  
     pushUp(cur);  
 }  
 int query(int curL, int curR, int l, int r, int cur){  
     //查询[curL, curR]出现的元素个数  
     if(curL <= l && curR >= r){  
         return sum[cur];  
     }  
     int mid = (l + r) >> 1;  
     int result = 0;  
     if(curL <= mid){  
         result += query(curL, curR, l, mid, cur << 1);  
     }  
     if(curR > mid){  
         result += query(curL, curR, mid+1, r, cur << 1 | 1);  
     }  
     return result;  
 }  
 int main(){  
     int n;          //元素个数  
     int A[MAX];     //保存元素  
     int count;      //保存当前结果  
     int result;     //保存结果  
     while(~scanf("%d",&n)){  
         count = 0;  
         build(0, n-1, 1);  
         for(int i = 0; i < n; i++){  
             scanf("%d",&A[i]);  
             count += query(A[i], n-1, 0, n-1, 1);  
             update(A[i], 0, n-1, 1);  
         }  
         result = count;  
         for(int i = 0; i < n; i++){  
             count += n - A[i] - A[i] - 1;  
             if(result > count){  
                 result = count;  
             }  
         }  
         printf("%d\n",result);  
     }  
     return 0;  
 }  

hdu 2795 Billboard

大意：已知一块黑板高为h（有h行），宽为w。下面有n张通知需要张贴。张贴规则为尽量高，尽量靠左边，即当前最高行，和那行的最左边，可以理解为从左上角开始张贴。给出每张通知的宽度（默认一行至少可以容纳一张通知），求它张贴的行号（由上至下1到h），如果贴不下，则返回-1.

思路：

（1）用黑板的高度作为区间下标构建线段树，保存当前区间所能容纳的最大宽度。build的时候每个区间保存的都是w. 为了节省时间，这里的update操作归并到query里，因为每次查询都需要查询到特定的叶结点并返回其区间下标，这时就可以修改其值并在过程中传递上去。pushUp更新当前区间能容纳的最大宽度。

（2）每次传入当前通知宽度前，都需要查看根结点的数值是否大于当前宽度，因为若根结点都存不下，那这个通知就不能张贴了。

函数接口：

和之前的类似，只是query 传递 curW，查看当前区间是否能存放下curW宽度的通知，若能则找到其叶子结点返回其值。

代码如下：

[cpp]view plaincopy 
   
 #include<cstdio>  
 using namespace std;  
 const int MAX = 2000000 + 10;  
 int maxWidth[MAX << 2];         //保存范围内的最大宽度，用高度构建线段树  
 int h, w, n;            //输入  
 void pushUp(int cur){  
     //更新宽度  
     if(maxWidth[cur << 1] > maxWidth[cur << 1 | 1]){  
         maxWidth[cur] = maxWidth[cur << 1];  
     }  
     else{  
         maxWidth[cur] = maxWidth[cur << 1 | 1];  
     }  
 }  
 void build(int l, int r, int cur){  
     //初始化线段树，保存范围内可容纳最大宽度  
     maxWidth[cur] = w;  
     if(l == r)return;  
     int mid = (l + r) >> 1;  
     build(l, mid, cur << 1);  
     build(mid+1, r, cur << 1 | 1);  
 }  
 int query(int curW,int l, int r, int cur){  
     //查询[l, r]是否能容纳 curW 宽度， 若能返回行号  
     if(l == r){  
         maxWidth[cur] -= curW;  
         return l;  
     }  
     int mid = (l + r) >> 1;  
     int result = (maxWidth[cur << 1] >= curW) ? query(curW, l, mid, cur << 1) : query(curW, mid+1, r, cur << 1 | 1);  
     pushUp(cur);  
     return result;  
 }  
 int main(){  
     while(~scanf("%d %d %d", &h, &w, &n)){  
         if(h > n){  
             //因为张贴的宽度不可能大于w， 即不可能超过n行  
             h = n;  
         }  
         build(1, h, 1);  
         int temp;  
         for(int i = 0; i < n; i++){  
             scanf("%d",&temp);  
             if(maxWidth[1] < temp){  
                 printf("-1\n");  
             }  
             else{  
                 printf("%d\n",query(temp, 1, h, 1));  
             }  
         }  
     }  
     return 0;  
 }  

pku 2828 Buy Tickets

大意：插队问题。已知有N个人，一开始队列为空，编号从1到N，可以看作所有人都排在0号的后面（0号不存在）。分别读入N个人的pos 和 val，pos 表示插队在 pos号人的后面（如pos = 0, 即插入到第1位），val 可以看作是读入的人的一个标识。求经过N次插队以后（插队一定成功），最终的队列（输出这个队列每个人的标识值）。

思路：

（1）如果按输入顺序模拟插队，每次都要做很多的移动，效率低下。如果从最后一个人往前看，他的pos 表示的就是前面有 pos 个空位。根据这个他们每次插队后的位置就是最终的位置，因为没有后面的人会让他们后移（因为是从后往前看嘛~）。可以用build 构建线段树保存区间的空位数，区间下标为队列的编号。pushUp 由下往上传递求和信息。query 查询前i 个空位，并返回第i + 1 个空位的区间下标（这个可以从函数代码里那个if 语句看出，左区间是包括mid 的，但比较的时候没有包括进去，其实每次返回的就是上一次的 mid）。和上题相似，query 找到下标后直接修改区间的值，避免重复计算，然好用pushUp 传递其值。

（2）对于每次query 返回的值，我采用多开一个数组来保存每次的结果，最后再顺序输出即可。

函数接口：

基本和前面出现的类似，需要注意的是query 传递的 i 的含义。每次返回的是第i + 1 个空位的下标。

代码如下：

[cpp]view plaincopy 
   
 #include<cstdio>  
 using namespace std;  
 const int MAX = 200000 + 10;  
 struct person{  
     int pos;  
     int val;  
 };  
 int sum[MAX << 2];      //保存线段树，空位数  
 void pushUp(int cur){  
     //更新空位数  
     sum[cur] = sum[cur << 1] + sum[cur << 1 | 1];  
 }  
 void build(int l, int r, int cur){  
     //构建线段树  
     if(l == r){  
         sum[cur] = 1;  
         return;  
     }  
     int mid = (l + r) >> 1;  
     build(l, mid, cur << 1);  
     build(mid+1, r, cur << 1 | 1);  
     pushUp(cur);  
 }  
 int query(int i, int l, int r, int cur){  
     //找到前i个空位，并返回第i+1个空位的下标  
     if(l == r){  
         sum[cur] = 0;  
         return l;  
     }  
     int mid = (l + r) >> 1;  
     int result;  
     if(i < sum[cur << 1]){  
         result = query(i, l, mid, cur << 1);  
     }  
     else{  
         result = query(i-sum[cur << 1], mid+1, r, cur << 1 | 1);  
     }  
     pushUp(cur);  
     return result;  
 }  
 int main(){  
     int n;              //人数  
     person A[MAX];      //保存每个人的值  
     int R[MAX];         //结果序列  
     while(~scanf("%d",&n)){  
         for(int i = 0; i < n; i++){  
             scanf("%d%d",&A[i].pos,&A[i].val);  
         }  
         build(1, n, 1);  
         for(int i = n-1; i >= 0; i--){  
             int index = query(A[i].pos, 1, n, 1);  
             R[index] = A[i].val;  
         }  
         printf("%d",R[1]);  
         for(int i = 2; i <= n; i++){  
             printf(" %d",R[i]);  
         }  
         printf("\n");  
     }  
     return 0;  
 }  

pku 2886 Who Gets the Most Candies?

大意：N个小朋友围成一圈玩游戏，每个人手上拿着一张有数字的卡片。输入序列给出每个小朋友的编号，一开始由第k个小朋友开始玩。被点到的小朋友跳出圈，手上卡片的数字val 若是正数，则顺时针数val 后点到小朋友；若为负值，则逆时针数-val 后点到小朋友。一直这样下去直到所有小朋友跳出圈。另外，每个跳出圈的小朋友都可以得到一定的糖果，糖果数就是 m（他是第 m 个跳出圈的）的划分，也就是m 的因子数。问可以得到最多糖果的小朋友的名字和他得到的糖果数（输入给出小朋友的名字和他手上的卡片数字）。如果有多个获得最多糖果的孩子，则输出最早跳出圈那个。

思路：

（1）如果每次游戏都玩到最后，那么需要保存所有人的糖果数，最后再比较输出。网上有人提到可以利用反素数的概念（百度百科：对于任何正整数x,其约数的个数记做g(x).例如g(1)=1,g(6)=4.如果某个正整数x满足:对于任意i(0<i<x),都有g(i)<g(x),则称x为反素数.），那么对于每个给定的N，我们进行到1-N 的最小反素数时就可以退出，这个孩子得到的就是最多糖果。所以我首先通过下面代码打表获得500000以内的所有最小反素数和获得的最大糖果，只有35个~

[cpp]view plaincopy 
   
 #include<cstdio>  
 #include<fstream>  
 using namespace std;  
 int A[500010];  
 int R[500010];  
 int main(){  
     for(int i = 1; i <= 500000; i++){  
         for(int j = 1; i * j <= 500000; j++){  
             A[i * j]++;  
         }  
     }  
     int n = 0;  
     for(int i = 1; i <= 500000; i++){  
         int max = 1;  
         for(int j = 1; j <= i; j++){  
             if(A[max] < A[j]){  
                 max = j;  
             }  
         }  
         int k;  
         for(k = 0; k < n; k++){  
             if(R[k] == max){  
                 break;  
             }  
         }  
         if(k == n){  
             R[n++] = max;  
         }  
     }  
     ofstream write("1.txt");  
     for(int i = 0; i < n; i++){  
         write<<R[i]<<' '<<A[R[i]]<<endl;  
     }  
     return 0;  
 }  

（2）下面就需要用到线段树来快速求解类约瑟夫问题。因为普通方法往往需要遍历整个序列，当数据量很大时，必然超时。用build 构建线段树保存当前区间的未跳出人数，pushUp 求和向上传递，query 返回区间下标并删除该元素即数量减1。这个其实并不困难，只要想到了，和上面的也是差不多的。

（3）关键在于相对下标的求解。相对下标是指删除元素后，某元素在删除后序列的下标。query 每次返回的是绝对下标即原序列的下标（这是因为每次都需要取到该孩子手上的数字），我们的目的在于已知当前的相对下标（一开始给出的k就是相对下标），如何根据卡片的数字求出下一个相对下标。这个我弄了很久还是有错，最后参考了网上的思路，得到下面的递推公式。

if( k > 0){

next相对下标 = （cur相对下标 + 偏移量 - 1）% 当前人数

if next相对下标 <= 0{

next相对下标 += 当前人数

}

else{

next相对下标 = （cur相对下标 + 偏移量）% 当前人数

if next相对下标 <= 0{

next相对下标 += 当前人数

}

需要注意到，当k 大于0 时，因为当前小孩已经跳出圈，那么现在的下标其实是当前小孩的下一个小孩的下标，所以偏移量要 -1. 当k 小于0时，则不需要作此变化。取模是为了将编号控制在人数内，上面的当前人数是不包括这个卡片的持有人，因为他已经跳出圈了。另外，因为结果有可能为非正数（数组下标是1-N），这时就需要加上模数。（举个例子，若1的前1人即0，这时加上模数就是N了，也就满足围成圈。而C++的负数取模和正数取模类似，只是加多个负号。如 -7 % 5 = -2）

代码如下：

[cpp]view plaincopy 
   
 #include<cstdio>  
 using namespace std;  
 //（最小）反素数表  
 const int maxTurn[35]={1,2,4,6,12,24,36,48,60,120,180,240,360,720,840,1260,1680,2520,5040,7560,10080,15120,20160,25200,27720,45360,50400,55440,83160,110880,166320,221760,277200,332640,498960};  
 //最大糖果表  
 const int maxCandy[35]={1,2,3,4,6,8,9,10,12,16,18,20,24,30,32,36,40,48,60,64,72,80,84,90,96,100,108,120,128,144,160,168,180,192,200};  
 const int MAX = 500000 + 10;  
 struct child{  
     char name[11];  
     int k;  
 };  
 child A[MAX];             //保存输入数据  
 int leftSum[MAX << 2];  //保存区间内剩余人数  
 void pushUp(int cur){  
     //更新区间剩余人数  
     leftSum[cur] = leftSum[cur << 1] + leftSum[cur << 1 | 1];  
 }  
 void build(int l, int r, int cur){  
     //初始化线段树  
     if(l == r){  
         leftSum[cur] = 1;  
         return;  
     }  
     int mid = (l + r) >> 1;  
     build(l, mid, cur << 1);  
     build(mid+1, r, cur << 1 | 1);  
     pushUp(cur);  
 }  
 int query(int i, int l, int r, int cur){  
     //删除第i个元素并返回原下标  
     if(l == r){  
         leftSum[cur] = 0;  
         return l;  
     }  
     int mid = (l + r) >> 1;  
     int result;  
     if(i <= leftSum[cur << 1]){  
         result = query(i, l, mid, cur << 1);  
     }  
     else{  
         result = query(i - leftSum[cur << 1], mid+1, r, cur << 1 | 1);  
     }  
     pushUp(cur);  
     return result;  
 }  
 int main(){  
     int n,m;  
     while(~scanf("%d%d",&n,&m)){  
         for(int i = 1; i <= n; i ++){  
             scanf("%s%d",A[i].name,&A[i].k);  
         }  
         build(1, n, 1);  
         int luckyNumber = 0;  
         while(luckyNumber < 35 && maxTurn[luckyNumber] <= n){  
             luckyNumber++;  
         }  
         luckyNumber--;  
         int pos = 0;  
         A[pos].k = 0;  
         int mod = n;  
         for(int i = 0; i < maxTurn[luckyNumber]; i++,mod--){  
             if(A[pos].k > 0){  
                 m = (m + A[pos].k - 1) % mod;  
             }  
             else{  
                 m = (m + A[pos].k) % mod;  
             }  
             if(m <= 0){  
                 m += mod;  
             }  
             pos = query(m, 1, n, 1);  
         }  
         printf("%s %d\n",A[pos].name, maxCandy[luckyNumber]);  
     }  
     return 0;  
 }  