动态求连续区间和--树状数组与线段树

树状数组，这玩意吧，我也整不明白具体的原理，说的好听点就是注重实践，说不好听点就是背着这几个函数会写就行了

给定 n 个数组成的一个数列，规定有两种操作，一是修改某个元素，二是求子数列 [a,b] 的连续和。

输入格式
第一行包含两个整数 n 和 m，分别表示数的个数和操作次数。

第二行包含 n 个整数，表示完整数列。

接下来 m 行，每行包含三个整数 k,a,b （k=0，表示求子数列[a,b]的和；k=1，表示第 a 个数加 b）。

数列从 1 开始计数。

输出格式
输出若干行数字，表示 k=0 时，对应的子数列 [a,b] 的连续和。

数据范围

1≤n≤100000,
1≤m≤100000，
1≤a≤b≤n

输入样例：

10 5
1 2 3 4 5 6 7 8 9 10
1 1 5
0 1 3
0 4 8
1 7 5
0 4 8

输出样例：

11
30
35

树状数组就是求前缀和并且能动态的去修改的 O(log n)，就是可以在一个位置上加一个数（只能是加一个数）
不多说了，直接放代码了，我也解释不出来啥原理，就记住这个函数跟功能吧：

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;
int n, m;
int a[N], tr[N];

int lowbit(int x)
{
    return x & -x;
}

void add(int x, int y)
{
    for(int i = x; i <= n; i += lowbit(i))  tr[i] += y;
}

int quary(int x)
{
    int res = 0;
    for(int i = x; i; i -= lowbit(i))  res += tr[i];
    return res;
}

int main()
{
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++  )   scanf ("%d", &a[i]);
    for(int i = 1; i <= n; i ++ )    add(i, a[i]);
    
    while(m --)
    {
        int k, x, y;
        scanf("%d%d%d", &k, &x, &y);
        if(k == 1)  add(x, y);
        else    printf("%d\n", quary(y) - quary(x - 1));
    }
}

线段树吧，这个玩意倒是好理解，就是把一个数组给他不断地从中间劈开，拆成了一个二叉树的样子，每个位置都是一个结构体，结构体放着左右区间的一个范围，还有一个要求的东西（区间的和，最大值…）

每次进行递归查询


代码如下，相应的函数实现的功能都在后面备注了

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int w[N];
struct Node
{
    int l, r;
    int sum;
}tr[N * 4];

void pushup(int u)  //根据左右子节点求出来当前节点
{
    tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum;
}

void build(int u, int l, int r) //当前是哪一个结点(u),左右边界是多少（下标）
{
    if(l == r)  tr[u] = {l, r, w[r]};
    else
    {
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}

int query(int u, int l, int r)      //看当前这个结点是否被这个范围全部包含住，没有就进行递归，直到他被包含住了
{
    if(tr[u].l >= l && tr[u].r <= r)    return tr[u].sum;
    int mid = tr[u].l + tr[u].r >> 1;
    int sum = 0;
    if(l <= mid)    sum += query(u << 1, l, r);
    if(r > mid)     sum += query(u << 1 | 1, l, r);     mid = r的时候说明右半边是没有在l r的范围内的，所以不用进行查找
    return sum;
}

void modify(int u, int x, int v)     //从第U个节点，改变他的第x个位置，给他加上V
{
    if(tr[u].l == tr[u].r)  tr[u].sum += v;
    else
    {
        int mid = tr[u].l + tr[u].r >> 1;
        if(x <= mid) modify(u << 1, x, v);      //因为分的时候是[l, mid] [mid + 1, r]所以mid是属于左半部分
        else    modify(u << 1 | 1, x, v);       
        pushup(u);      //他的左或者右结点有一个或者两个都更改了，然后进行更新
    }
}

int main()
{
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++ )    scanf("%d", &w[i]);
    build(1, 1, n);
    
    int k, a, b;
    while(m --)
    {
        scanf("%d%d%d", &k, &a, &b);
        if(k == 0)  printf("%d\n", query(1, a, b));
        else    modify(1, a, b);
    }
    return 0;
}