SDUTOJ3771_数组计算机(线段树)

数组计算机

Time Limit: 1000 ms Memory Limit: 65536 KiB

Submit Statistic

Problem Description

bLue 有一个神器的机器，这个机器可以读入一个数组，并按照用户要求快速地进行数组的处理和计算，它支持如下两种操作：

• 操作 1：把数组中第 p 个元素的值增加 v。
• 操作 2：计算数组中 [l, r] 区间内所有数的和。

这个机器就是这么的神奇，但是 bLue 的计算机坏掉了，你能帮他修一下吗？

Input

输入数据有多组（数据组数不超过 20），到 EOF 结束。

对于每组数据：

• 第 1 行输入一个整数 n (1 <= n <= 10^5)，表示数组中元素的个数。
• 第 2 行输入 n 个用空格隔开的整数 ai (1 <= ai <= 10^10)，表示初始输入到计算机中的数组。
• 第 3 行输入一个整数 q (1 <= q <= 50000)，表示用户的操作次数。
• 接下来 q 行，每行输入先输入 1 个整数，表示操作类型，根据不同的操作类型：
  • 如果类型为 1，则紧接着输入 2 个用空格隔开的整数 p (1 <= p <= n) 和 v (1 <= v <= 10^10)，表示要把数组中第 p 个数的值增加 v。
  • 如果类型为 2，则紧接着输入 2 个用空格隔开的整数 l, r (1 <= l <= r <= n)，表示要计算区间 [l, r] 内所有数的和（数组下标从 1 开始）。

Output

对于每组数据中的每次类型为 2 的操作，输出 1 行，包含一个整数，表示计算出的和。

Sample Input

5
1 2 3 4 5
5
2 1 2
2 1 5
1 4 10
2 4 5
2 1 5

Sample Output

3
15
19
25

Hint

Source

【2017年寒假集训分组测试赛2】bLue

关于线段树的详细学习：

看这篇博客

http://www.cnblogs.com/TenosDoIt/p/3453089.html#f

学长关于线段树的总结：转载于(https://blog.csdn.net/winner647520/article/details/81407177)

• 首先明确一点，线段树是一颗完全二叉树，然后建树的时候用数组比较方便。
• 假设根节点下标是n，那么他的左儿子下标是n×2+1，右儿子下标是n×2+2。
• 这里有个细节是数组是开的结构体数组，因为一个节点有时候要储存好几个信息，这里我把维护的区间也储存起来了，方便查询的时候调用。
• 建树的时候递归建树就可以。
• 查询的时候，这里分两种情况：如果查询区间与当前节点的区间无交集，那么返回。如果查询区间与当前节点的区间有交集，那么把查询区间更新为这个交集。（具体为什么，可以画图模拟一下就知道了）
• 最后当前节点是叶子节点的话，就直接返回当前节点的值，否则继续查询当前节点的左右子树并返回两者返回值的和。
• 更新节点值的时候相当于二分查找，直到找到需要添加值的叶子节点。这里需要注意的是，查询过程中，如果沿途上的节点的区间包含要更新的节点的话，顺便把这个节点也更新掉。
   

ACcode:

/* 线段树学习 -01(模仿别人代码)
* 时间复杂度: O(logn)
* 增加数组某个位置元素的值大小
* 求区间[l, r]的元素和
* 待续。。。
*/
#include <bits/stdc++.h>
using namespace std;
struct node
{
    int left, right; // 区间边界
    long long data;  // 区间和
};
node tree[1000005];
long long num[1000005];
void build_tree(int id, int l, int r) // 建立线段树(递归)
{
    tree[id].left = l;
    tree[id].right = r;
    if (l == r) // 当是叶子节点的时候
        tree[id].data = num[l];
    else
    {
        int mid = (l + r) / 2;                                         // 二分建立左子树和右子树
        build_tree(id * 2 + 1, l, mid);                                // 建立左子树
        build_tree(id * 2 + 2, mid + 1, r);                            // 建立右子树
        tree[id].data = tree[id * 2 + 1].data + tree[id * 2 + 2].data; // 该节点的区间和等于左子树的区间线段和+右子树的区间线段和
    }
}
long long query(int id, int l, int r) // 查询[l, r]区间和
{
    int left = tree[id].left;
    int right = tree[id].right;
    if (left > r || right < l) // 当[l, r]区间和id节点的区间无交集的时候
        return 0;
    // 求交集 画图模拟
    l = max(left, l);
    r = min(right, r);
    if (left == l && right == r) // 当[l, r]区间在id节点区间的内时
        return tree[id].data;
    // 当[l, r]区间与id节点相交的时候(不是包含关系)
    // 查询左子树和右子树 左右子树必有个反回0 所以求和即可
    return query(2 * id + 1, l, r) + query(2 * id + 2, l, r);
}
void update(int id, int pos, long long data) // 更新某个位置元素的值
{
    int left = tree[id].left;
    int right = tree[id].right;
    if (left > pos || right < pos) // 当pos 不在区间[l, r]中的时候
        return;
    // 如果在 和++data
    tree[id].data += data;
    if (left == right)
        return;
    update(id * 2 + 1, pos, data); // 更新左子树
    update(id * 2 + 2, pos, data); // 更新右子树
}
int main()
{
    ios::sync_with_stdio(false);
    int n, q;
    long long v;
    while (cin >> n)
    {
        memset(num, 0, sizeof(num));
        memset(tree, 0, sizeof(tree));
        for (int i = 0; i < n; i++)
            cin >> num[i];
        build_tree(0, 0, n - 1); // 根节点是 0
        cin >> q;
        while (q--)
        {
            int m, p, l, r;
            cin >> m;
            if (m == 2)
            {
                cin >> l >> r;
                cout << query(0, l - 1, r - 1) << endl;
            }
            else if (m == 1)
            {
                cin >> p >> v; // 对p位置的元素加v
                update(0, p - 1, v);
            }
        }
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/iQXQZX/p/10258766.html