树状数组

最新推荐文章于 2024-08-02 16:46:49 发布
最新推荐文章于 2024-08-02 16:46:49 发布
阅读量358 收藏
点赞数 2
分类专栏： 树状数组 文章标签： c++ c语言 树状数组
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Demon_Rieman/article/details/78066513
版权

(我又来写题解了~~~)

树状数组（二叉搜索树）

定义： c[i] 维护的是 [i，i−lowbit（i）+1] 这段区间的值，这个 lowbit 等会解释。树状数组，他的时间复杂度为 O（logN） ，而且常数小，还好写，简直就是oi中的大法。并且我们可以“感受”到，如果只有一般的修改与一般的询问最大值，前缀和等，都完全可以替代线段树。（当然，有些时候他也替代不了线段树，比如主席树时）。下面来直观看看这个数组c的管辖范围。
TREE ARRAY
由此可见，这个数组像一棵树一样，故曰树状数组（实际上本来就是一棵树）。
下面解释 lowbit（x） 的含义： lowbit（x） 是最大的 2k ，使得 2k 是 x 的约数，而2（k+1）不是其约数。即 x 的约数中最大的二的幂。也可以说是x在二进制时最后一个 1 所代表的值。

1.基本操作：

单点更新：

int update(int x,int val)
{
    while (x<=n)
    {
    c[x]+=val;
    x+=lowbit(x);
    }
}

区间查询：

int query(int x)
{
    int ans = 0;
    while (x)
    {
    ans += c[x];
    x-=lowbit(x);
    }
}

实际上也可以区间更新，区间查询。记录一个新数组a[i]=x[i]−x[i−1]（原数组为 x ），那么修改时修改差分，然后差分的前缀和就是单点的数。而区间查询则需要推公式，推出来为x×∑a[i]−∑a[i]×(i−1)；那么就只需要再记录一个新的数组记录 a[i]×(i−1) 。

例题

  • Codevs 1082
    题目：区间修改，区间查询。
    代码：
#include<cstdio>
#include<algorithm>
const int size = 200005;
using namespace std;
typedef long long ll; 
ll del[size],del2[size],num[size];
ll n , m;
ll dodo ,l ,r,val;
ll lowbit(ll x){return  (x &(-x));}
void update(ll x,ll val,ll *arr)
{
    while (x<=n)
    {
        arr[x] += val;
        x += lowbit(x);
    }
}
ll query(ll x,ll *arr)
{
    ll ans = 0;
    while(x)
    {
        ans += arr[x];
        x -= lowbit(x);
    }
    return ans;
}
int main()
{
    scanf("%lld" , &n);
    for (ll i = 1;i<=n;i++)
    {scanf("%lld" , &num[i]);
     update(i,num[i] - num[i-1],del);
     update(i,(i-1) * (num[i] - num[i-1]) ,del2);
    }
    scanf("%lld",&m);
    for (ll i =1;i <=m ;i++)
    {
        scanf("%lld",&dodo);
        if (dodo == 1)
        {
            scanf("%lld%lld%lld",&l,&r,&val);
            update(l,val,del);
            update(r+1,-val,del);
            update(l,val * (l-1),del2);
            update(r+1,-val * r,del2);
        }
        else
        {
            scanf("%lld%lld",&l,&r);
            ll lle =  (l-1) * query(l-1,del) - query(l-1,del2);
            ll rr =  r * query(r,del) - query(r,del2);
            printf("%lld\n",rr-lle);
        }
    }
        return 0;
}

题目： 略

题解：水题啊，注意到 c 的值很小，m， n 的也很小，那么我们就记录树状数组c[d][m][n]表示 d 这个数在（0,0）—（m，n）这个矩形内出现次数，然后就完了。
代码：

#include<cstdio>
#include<algorithm>
#include<cstring>
int n,m,q;//n 对应 x //m 对应 y  
int c[101][310][310];
int mat[310][310];
int lowbit(int x)
{return (x&(-x));}
using namespace std;
void update(int x,int y,int pre,int now)
{
        int x0 = x;int y0 = y;
        while (x0<=n)
        {
             y0 = y;
            while (y0 <= m)
            {
            c[now][x0][y0]++;
            y0 += lowbit(y0);
            }
            x0 += lowbit (x0);
        }
         x0 = x; y0 = y;
        while (x0<=n)
        {
            y0 = y;
            while (y0 <= m)
            {
            c[pre][x0][y0]--;
            y0 += lowbit(y0);
            }
            x0 += lowbit (x0);
        }
}
int query(int val,int x,int y)
{
    int ans = 0;
    int x0 = x;int y0 = y;
    while (x0)
    {
        y0 = y;
        while (y0)
        {
            ans += c[val][x0][y0];
            y0 -= lowbit(y0); 
        }
        x0 -= lowbit (x0);
    }   
    return ans;
}
int main()
{
    scanf("%d%d",&n,&m);
    memset(c,0,sizeof c);
    for (int x = 1;x <= n ;x++)
       for (int y = 1;y <= m;y++)
       {
       scanf("%d",&mat[x][y]);
       update(x,y,0,mat[x][y]);
       }
    scanf("%d",&q);
    while (q--)
    {
        int dodo;
        scanf("%d",&dodo);
        if (dodo == 1)
        {
            int x,y,val;
            scanf("%d%d%d",&x,&y,&val);
            update(x,y,mat[x][y],val);
            mat[x][y] = val;
        }else
        if (dodo == 2)
        {
            int x1,x2,y1,y2,val;
            scanf("%d%d%d%d%d",&x1,&x2,&y1,&y2,&val);
            int ans = query(val,x2,y2)+ query(val,x1-1,y1-1) - query(val,x2,y1-1)- query(val,x1-1, y2);
            printf("%d\n",ans);
        }
    }
    return 0;
}

  • bzoj 2743[HEOI2012]采花
    题目：
    萧芸斓是Z国的公主，平时的一大爱好是采花。
    今天天气晴朗，阳光明媚，公主清晨便去了皇宫中新建的花园采花。花园足够大，容纳了n朵花，花有c种颜色（用整数1-c表示），且花是排成一排的，以便于公主采花。公主每次采花后会统计采到的花的颜色数，颜色数越多她会越高兴！同时，她有一癖好，她不允许最后自己采到的花中，某一颜色的花只有一朵。为此，公主每采一朵花，要么此前已采到此颜色的花，要么有相当正确的直觉告诉她，她必能再次采到此颜色的花。由于时间关系，公主只能走过花园连续的一段进行采花，便让女仆福涵洁安排行程。福涵洁综合各种因素拟定了m个行程，然后一一向你询问公主能采到多少朵花（她知道你是编程高手，定能快速给出答案！），最后会选择令公主最高兴的行程（为了拿到更多奖金！）。
    题解：
    实际上就是问你区间上有几个落单的数。那么我们可以打一下标记，先把询问按左端点排序，然后记录每个数的下一个与其值相等的数的位置 next ，然后先把每个值第二个加入树状数组，接着做时，就遇到一个 i ，去掉next[i]，加上 next[next[i]] 。（因为这样就可以使如果只有一个，一正一负刚好可以抵了，反之，也对，把第二个也加上是考虑了第零个）。
    代码：
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn = 1000110;
int lowbit(int x){ return (x & (-x));}
int n , m  ,ww;
int c[maxn] , a[maxn] , ans[maxn] , next[maxn] , pre[maxn ] ;
bool vis[maxn];
struct q{
    int l ,r ,id; 
    bool operator < (const q &cx) const{
        if (l == cx.l) return r < cx.r;
        return l < cx.l;
    }
}qq[maxn];
void update (int x,int del)
{
    while (x <= n)
    {
        c[x] += del;
        x += lowbit(x);
    }
}
int query(int x)
{
    if (x==0) return 0;
    int ans = 0;
    while (x)
    {
        ans += c[x];
        x -= lowbit (x);
    }
    return ans;
}
int main()
{
    scanf("%d%d%d",&n,&ww,&m);
    for (int i = 1 ;i <= n ;i++)
    scanf("%d" , &a[i]);
    for (int i = 1;i <= m;i++)
    scanf("%d%d", &qq[i].l, &qq[i].r), qq[i].id = i;        
    sort(qq + 1 , qq + 1 + m);
    memset(vis,0,sizeof vis); 
    for (int i = 1;i <= n;i++)
    {
        if (pre[ a[i] ])    next[ pre[ a[i] ] ] = i;
        else vis[i] = 1;
        pre[ a[i] ] = i;
    }
    for (int i = 1;i <= n;i++)
    if (vis[i] && next[i])
    update(next[i],1); 
    int nowr = 1;
    for(int i = 1;i <= m;i++)
    {
        while (nowr < qq[i].l)
        {

        if (next[nowr]) 
            {
            update(next[nowr] , -1);
            if (next [ next [ nowr ]  ]) update(next[ next[nowr] ] , 1); }  
            nowr++; 
        }
    ans[qq[i].id] = query(qq[i].r) ;
    }
   for (int i = 1;i <= m;i++)
    printf("%d\n",ans[i]);
    return 0;
}
  • bzoj 1878: [SDOI2009]HH的项链
    题解：
    与上题相似，但这题按右端点排序。我们记录一个 a[i] 表示 i 是不是当前区间内x[i]这个值最靠右的（ x 是原序列），然后就统计一下就完了。
    代码：
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn = 200110;
int lowbit(int x){ return (x & (-x));}
int n , m;
int c[maxn] , a[maxn] , ans[maxn] , next[maxn] , pre[maxn * 5] ;
struct q{
    int l ,r ,id; 
    bool operator < (const q &cx) const{
        if (r == cx.r) return l < cx.l;
        return r < cx.r;
    }
}qq[maxn];
void update (int x,int del)
{
    while (x <= n)
    {
        c[x] += del;
        x += lowbit(x);
    }
}

int query(int x)
{
    if (x==0) return 0;
    int ans = 0;
    while (x)
    {
        ans += c[x];
        x -= lowbit (x);
    }
    return ans;
}
int main()
{
    scanf("%d",&n);
    for (int i = 1 ;i <= n ;i++)
    scanf("%d" , &a[i]);

    scanf("%d" , &m);
    for (int i = 1;i <= m;i++)
    scanf("%d%d", &qq[i].l, &qq[i].r), qq[i].id = i;        
    sort(qq + 1 , qq + 1 + m);

    for (int i = 1;i <= n;i++)
    {
        if (pre[ a[i] ])    next[ pre[ a[i] ] ] = i;
        pre[ a[i] ] = i;
    }
    memset(pre , 0 , sizeof pre);
    for (int i = 1;i <= n;i++)   if (next[i]) pre[ next[i] ] = i;

    int nowr = 0;
    for(int i = 1;i <= m;i++)
    {
        while (nowr < qq[i].r)
        {
        nowr++;
        if (pre[nowr]) update(pre[nowr] , -1);
        if (nowr) update(nowr , 1); 
        }   
        ans[qq[i].id] = query(qq[i].r) - query(qq[i].l-1);
    }   
    for (int i = 1;i <= m;i++)
    printf("%d\n",ans[i]);
    return 0;
}


题目：略
题解：
（这题好啊）*最小交换次数就是最后序列的关于原位置的逆序对*，然后我们可以证明最后数列是一个先增后减的样子。（好不容易遇到一个我会证的，当然要证一证）。如下：首先最大的可以随便放，然后我们考虑他左边的第一个数Ai，那么 Ai 右边有比他大的了，所以 Ai 左边都不能比 Ai 大，所以 Ai 是 [1,i] 最大的，同理可证 Ai−1 也是 [1,Ai−1] 最大的，于是在最大的以左为单增，同理可证右边为单减。好了，接着把草从大到小排一次序，那么我们新放的数一定在已经放的数的最左边或最右边，然后开始贪心，每次加入其位置，然后看是放左边还是右边。因为大的已经放了，较小的无论怎么放都不会影响之前的大的，所以可以贪心。
总结：这道题最大的转点在于：最小交换次数就是最后序列的关于原位置的逆序对这一结论，一定要记熟。
代码：（压了行的，别打我）

#include<cstdio>
#include<algorithm>
using namespace std;const int maxn = 300010; 
inline int read(){  int x=0; char ch=getchar();  
while (ch<'0' || ch>'9') ch=getchar();  
while (ch>='0' && ch<='9'){ x=x*10+ch-'0'; ch=getchar(); }
return x;}int c[maxn],n,answer = 0;struct gra
{int h,id;bool operator < (const gra &d) 
const {return h > d.h;}}a[maxn];int lowbit(int x)
{return x& (-x);}int query(int x){int ans = 0 ;
while (x){ans+=c[x] ;
x-=lowbit(x);}return ans;}
void update(int x,int val)
{while (x <= n){c[x]+=val;
x +=lowbit(x);}}int  main()
{n=read();for (int i = 1;i <= n ;i ++)
{a[i].h=read();a[i].id = i;}
sort(a + 1,a + 1 + n);int head=1; long long ans=0;  
for (int i=1; i<=n; i++){if (a[i].h!=a[i-1].h)
while (head<i) update(a[head++].id , 1);  int tmp=query(a[i].id); 
ans+=min(tmp,head-1-tmp);}printf("%lld",ans);return 0;} 


（数据小点还可以dp的，气）。这个我实在是看的别人的，这里推荐一个写得好的：
http://m.blog.csdn.net/FromATP/article/details/64133191
代码：

#include<cstdio>
#include<algorithm>
const int size = 100010;
using namespace std;
int c[size] , n ,w ,y[size],f[size],answ=0,cnt;
struct th{
    int v,t,loc,w1,w2;
    bool operator < (const th &de) const{
        if (w1==de.w1) return w2<de.w2;return w1<de.w1;
    }
}ob[size];
int lowbit(int  x){return (x&(-x));}
int query(int x)
{   int ans=0;
    while (x)
    {ans = max(c[x],ans);
    x -= lowbit(x);}
    return ans;
}
void update(int x,int val)
{   while (x<=n)
    {c[x] = max(c[x],val);
    x+=lowbit(x);
}}
int main()
{
    scanf("%d%d",&w,&n);
    for (int i = 1;i<=n;i++){
    scanf("%d%d%d",&ob[i].t,&ob[i].loc,&ob[i].v); 
    ob[i].w1 = 2 * ob[i].t + ob[i].loc; 
    ob[i].w2 = 2 * ob[i].t - ob[i].loc; 
    y[++cnt] = ob[i].w2;
    }
    sort(y + 1 , y + 1 + n);
    cnt = unique (y + 1 , y + 1 + n) - y - 1;
    for (int i = 1;i<=n;i++) ob[i].w2 = lower_bound(y+1,y+1+cnt,ob[i].w2)-y;
    sort(ob + 1,ob + 1 + n);
    for (int i = 1;i<=n;i++)
    {
        f[i] = ob[i].v + query(ob[i].w2);
        answ = max(answ,f[i]);
        update(ob[i].w2 , f[i]);
    }
    //for (int i =1;i<=n;i++)
    printf("%d",answ);
    return 0;
}


结语

树状数组大法好，好写又好调！！！

Demon_Rieman
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树状数组（入门附模板）
cyyyyds857的博客
06-21 1915
树状数组或二叉索引树（英语：Binary Indexed Tree），又以其发明者命名为Fenwick树，最早由Peter M. Fenwick于1994年以A New Data Structure for Cumulative Frequency Tables为题发表在SOFTWARE PRACTICE AND EXPERIENCE。其初衷是解决数据压缩里的累积频率（Cumulative Frequency）的计算问题，现多用于高效计算数列的前缀和， 区间和。——源自百度百科。
python 树状数组_【算法日积月累】19-高级数据结构：树状数组
weixin_29095587的博客
03-01 552
树状数组能解决的问题树状数组，也称作“二叉索引树”(Binary Indexed Tree)或 Fenwick 树。 它可以高效地实现如下两个操作：1、数组前缀和的查询；2、单点更新。下面具体解释这两个操作。1、数组的前缀和查询首先看下面这个例子，了解什么是数组的前缀和查询。例1：已知数组。1、求索引 至索引 的所有元素的和；2、求索引 至索引 的所有元素的和；3、求索引 至索引 的所有元...
树状数组(详细分析+应用)，看不懂打死我!
TheWayForDream
07-03 4万+
树状数组介绍 在学习一个算法之前一定要清楚它能干嘛，能解决什么样的问题，对你解题是否有帮助，然后才去学习它! 那么接下来看如下几个问题 什么是树状数组 顾名思义就是一个结构为树形结构的数组，于二叉树的结构类似但又不同，它是在二叉树的结构上删除了一些中间节点，来看两幅图就明白了. 1.这是二叉树的结构 2.这是树状数组的结构 不难发现，树状数组相比于二叉树删除了一些节点，但是为什么要删除呢？这就和树状数组的一些性质(lowbit)有关了，不懂没关系，继续往下看. 树状数组可以解决什么问题呢？ 可以解决大部
树状数组 java_树状数组详解
weixin_42220669的博客
02-16 1306
先来看几个问题吧。1.什么是树状数组？顾名思义，就是用数组来模拟树形结构呗。那么衍生出一个问题，为什么不直接建树？答案是没必要，因为树状数组能处理的问题就没必要建树。和Trie树的构造方式有类似之处。2.树状数组可以解决什么问题可以解决大部分基于区间上的更新以及求和问题。3.树状数组和线段树的区别在哪里树状数组可以解决的问题都可以用线段树解决，这两者的区别在哪里呢？树状数组的系数要少很多，就比如字...
树状数组数据结构
qq_37464878的博客
02-22 2532
1.树状数组概念 树状数组简单来说就是仅通过一个数组来描述一棵树或一个森林。数组中每个元素只存储着树中对应节点存储的信息，不存储描述树的层次结构的信息。 2.普通树的存储 对于一棵普通的树，在《数据结构》严蔚敏版中提到可以使用如下方法进行存储： 2.1 父节点表示法 用一个数组中存储节点信息，节点信息包括节点存储数据和父节点编号。 struct Node { int data; // 节点存储的数据 int parent; // 节点对应的父节点的编号 } struct Tree {
树状数组简单易懂的详解
热门推荐
FlushHip
01-25 6万+
树状数组确实是个好东西啊，以前搞比赛的时候了解过它，会套用模版，但确没有深入理解这个东西，先学会用轮子，然后再学造轮子嘛，这段时间再回头研究了一下，发现二进制在算法中真的是的好东西，它可以使算法的时间复杂度降到n的二进制表示中的1相关，大家都知道，求一个二进制中的1的个数，这个时间复杂度为O(logn)" role="presentation" style="position: relative;
树状数组c++详解
黑客HK的博客
07-02 444
树状数组（Binary Indexed Tree，简称BIT）是一种用于高效处理数组范围查询和单点更新操作的数据结构。它解决了传统的线段树在处理范围查询时的低效问题，并且在某些情况下，比如查询和更新操作频繁的情况下，它比线段树更快。请注意，树状数组的索引是从1开始的，所以我们在所有操作中都对索引进行了加1的处理。此外，树状数组的大小通常是原始数组的大小加上1，以确保我们可以安全地使用索引来访问所有的节点。表示为一个二进制数，然后用这个二进制数的最后一个1来确定它是哪个父节点的子节点。调用来计算出区间和。
树状数组详解
萧何山的博客
07-31 1万+
文章目录前言一、树状数组概括二、树状数组的应用1.单点修改+区间查询总结 前言 树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。 一、树状数组概括 树状数组是一个查询和修改复杂度都为log(n)的数据结构。主要用于数组的单点修改&
php 生成树形数组,php递归生成无限极树状数组
weixin_29091105的博客
04-11 474
在生成多级树状数组之前，我们一般得到的数据结构如下[{"id": 6,"parent_id": 5,"name": "体育专题1","intro": "体育专题1111介绍",}, {"id": 5,"parent_id": 4,"name": "体育专题","intro": "体育专题介绍",}, {"id": 4,"parent_id": 0,"name": "体育","intro": "体育...
树状数组基本操作
w75779的博客
10-01 793
树状数组的一维和二维
树状数组_洛谷_树状数组_
10-02
树状数组，也被称为线段树（Segment Tree），是一种数据结构，主要用于高效地处理动态区间查询和修改问题。在编程竞赛和算法设计中，树状数组是解决许多问题的利器，尤其是在面对需要频繁更新和查询区间信息的问题时...
树状数组树状数组树状数组树状数组
06-07
树状数组树状数组树状数组树状数组树状数组树状数组树状数组树状数组
js用闭包遍历树状数组的方法
12-12
做公司项目时，要求写一个方法，方法的参数为一个菜单数组集合和一个菜单id，菜单数组的格式为树状json,如下面所示： 代码如下:[{“id”:28,”text”:”公司信息”,”children”:[  {“id”:1,”text”:”公司文化...
什么是树状数组以及我们学习树状数组的作用
06-10
相较于其他数据结构（如线段树），树状数组的代码实现更为简洁，并且常数因子较小，使得它在实际应用中非常高效。 ### 树状数组的基本概念 1. **低界操作**：树状数组中的一个重要概念是“低界”（Low Bit）操作，...
什么是树状数组以及学习树状数组的意义是什么
06-08
相较于其他数据结构如线段树、差分数组等，树状数组在实现上更为简洁，在空间和时间复杂度上也表现得更加优秀。树状数组的应用场景广泛，尤其是在解决区间查询与更新的问题时，能够提供非常高效的解决方案。 #### ...
【C++】输入输出
最新发布
2401_83948390的博客
08-02 203
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
美团2024年春招第一场笔试[测开方向]，编程题+选择题详解，ACM式C++解法
weixin_45962681的博客
07-31 680
静态数据区主要用于生命周期固定、大小确定的数据，它的管理简单但缺乏灵活性。动态数据区则主要用于生命周期不定、大小可变的数据，提供了高度的灵活性，但管理起来较为复杂，且容易引发错误。正确地选择和使用这两种数据区，对于开发高效、可维护的软件应用至关重要。
C++｜设计模式（八）｜⭐️工厂模式？错！是工厂模式群！
糖炒栗子
08-02 470
首先我们按照与 Employee 类相同的方式来创建所有不同项目对应的基类（父类）Project，在这个类中我们还定义了与项目相关的接口 assignTo ，这个接口可以将某个项目指派给对应账户ID的员工，还是相同的方式我们定义 ITProject 与 UIProject 这两个不同项目的子类，并提供 assignTo 接口的不同实现。
第六章 - c语言中的数组-二维数组（下）
百知_zmj的博客
08-02 150
二维数组案例：杨辉三角形。
树状数组详解与应用
"树状数组是一种数据结构，...它通过巧妙的位运算和树形结构设计，使得在大规模数据集上的操作变得高效。理解和掌握树状数组的原理及应用，对于解决实际编程问题，尤其是在算法竞赛和数据分析领域，都是至关重要的。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值