线段树_单点更新

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

补充几点说明：

（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] 表示需要查询的区间

代码如下：

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

代码如下：

#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次。

代码如下：

#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宽度的通知，若能则找到其叶子结点返回其值。

代码如下：

#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 个空位的下标。

代码如下：

#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个~

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

代码如下：

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

总结：

对于一些不是很明显可以用线段树来做的题目，我们要提取它们的区间特征，也就是用什么来做区间下标，需要每个区间保存什么内容，每次修改什么值，怎样更新内容。我认为用什么来做区间下标和每个区间保存什么内容尤为重要，只要说清楚这个两个问题，基本思路就出来了。

采用线段树而不是其他方法，主要是因为线段树的高效，并不是说一般方法做不到。所以很难说什么样的问题归到线段树的类型。线段树的另一个特点就是空间开销非常大，因为需要保存每一块区间的数据。典型的空间换时间。

单点更新是线段树的最基本内容，因为还不需要用到延迟标识，每次更新都是更新到底。