3771——数组计算机

数组计算机
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

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
struct node
{
    long long int data;
};
struct node tree[400000];
void creat(int root,int l,int r)
{
    int mid;
    if(l==r)//相当于二分到最底层；
    {
        scanf("%lld",&tree[root].data);
        return ;//返回原函数，继续添加
    }
    mid=(l+r)/2;//root在这里起着编号的作用，mid则是二分线段
    creat(2*root,l,mid);//比如【0,7】分为【0,3】和【4,7】,递归左调用
    creat(2*root+1,mid+1,r);//递归右调用
    tree[root].data=tree[2*root].data+tree[2*root+1].data;
}
void updata(int p,long long int v,int l,int r,int root)
{
    int mid;
    if(l==r)
    {
        tree[root].data=tree[root].data+v;
        return ;
    }
    mid=(l+r)/2;
    if(p<=mid)
    {
        updata(p,v,l,mid,2*root);//递归调用
    }
    else
    {
        updata(p,v,mid+1,r,2*root+1);
    }
    tree[root].data=tree[2*root].data+tree[2*root+1].data;//更新父亲的区间值
}
long long sum(int L,int R,int l,int r,int root)
{
    int mid;
    long long int red=0;
    if(L<=l&&R>=r)
    {
        return tree[root].data;//如果区间满足L,R的范围就返回对于的区间值
    }
    mid=(l+r)/2;
    if(L<=mid)
    {
        red=red+sum(L,R,l,mid,2*root);
    }
    if(R>mid)
    {
        red=red+sum(L,R,mid+1,r,2*root+1);
    }
    return red;
}
int main()
{
    int n,m,num,p,L,R;
    long long int v;
    while(scanf("%d",&n)!=EOF)
    {
        creat(1,1,n);
        scanf("%d",&m);
        while(m--)
        {
            scanf("%d",&num);
            if(num==1)
            {
                scanf("%d %lld",&p,&v);
                updata(p,v,1,n,1);
            }
            else if(num==2)
            {
                scanf("%d %d",&L,&R);
                printf("%lld\n",sum(L,R,1,n,1));
            }
        }
    }
    return 0;
}

#include <iostream>
#include <bits/stdc++.h>
using namespace std;

long long int n[400000];

void built(int t,int l,int r)
{
    if(l==r)
    {
        scanf("%lld",&n[t]);
        return ;
    }
    int mid=(l+r)/2;
    built(2*t,l,mid);
    built(2*t+1,mid+1,r);
    n[t]=n[2*t]+n[2*t+1];
}

void updata(int p,long long int v,int l,int r,int t)
{
    if(l==r)
    {
        n[t]=n[t]+v;
        return ;
    }
    int mid=(l+r)/2;
    if(p<=mid)
    {
        updata(p,v,l,mid,2*t);
    }
    else
    {
        updata(p,v,mid+1,r,2*t+1);
    }
    n[t]=n[2*t]+n[2*t+1];
}

long long sum(int L,int R,int l,int r,int t)
{
    long long int ans=0;
    if(L<=l&&R>=r)
    {
        return n[t];
    }
    int mid=(l+r)/2;
    if(L<=mid)
    {
        ans=ans+sum(L,R,l,mid,2*t);
    }
    if(R>mid)
    {
        ans=ans+sum(L,R,mid+1,r,2*t+1);
    }
    return ans;
}

int main()
{
    int a,b,c,p,L,R;
    long long v;
    while(scanf("%d",&a)!=EOF)
    {
        built(1,1,a);
        scanf("%d",&b);
        while(b--)
        {
            scanf("%d",&c);
            if(c==1)
            {
                scanf("%d%lld",&p,&v);
                updata(p,v,1,a,1);
            }
            else if(c==2)
            {
                scanf("%d%d",&L,&R);
                printf("%lld\n",sum(L,R,1,a,1));
            }
        }
    }
    return 0;
}```