蓝桥杯 算法训练 操作格子

问题描述

有n个格子，从左到右放成一排，编号为1-n。

共有m次操作，有3种操作类型：
1.修改一个格子的权值，
2.求连续一段格子权值和，
3.求连续一段格子的最大值。

对于每个2、3操作输出你所求出的结果。

输入格式

第一行2个整数n，m。

接下来一行n个整数表示n个格子的初始权值。

接下来m行，每行3个整数p,x,y，p表示操作类型，

p=1时表示修改格子x的权值为y，

p=2时表示求区间[x,y]内格子权值和，

p=3时表示求区间[x,y]内格子最大的权值。

输出格式

有若干行，行数等于p=2或3的操作总数。

每行1个整数，对应了每个p=2或3操作的结果。

样例输入

4 3
1 2 3 4
2 1 3
1 4 3
3 1 4

样例输出

6
3

数据规模与约定

对于20%的数据n <= 100，m <= 200。
对于50%的数据n <= 5000，m <= 5000。
对于100%的数据1 <= n <= 100000，m <= 100000，0 <= 格子权值 <= 10000。

解题思路

由数据规模得，使用int数据类型即可。

注意，区间计数是从1开始的。

按照一般的思路提交，可是超时，刚好看到题目锦囊提示使用线段树。

线段树（Segment Tree）是一种二叉搜索树，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。

对于线段树中的每一个非叶子节点[a,b]，它的左子树表示的区间为[a,(a+b)/2]，右子树表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树。叶节点数目为N，即整个线段区间的长度。

简单的说，顾名思义，就是将一段线段（如：1-10），不断的划分，形成一棵树。

在这里，使用数组存放满二叉树，那数组的大小是多少呢？

在构建和利用线段树的过程中，充分使用了分治的思想。

题目中说，“p=1时表示修改格子x的权值为y”，这个x代表的是格子的位置。

创建的是1到n的线段树，其实每个结点的权重是不需要额外存储的，只需知道权重的和与最大值。叶子结点的sum和max即为权重。

注意，数组从1开始存储，利于二叉树结点位置的确定。

找了好几个小时的错误，原来是在找最大值的地方，把right写成了left，悲哀！忽然有种高中做数学题的悲哀。

代码实现

数组或容器

只能满足前50%的数据。

注意，在case语句中最好不要定义并初始化变量，常引起错误。

case后加大括号，可定义局部变量。

 
 
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void) {
    int n, m;
    cin >> n >> m;
    vector<int> v;
    while(n--) {
        int tmp;
        cin >> tmp;
        v.push_back(tmp);
    }
    while(m--) {
        int p, x, y;
        cin >> p >> x >> y;
        int sum = 0;
        int max = 0;
        switch(p) {
        case 1 :
            v[x-1] = y;
            break;
        case 2 :
            for(int i = x; i <= y; i++) {
                sum += v[i - 1];
            }
            cout << sum << endl;
            break;
        case 3 :
            for(int i = x; i <= y; i++) {
                if(v[i - 1] > max) {
                    max = v[i - 1];
                }
            }
            cout << max << endl;
            break;
        default :
            break;
        }
    }
    return 0;
}

线段树

这里使用数组存放线段树，其实和线段树相关的操作只涉及到4种：

1. 构建线段树
2. 改变线段树中某个结点的值
3. 求某区间的结点权重的和
4. 求某区间的结点权重的最大值

只是存放线段树的数组的大小还没搞清楚，从coolnote下载的测试数据表明：
当n为100000时，最后一个不为0的数组索引为262142。

给定【1，n】，建立线性二叉树，其层数是确定的，根据二分原理，其层数为m=上取整(log(n))+1 , 那么数组上界为这棵满二叉树所有节点个数： 2^m-1=2^(上取整(log(n))+1)-1

举个例子，n=5，树层数为m=4,上界为2^4-1=15
n=6，树层数为m=4,上界为2^4-1=15
n=100000,树层数为m=18,上界为2^18-1=262143

 
 
#include <iostream>
#include <cstring>
using namespace std;
 
typedef struct SNode {
    int max, sum;
    int left, right;
} SNode;
 
SNode t[300000];
 
int two_max(int a, int b) {
    return a > b ? a : b;
}
 
void build(int pos, int l, int r) {
    t[pos].left = l;
    t[pos].right = r;
    t[pos].max = 0;
    t[pos].sum = 0;
    if(l == r) {
        return;
    }
    build(pos * 2, l, (l + r) / 2);
    build(pos * 2 + 1, (l + r) / 2 + 1, r);
}
 
void change(int pos, int v, int w) {
    if(t[pos].left == v && t[pos].right == v) {
        t[pos].sum = w;
        t[pos].max = w;
        return;
    }
    int middle = (t[pos].left + t[pos].right) / 2;
    if(v <= middle) {
        change(pos * 2, v, w);
    } else {
        change(pos * 2 + 1, v, w);
    }
    t[pos].sum = t[pos * 2].sum + t[pos * 2 + 1].sum;
    t[pos].max = two_max(t[pos * 2].max, t[pos * 2 + 1].max);
}
 
int get_sum(int pos, int l, int r) {
    if(t[pos].left == l && t[pos].right == r) {
        return t[pos].sum;
    }
    int middle = (t[pos].left + t[pos].right) / 2;
    if(r <= middle) {
        return get_sum(pos * 2, l, r);
    }
    if(l > middle) {
        return get_sum(pos * 2 + 1, l, r);
    }
    return get_sum(pos * 2, l, middle) + get_sum(pos * 2 + 1, middle + 1, r);
}
 
int get_max(int pos, int l, int r) {
    if(t[pos].left == l && t[pos].right == r) {
        return t[pos].max;
    }
    int middle = (t[pos].left + t[pos].right) / 2;
    if(r <= middle) {
        return get_max(pos * 2, l, r);
    }
    if(l > middle) {
        return get_max(pos * 2 + 1, l, r);
    }
    return two_max(get_max(pos * 2, l, middle), get_max(pos * 2 + 1, middle + 1, r));
}
 
int main(void) {
    memset(t, 0, sizeof(t));
    int n, m;
    cin >> n >> m;
    build(1, 1, n);
    for(int i = 1; i <= n; i++) {
        int tmp;
        cin >> tmp;
        change(1, i, tmp);
    }
    while(m--) {
        int p, x, y;
        cin >> p >> x >> y;
        switch(p) {
        case 1 :
            change(1, x, y);
            break;
        case 2 :
            cout << get_sum(1, x, y) << endl;
            break;
        case 3 :
            cout << get_max(1, x, y) << endl;
            break;
        }
    }
    return 0;
}