SDUT OJ 数组计算机（线段树）

学长推荐了这个博客详细的介绍了线段树的建立、查找、更新；

数组计算机

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

补一波学长的总结：

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

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;

struct node
{
    int l, r;
    long long int data;
};

struct node tree[1234567];
long long int Begin[1234567];


void Buildtree( int root, int l, int r )
{
    tree[root].l = l;
    tree[root].r = r;
    if( l == r )
        tree[root].data = Begin[l];
    else
    {
        int mid = ( l + r ) / 2;
        Buildtree( root * 2 + 1, l,   mid );
        Buildtree( root * 2 + 2, mid+1, r );
        tree[root].data = tree[root * 2 + 1].data + tree[root * 2 + 2].data;
    }
}


long long int Query ( int root, int l, int r )
{
    int i = tree[root].l, j = tree[root].r;
    if( i > r || j < l )
        return 0;

    l = max( l, i );
    r = min( r, j );
    if( i == l && j == r )
        return tree[root].data;

    return Query( root * 2 + 1, l, r ) + Query( root * 2 + 2, l, r );
}

void Updata ( int root, long long int pos, long long int data )
{
    int l = tree[root].l, r = tree[root].r;
    if( l > pos || r < pos )
        return;

    tree[root].data += data;

    if( l == r )
        return;

    Updata( root * 2 + 1, pos, data );
    Updata( root * 2 + 2, pos, data );
}


int main()
{
    int n;
    while( ~scanf("%d", &n) )
    {
        memset( tree, 0, sizeof( tree ));
        memset( Begin, 0, sizeof(Begin));
        int i;
        for( i=0; i<n; i++ )
            scanf("%lld", &Begin[i]);
        Buildtree( 0, 0, n-1 );


        int q;
        scanf("%d", &q);
        while( q-- )
        {
            int type;
            long long int x, y;
            scanf("%d %lld %lld", &type, &x, &y);
            if( type == 1 )
                Updata( 0, x-1, y );
            if( type == 2 )
                printf("%lld\n", Query(0, x-1, y-1));
        }
    }
    return 0;
}

 

转载于:https://www.cnblogs.com/gaojinmanlookworld/p/10586878.html