树状数组

最新推荐文章于 2024-07-02 22:40:02 发布
最新推荐文章于 2024-07-02 22:40:02 发布
阅读量340 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/my_gemini_acm/article/details/8631565
版权

入门篇：http://fqq11679.blog.hexun.com/21722866_d.html 

 

hdu1166 敌兵布阵 【单点更新，区间求和】

http://acm.hdu.edu.cn/showproblem.php?pid=1166 

最基本的模板题

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

#define lowbit(x) ((x)&(-(x)))
int n;

void update(int *a,int x,int w)
{
	while(x<=n)
	{
		a[x]+=w;
		x+=lowbit(x);
	}
}

int sum(int *a,int x)
{
	int ans=0;
	while(x>0)
	{
		ans+=a[x];
		x-=lowbit(x);
	}
	return ans;
}
	
int main()
{
	int a[50001],b[50001];
	int T,t=1;
	scanf("%d",&T);
	while(T--)
	{
		int w;
		scanf("%d",&n);
		memset(a,0,sizeof(a));
		for(int i=1;i<=n;i++)
		{                    
			scanf("%d",&w);
		    update(a,i,w);
		}
		printf("Case %d:\n",t++);
		char s[10];
		int x,y;
		scanf("%s",&s);
		while(strcmp(s,"End")!=0)
		{                       
			if(strcmp(s,"Add")==0)
			{
				scanf("%d%d",&x,&y);
				update(a,x,y);
			}
			else if(strcmp(s,"Sub")==0)
			{
				scanf("%d%d",&x,&y);
				update(a,x,-y);
			}
			else if(strcmp(s,"Query")==0)
			{
				scanf("%d%d",&x,&y);
				int ans=sum(a,y)-sum(a,x-1);
				printf("%d\n",ans);
			}
			scanf("%s",&s);
		}
	}
	return 0;
}


 

 poj3928 Ping pong【单点更新，区间求和】

http://poj.org/problem?id=3928

题意：一条大街上从西到东依次住着N个乒乓球爱好者，他们经常举办比赛。每个人都有一个不同的技能值。每场比赛需要三个人，一个裁判加两个爱好者，不过比赛有一个要求就是裁判的技能值需要在两个爱好者的中间，并且居住的位置也要求在两个爱好者的中间，问总共能够举办多少场比赛。

思路：枚举每个人为裁判。ls[i]为裁判左边比他技能值小的人数，ll[i]为裁判左边比他技能值大的人数，rs[i]为裁判左边比他技能值小的人数，rl[i]为裁判右边比他技能值大的人数。则ls[i]*rl[i]+ll[i]*rs[i]即为所求结果。

 

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

#define lowbit(x) ((x)&(-(x)))

const int INF=0x3f3f3f3f;

long long ans;
int T,n,maxx;
int a[100001],ll[20001],ls[20001],rl[20001],rs[20001],rank[20001];//ll:左大，ls：左小，rl：右大，rs：右小

void update(int *a,int x,int w)
{
    while(x<=maxx)
    {
        a[x]+=w;
        x+=lowbit(x);
    }
}

int sum(int *a,int x)
{
    int ans=0;
    while(x>0)
    {
        ans+=a[x];
        x-=lowbit(x);
    }
    return ans;
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        maxx=0;
        scanf("%d",&n);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&rank[i]);
            if(rank[i]>maxx)
                maxx=rank[i];
        }
        memset(a,0,sizeof(a));
        memset(ll,0,sizeof(ll));
        memset(ls,0,sizeof(ls));
        for(int i=1;i<=n;i++)
        {
            ls[i]=sum(a,rank[i]);
            ll[i]=i-1-ls[i];
            update(a,rank[i],1);
        }
        memset(a,0,sizeof(a));
        memset(rl,0,sizeof(rl));
        memset(rs,0,sizeof(rs));
        for(int i=n;i>0;i--)
        {
            rs[i]=sum(a,rank[i]);
            rl[i]=n-i-rs[i];
            update(a,rank[i],1);
        }
        ans=0;
        for(int i=1;i<=n;i++)
            ans+=(long long)ls[i]*rl[i]+(long long)ll[i]*rs[i];
        printf("%I64d\n",ans);
    }
    return 0;
}

 

poj2299 Ultra-QuickSort【单点更新，区间求和】

http://poj.org/problem?id=2299

题意：给你一个数列，每次只能交换相邻的两个数，问多少次交换可以将数列从小到大排序

思路：其实就是求逆序数个数。枚举每个数，之前比它大的数的个数加起来就是逆序数个数。由于数值范围是999999999，但个数只有500000，所以需要先离散化。

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

#define lowbit(x) ((x)&(-(x)))

const int maxn=500001;

struct point
{
    int value,pos;
};

int n;
int c[maxn],f[maxn];
long long ans;
point a[maxn];

void update(int *a,int x,int w)
{
    while(x<=n)
    {
        a[x]+=w;
        x+=lowbit(x);
    }
}

int sum(int *a,int x)
{
    int ans=0;
    while(x>0)
    {
        ans+=a[x];
        x-=lowbit(x);
    }
    return ans;
}

void quicksort(int s,int t)
{
    int i,j,x,g;
    point k;
    i=s; j=t; g=(s+t)>>1; x=a[g].value;
    while(i<=j)
    {
        while(a[i].value<x) i++;
        while(a[j].value>x) j--;
        if(i<=j)
        {
            k=a[i]; a[i]=a[j]; a[j]=k;
            i++; j--;
        }
    }
    if(s<j) quicksort(s,j);
    if(i<t) quicksort(i,t);
}

int main()
{
    scanf("%d",&n);
    while(n!=0)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i].value);
            a[i].pos=i;
        }
        quicksort(1,n);
        for(int i=1;i<=n;i++)   //离散化
            f[a[i].pos]=i;
        memset(c,0,sizeof(c));
        ans=0;
        for(int i=1;i<=n;i++)
        {
            ans+=(long long)i-1-sum(c,f[i]);
            update(c,f[i],1);
        }
        printf("%I64d\n",ans);
        scanf("%d",&n);
    }
    return 0;
}



 poj2481 Cows 【单点更新，区间求和】

http://poj.org/problem?id=2481

题意：有n头奶牛，每头奶牛覆盖一段区间[l,r]的牧草。若对于两只奶牛，l1<=l2，r1>=r2，r1-l1>r2-l2，则说奶牛1比奶牛2强。现在给你每头奶牛的牧草区域，问对于每头奶牛，有多少比它强的。

思路：离线。将奶牛的覆盖区域按l升序，r降序排列。那么对于每个r，之前只要出现一个比它大的ri，必定有li,ri覆盖的区域比l,r大（或者相等，特判），维护一个树状数组，对于每个r，看之前有多少个比它大的r即可。

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

#define lowbit(x) ((x)&(-(x)))

struct point
{
    int l,r,id;
    bool operator < (const point & p) const
    {
        if(l==p.l) return r>p.r;
        else return l<p.l;
    }
};

const int maxn=100010;

int n,maxx;
int c[maxn],ans[maxn];
point a[maxn];

void update(int *a,int x,int w)
{
    while(x<=maxx)
    {
        a[x]+=w;
        x+=lowbit(x);
    }
}

int sum(int *a,int x)
{
    int ans=0;
    while(x>0)
    {
        ans+=a[x];
        x-=lowbit(x);
    }
    return ans;
}

int main()
{
    scanf("%d",&n);
    while(n!=0)
    {
        maxx=0;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d",&a[i].l,&a[i].r);
            a[i].id=i;
            if(a[i].r>maxx)
                maxx=a[i].r;
        }
        sort(a+1,a+n+1);
        memset(c,0,sizeof(c));
        memset(ans,0,sizeof(ans));
        for(int i=1;i<=n;i++)
        {
            if(i!=1 && a[i].l==a[i-1].l && a[i].r==a[i-1].r)
                ans[a[i].id]=ans[a[i-1].id];
            else
                ans[a[i].id]=i-1-sum(c,a[i].r-1);
            update(c,a[i].r,1);
        }
        for(int i=1;i<=n-1;i++)
            printf("%d ",ans[i]);
        printf("%d\n",ans[n]);
        scanf("%d",&n);
    }
    return 0;

}


 

hdu4638 Group【单点更新，区间查询】

http://acm.hdu.edu.cn/showproblem.php?pid=4638

题意：给你一串数，然后对于每次询问l和r，问你在[l,r]中有多少段连续的数

思路：树状数组，离线。每向后添加一个i位置的数a[i]，先直接在这个位置+1，表示出现一个新组，然后看前面是否出现a[i]-1和a[i]+1，若出现a[i]-1，则在pos[a[i]-1]位置-1，a[i]+1同理。因为此时数段被合并起来了，a[i]就代表了它们的状态。将所有的询问按r从小到大排序。然后枚举i，树状数组维护的是第i个数之前那些-1,0,1的和。

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

#define lowbit(x) ((x)&(-(x)))

const int maxn=100001;

struct point
{
    int l,r,id;
    bool operator < (const point & p) const
    {
        return r<p.r;
    }
};

int T,n,m;
int a[maxn],c[maxn],pos[maxn],ans[maxn];
bool mark[maxn];
point q[maxn];

void update(int *a,int x,int w)
{
    while(x<=n)
    {
        a[x]+=w;
        x+=lowbit(x);
    }
}

int sum(int *a,int x)
{
    int ans=0;
    while(x>0)
    {
        ans+=a[x];
        x-=lowbit(x);
    }
    return ans;
}

int main()
{
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d",&n,&m);
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            pos[a[i]]=i;
        }

        for(int i=1;i<=m;i++)
        {
            scanf("%d%d",&q[i].l,&q[i].r);
            q[i].id=i;
        }
        sort(q+1,q+m+1);
        memset(mark,0,sizeof(mark));
        memset(c,0,sizeof(c));
        int j=1;
        for(int i=1;i<=n;i++)
        {
            mark[a[i]]=1;
            update(c,pos[a[i]],1);
            if(a[i]-1>0 && mark[a[i]-1])
                update(c,pos[a[i]-1],-1);
            if(a[i]+1<=n && mark[a[i]+1])
                update(c,pos[a[i]+1],-1);
            while(q[j].r==i)
            {
                ans[q[j].id]=sum(c,q[j].r)-sum(c,q[j].l-1);
                j++;
            }
        }
        for(int i=1;i<=m;i++)
            printf("%d\n",ans[i]);
    }
    return 0;
}

gemini_玥
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
树状数组（入门附模板）
cyyyyds857的博客
06-21 1901
树状数组或二叉索引树（英语：Binary Indexed Tree），又以其发明者命名为Fenwick树，最早由Peter M. Fenwick于1994年以A New Data Structure for Cumulative Frequency Tables为题发表在SOFTWARE PRACTICE AND EXPERIENCE。其初衷是解决数据压缩里的累积频率（Cumulative Frequency）的计算问题，现多用于高效计算数列的前缀和， 区间和。——源自百度百科。
树状数组树状数组树状数组树状数组
06-07
树状数组树状数组树状数组树状数组树状数组树状数组树状数组树状数组
树状数组(详细分析+应用)，看不懂打死我!
TheWayForDream
07-03 4万+
树状数组介绍 在学习一个算法之前一定要清楚它能干嘛，能解决什么样的问题，对你解题是否有帮助，然后才去学习它! 那么接下来看如下几个问题 什么是树状数组 顾名思义就是一个结构为树形结构的数组，于二叉树的结构类似但又不同，它是在二叉树的结构上删除了一些中间节点，来看两幅图就明白了. 1.这是二叉树的结构 2.这是树状数组的结构 不难发现，树状数组相比于二叉树删除了一些节点，但是为什么要删除呢？这就和树状数组的一些性质(lowbit)有关了，不懂没关系，继续往下看. 树状数组可以解决什么问题呢？ 可以解决大部
树状数组 java_树状数组详解
weixin_42220669的博客
02-16 1304
先来看几个问题吧。1.什么是树状数组？顾名思义，就是用数组来模拟树形结构呗。那么衍生出一个问题，为什么不直接建树？答案是没必要，因为树状数组能处理的问题就没必要建树。和Trie树的构造方式有类似之处。2.树状数组可以解决什么问题可以解决大部分基于区间上的更新以及求和问题。3.树状数组和线段树的区别在哪里树状数组可以解决的问题都可以用线段树解决，这两者的区别在哪里呢？树状数组的系数要少很多，就比如字...
树状数组数据结构
qq_37464878的博客
02-22 2525
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 429
树状数组（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 470
在生成多级树状数组之前，我们一般得到的数据结构如下[{"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 790
树状数组的一维和二维
树状数组_洛谷_树状数组_
10-02
树状数组，也被称为线段树（Segment Tree），是一种数据结构，主要用于高效地处理动态区间查询和修改问题。在编程竞赛和算法设计中，树状数组是解决许多问题的利器，尤其是在面对需要频繁更新和查询区间信息的问题时...
js用闭包遍历树状数组的方法
12-12
做公司项目时，要求写一个方法，方法的参数为一个菜单数组集合和一个菜单id，菜单数组的格式为树状json,如下面所示： 代码如下:[{“id”:28,”text”:”公司信息”,”children”:[  {“id”:1,”text”:”公司文化...
树状数组 树状数组.ppt
09-17
树状数组 树状数组.ppt
树状数组基本操作.rar
06-07
树状数组，也被称为线段树（Segment Tree），是一种数据结构，主要用于高效地处理区间查询与更新问题。在计算机科学中，特别是在算法设计和数据结构领域，它扮演着至关重要的角色。树状数组的设计思想是将数组的每个...
树状数组树状数组资料.txt
01-10
树状数组
树状数组的概念及使用场景
06-09
树状数组（Binary Indexed Tree，简称 BIT 或 Fenwick Tree）是一种可以高效计算数组前缀和的数据结构，同时支持快速修改数组元素的值。树状数组的主要优点是空间复杂度低（与原始数组相同），同时修改和查询操作的...
树状数组优缺点及场景.zip
06-11
树状数组，也被称为二进制索引树（Binary Indexed Tree, BIT），是计算机科学中一种数据结构，常用于高效地处理动态集合上的区间查询和更新操作。它以数组的形式存储数据，通过巧妙的数学计算使得对数组的任何一段...
算法NOIP树状数组校门外的树.pdf
05-02
本文详细介绍了树状数组的原理，并用树状数组解校门外的树这个问题.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值