树状数组 (三种模型)

感谢大佬的讲解:https://blog.csdn.net/sinat_37668729/article/details/77387668                        

 

1.改变某一元素的值,查询某一区间内所有元素的和(单点更新,区间查询)。

2.把一个区间内的所有元素都加上一个值,查询某一个元素的值(区间更新,单点查询)。

3.把某一个区间内的所有元素都加上一个值,查询某一区间内所有元素的和(区间更新,区间查询)。

第三种操作是转载RoBa大牛的,具体还得深入理解,现在暂当模板。虽然前面说是“区间更新”,或者“区间查询”,但实际上并不能做到像线段树那样完美,有着很大的局限性。

模式1:

#define Lowbit(p) (p&(-(p)))
//1.改变某一元素的值,查询某一区间内所有元素的和(单点更新,区间查询)。
//向上更新,向下求和
void Update(int *BIT,int p,int val)
{
    while ( p<=N )
    {
        BIT[p] += val;
        p += Lowbit(p);
    }
}

int GetSum(int *BIT,int p)
{
    int ret=0;
    while ( p>0 )
    {
        ret += BIT[p];
        p -= Lowbit(p);
    }
    return ret;
}

//向下更新,向上求和
void Update(int *BIT,int p,int val)
{
    while ( p>0 )
    {
        BIT[p] += val;
        p -= Lowbit(p);
    }
}

int GetSum(int *BIT,int p)
{
    int ret=0;
    while ( p<=N )
    {
        ret += BIT[p];
        p += Lowbit(p);
    }
    return ret;
}


模式2:  

把一个区间内的所有元素都加上一个值,查询某一个元素的值(区间更新,单点查询)。描述给定一个初始值都为0的序列,动态地修改一段连续位置上的数字,加上一个数,减去一个数,然后动态地提出问题,问题的形式是求出一个位置的数字。
输入
输入数据第一行包含2个整数N,M(1≤N,M≤100000),表示序列的长度和操作的次数。
接下来M行,每行会出现如下的一种格式:
* Add i j x ——将序列中第i个数到第j个数加上x
* Query i ——求出序列中第i个数
输出
对于每一个Query操作输出一个数,表示序列中第i个数。
分析:
我们把支持这种操作的树状数组称为树状数组的模式二,在这种模式下,a[i]已经不再表示真实的值了,只不过是一个没有意义的、用来辅助的数组。这时我们真正需要的是另一个假想的数组b[],b[i] 才表示真实的元素值。此时Sum(i)虽然也是求a[i]之前的元素和,但它现在表示的是实际我要的值,也就是 b[i]

注意,这里只是对a[i]进行了加一,i+1到j的值是没变的,所以求得和即为某点的值)

比如现在我要对图1 中a[]数组中红色区域的值全部1。当然你可以用模式一的 Update(i)对该区间内的每一个元素都修改一次,但如果这个区间很大,那么每次修改的复杂度就都是O(NlogN),m次修改就是O(MNlbN),这在M和N很大的时候仍是不满足要求的。这时模式二便派上了用场。我只要将该区域的第一个元素+1,最后一个元素的下一位置-1,对每个位置GetSum(i)以后的值见下图:

 树状数组 (三种模型)_第1张图片


相信大家已经看得很清楚了,数组b[]正是我们想要的结果。模式二难理解主要在于 a[]数组的意义。这时请不要再管a[i]表示什么,a[i]已经没有意义了,我们需要的是b[i]!但模式二同样存在一个缺陷,如果要对某个区间内的元素求和,复杂度就变成O(NlogN)了。所以要分清两种模式的优缺点,根据题目的条件选择合适的模式,灵活应变!

 

//[l,r]中每个元素加上val
void _Update(int *BIT,int l,int r,int val)
{
    //调用的是模式一中的向上更新
    Update(BIT,l,val);
    Update(BIT,r+1,-val);
}

//询问p位置的数
int Querry(int BIT,int p)
{
    //调用的是模式一中的向下求和
    return GetSum(BIT,p);
}

 

模式3:

把某一个区间内的所有元素都加上一个值,查询某一区间内所有元素的和(区间更新,区间查询)。
简单的树状数组模型是不支持这样一组操作的:(1)把某一个区间内所有元素都加上一个值 (2)查询某一个区间内所有元素的和。当然,这个东西可以用线段树完成,但是线段树占内存比较大,写起来也比较繁(对我这种不会数据结构的人而言)。下面我们用一个改进版的树状数组完成这个任务。
首先一个观察是区间操作总可以变成从最左端开始,比如把区间[3..6]都加10,可以变成[1..6]加10, [1..2]减10。查询也类似。于是下面只关心从最左端开始的情况。定义Insert(p, d)表示把区间[1..p]都加d,Query(p)表示查询区间[1..p]之和。
我们考虑调用一次Insert(p, d)对以后的某次查询Query(q)的影响:
(1) 如果p<=q,总的结果会加上p*d (2) 如果p>q,总的结果会加上q*d
也就是说,Query(q)的结果来源可分为两部分,一部分是Insert(p1,d) (p1<=q),一部分是Insert(p2,d) (p2 > q)。我们用两个数组B[], C[]分别维护这两部分信息,B[i]表示区间右端点恰好是i的所有区间的影响之和,C[i]表示区间右端点大于i的所有区间的影响之和。每当遇到 Insert时,考虑当前的Insert会对以后的Query产生什么影响,更新B和C数组;当遇到Query时,把两部分的结果累加起来。
具体来说,当我们遇到Insert(p, d)时,把B[p]增加p*d,把C[1], C[2], …, C[p-1]都增加d。当遇到Query(p)时,查询B[1]+B[2]+…+B[p]+C[p]*p即可。可以发现对B数组是修改单个元素,查询区间和;对C数组是修改区间,查询单个元素,这恰好对应于一开始说的树状数组支持的基本操作。于是我们用两个树状数组漂亮地完成了任务。
 

#include 
const int MAXN = 1024;
int B[MAXN], C[MAXN];
#define LOWBIT(x) ((x)&(-(x)))
void bit_update(int *a, int p, int d)
{
    for ( ; p && p < MAXN ; p += LOWBIT(p))
        a[p] += d;
}

int bit_query(int *a, int p)
{
    int s = 0;
    for ( ; p ; p -= LOWBIT(p))
        s += a[p];
    return s;
}

void bit_update2(int *a, int p, int d)
{
    for ( ; p ; p -= LOWBIT(p))
        a[p] += d;
}

int bit_query2(int *a, int p)
{
    int s = 0;
    for ( ; p && p < MAXN ; p += LOWBIT(p))
        s += a[p];
    return s;
}

inline void _insert(int p, int d)
{
    bit_update(B, p, p*d);
    bit_update2(C, p-1, d);
}

inline int _query(int p)
{
    return bit_query(B, p) + bit_query2(C, p) * p;
}

inline void insert_seg(int a, int b, int d)
{
    _insert(a-1, -d);
    _insert(b, d);
}

inline int query_seg(int a, int b)
{
    return _query(b) - _query(a-1);
}

int main()
{
    int com, a, b, c;
    while (scanf("%d%d%d",&com,&a,&b) != EOF)
    {
        a += 2;
        b += 2; //防止出现负数
        if (com == 0)   //更新
        {
            scanf("%d",&c);
            insert_seg(a, b, c);
        }
        else     //查询
        {
            printf("%d\n",query_seg(a,b));
        }
    }
    return 0;
}

 

你可能感兴趣的:(树状数组)