树状数组合集

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

hdu 4605 Magic Ball Game

树状数组在dfs的应用，比较适合求区间的和 
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
#define MAXN 100010
/**
    从1到v的路径固定，按照dfs的思想，等同于只考虑
    一条支路；在一条支路上分为左右部分，找出大于x的
    个数和小于x的个数
*/
int n, m, q;
int w[MAXN], cnt, d[MAXN<<1], res[MAXN<<1][2], ans[MAXN][2];
struct node {int a, b; node(int _a, int _b):a(_a),b(_b){}};
vector<int> son[MAXN];
vector<node> mp[MAXN];
int lowbit(int c)
{
    return c & -c;
}
void update(int u, int c, int val)
{
    for (int i = u; i <= cnt; i += lowbit(i))
        res[i][c] += val;
}
int getSum(int u, int c)
{
    int sum = 0;
    for (int i = u; i > 0; i -= lowbit(i))
        sum += res[i][c];
    return sum;
}
int top, stk[MAXN];
int cson[MAXN], mpot[MAXN];
void dfs()
{
    top = 0;
    stk[top++] = 1;
    memset(cson, 0, sizeof cson);
    int u, i, s;
    int wei, dx, p, la, ra, lb, rb, lc, rc;
    int v, wv;
    while (top)
    {
        u = stk[top-1];
        if (cson[u] == 0)
        {
            s = mp[u].size();
            for (i = 0; i< s; ++i)
            {
                wei = mp[u][i].b;
                dx = mp[u][i].a;
                p = lower_bound(d, d+cnt, wei)-d+1;
                la = getSum(p-1, 0);
                ra = getSum(p-1, 1);
                lb = getSum(cnt, 0);
                rb = getSum(cnt, 1);
                lc = lb - getSum(p, 0);
                rc = rb - getSum(p, 1);
                if (la+ra+lc+rc - lb - rb)
                {
                    ans[dx][1] = -1;
                    continue;
                }
                ans[dx][0] = ra;
                ans[dx][1] = (la+ra)*3 + lc + rc;
            }
        }
        if (son[u].size() == 0)
        {
            top--;
            continue;
        }
        s = cson[u];
        if (s & 0x1)
        {
            update(mpot[u], s>>1, -1);
            s = ++cson[u];
            if (s > 3)
            {
                --top;
                continue;
            }
        }
        v = son[u][s>>1];
        wv = w[u];
        mpot[u] = p = lower_bound(d, d+cnt, wv)-d+1;
        update(p, s>>1, 1);
        stk[top++] = v;
        cson[u]++;
    }
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif // ONLINE_JUDGE
    int t, i;
    int u, a, b, x, v;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        cnt = 0;
        for (i = 0; i<= n; ++i)
        {
            son[i].clear();
        }
        for (i = 1; i<= n; ++i)
        {
            scanf("%d", &w[i]);
            d[cnt++] = w[i];
        }
        scanf("%d", &m);
        for (i = 0; i< m; ++i)
        {
            scanf("%d%d%d", &u, &a, &b);
            son[u].push_back(a);
            son[u].push_back(b);
        }
        scanf("%d", &q);
        for (i = 0; i<= q; ++i) mp[i].clear();
        for (i = 0; i< q; ++i)
        {
            scanf("%d%d", &v, &x);
            mp[v].push_back(node(i, x));
            d[cnt++] = x;
        }
        sort(d, d+cnt);
        cnt = unique(d, d+cnt)-d;
        memset(res, 0, sizeof res);
        dfs();
        for (i = 0; i< q; ++i)
        {
            if (ans[i][1] == -1)
                printf("0\n");
            else
                printf("%d %d\n", ans[i][0], ans[i][1]);
        }
    }
    return 0;
}

hdu 4630 No Pain No Game

树状数组、离散化 
#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
const int MAXN = 50005;
int n;
int a[MAXN];
int tree[MAXN], pre[MAXN], res[MAXN];
int lowbit(int i)
{
    return i & (-i);
}
void add(int pos, int val)
{
    while (pos <= n)
    {
        tree[pos] = max(tree[pos], val);
        pos += lowbit(pos);
    }
}
int solve(int i)
{
    int r = 0;
    while (i > 0)
    {
        r = max(r, tree[i]);
        i -= lowbit(i);
    }
    return r;
}
struct node
{
    int idx, l, r;
    bool operator < (const node & e) const
    {
        return l > e.l;
    }
    void getin()
    {
        scanf("%d%d", &l, &r);
    }
}query[MAXN];
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    int t;
    scanf("%d", &t);
    while (t--)
    {
        scanf("%d", &n);
        for (int i = 1; i<= n; ++i)
        {
            scanf("%d", a+i);
        }
        int q;
        scanf("%d", &q);
        for (int i = 0; i< q; ++i)
        {
            query[i].getin(); query[i].idx = i;
        }
        sort(query, query+q);
        memset(tree, 0, sizeof tree);
        memset(pre, 0, sizeof pre);
        for (int i = 0, j = n; i< q; )
        {
            for (; j>0 && j >= query[i].l; --j)
            {
                for(int k = 1; k*k <= a[j]; ++k)
                {
                    if (a[j] % k == 0)
                    {
                        if (pre[k])
                        {
                            add(pre[k], k);
                        }
                        pre[k] = j;
                        if (k != a[j]/k)
                        {
                            if (pre[a[j]/k])
                            {
                                add(pre[a[j]/k], a[j]/k);
                            }
                            pre[a[j]/k] = j;
                        }
                    }
                }
            }
            while (i < q && query[i].l > j)
            {
                res[query[i].idx] = solve(query[i].r);
                ++i;
            }
        }
        for (int i = 0; i < q; ++i)
            printf("%d\n", res[i]);
    }
    return 0;
}


hdu 4638 Group

与上一题类似 
#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 100005;
int sum[MAXN], a[MAXN];
int ans[MAXN];
int vis[MAXN];
int n, m;
// sum[i] 代表 
struct qy
{
	int s, e, id;
	bool operator < (const qy & v) const
	{
		return s < v.s;
	}	
	void getin(int k) 
	{
		id = k;
		scanf("%d%d", &s, &e);
	}
}q[MAXN];
int lowbit(int i) 
{
	return i &(-i);
}
void add(int i, int val)
{
	while (i<= n)
	{
		sum[i] += val;
		i += lowbit(i);
	}
}
int query(int i)
{
	int num = 0;
	while (i > 0)
	{
		num += sum[i];
		i -= lowbit(i);
	}
	return num;
}
int main()
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	int t;
	scanf("%d", &t);
	while (t--)
	{
		scanf("%d%d", &n, &m);
		for (int i = 1; i<= n; ++i)
		{
			scanf("%d", a+i);
		}
		memset(sum, 0, sizeof sum);
		memset(vis, 0, sizeof vis);
		for (int i = 1; i<= m; ++i)
		{
			q[i].getin(i);
		}
		sort(q+1, q+1+m);
		int k = m;
		for (int i = n; i>= 1; --i)
		{
			int tp = a[i];
			vis[tp] = i;
			add(i, 1);
			if (vis[tp+1]) add(vis[tp+1], -1);
			if (vis[tp-1]) add(vis[tp-1], -1);
			while (k >= 1 && q[k].s == i)
			{
				ans[q[k].id] = query(q[k].e) - query(i-1);
				k--;
			}
		}
		for (int i = 1; i<= m; ++i)
		{
			printf("%d\n", ans[i]);
		}
	}
	return 0;
}


hdu 4777 Rabbit Kingdom

树状数组求解区间内互质的数个数 
#include <cstdio>
#include <iostream>
#include <cmath>
#include <map>
#include <algorithm>
#include <vector>
using namespace std;
const int MAXN = 200010;
int n, m;
int sum[MAXN], isprm[MAXN], prime[MAXN], nprm;
int num[MAXN], cp[MAXN][15], LL[MAXN], RR[MAXN], U[MAXN], O[MAXN], ans[MAXN];
vector<int> mmp[MAXN];
struct _query
{
	int l, r, d;
	bool operator < (const _query & a) const
	{
		return r < a.r;
	}
}query[MAXN];
void getprime()
{
	nprm = 0;
	for (int i = 2; i< 500; ++i)
	{
		if (isprm[i] == 0) prime[nprm++] = i;
		for (int j = 0; j<nprm && i*prime[j] < MAXN; ++j)
		{
			isprm[i*prime[j]] = 1;
			if (i % prime[j] == 0) break;
		}
	}
}
int lowbit(int c){	return c&-c; }
void add(int u, int val)
{
	if (!u) return;
	while (u <= n)
	{
		sum[u] += val;
		u += lowbit(u);
	}
}
int getsum(int u)
{
	int res = 0;
	while (u > 0)
	{
		res += sum[u];
		u -= lowbit(u);
	}
	return res;
}
void dividePrime(int idx)
{
	int tp = num[idx];
	cp[idx][0] = 0;
	for (int i = 0; i< nprm && prime[i]*prime[i]<=tp ; ++i)
	{
		if (tp % prime[i] == 0)
		{
			cp[idx][++cp[idx][0]] = prime[i];
			while (tp % prime[i] == 0) tp/=prime[i];
		}
	}
	if (tp != 1) cp[idx][++cp[idx][0]] = tp;
}
int main()
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
	int idx;
	getprime();
	while (scanf("%d%d", &n, &m) && (n+m))
	{
		for (int i = 1; i<= n; ++i) scanf("%d", num+i);
		for (int i = 0; i< m; ++i)
		{
			scanf("%d%d", &query[i].l, &query[i].r);
			query[i].d = i;
		}
		sort(query, query+m);
		memset(sum, 0, sizeof sum);
		for (int i = 1; i<= n; ++i) 
			dividePrime(i), LL[i] = 0, RR[i] = n+1;
		for (int i = 0; i< MAXN; ++i)
			U[i] = 0, O[i] = n+1;		
		for (int i = 1; i<= n; ++i)
		{
			for (int j = 1, k=cp[i][0]; j<= k; ++j)
			{
				LL[i] = max(LL[i], U[cp[i][j]]);
				U[cp[i][j]] = i;
			}
		}
		for (int i = n; i>= 1; --i)
		{
			for (int j = 1, k=cp[i][0]; j<= k; ++j)
			{
				RR[i] = min(RR[i], O[cp[i][j]]);
				O[cp[i][j]] = i;
			}
		}
		for (int i = 1; i<= n; ++i) mmp[i].clear();
		for (int i = 1; i<= n; ++i) mmp[RR[i]].push_back(i);
		idx = 1;
		for (int i = 0; i< m; ++i)
		{
			while (idx <= query[i].r && idx <= n)
			{
				add(LL[idx], 1);
				for (int a, j = 0, k=mmp[idx].size(); j<k; ++j)
				{
					a = mmp[idx][j];
					add(LL[a], -1);
					add(a, 1);
				}
				++idx;
			}
			ans[query[i].d] = getsum(query[i].r) - getsum(query[i].l-1);
			ans[query[i].d] = query[i].r-query[i].l+1 - ans[query[i].d];
		}
		for (int i = 0; i< m; ++i) printf("%d\n", ans[i]);
	}
    return 0;
}


deprecated_tzg
关注
专栏目录
树状数组（入门附模板）
cyyyyds857的博客
06-21 2058
树状数组或二叉索引树（英语：Binary Indexed Tree），又以其发明者命名为Fenwick树，最早由Peter M. Fenwick于1994年以A New Data Structure for Cumulative Frequency Tables为题发表在SOFTWARE PRACTICE AND EXPERIENCE。其初衷是解决数据压缩里的累积频率（Cumulative Frequency）的计算问题，现多用于高效计算数列的前缀和， 区间和。——源自百度百科。
js用闭包遍历树状数组的方法
12-12
做公司项目时，要求写一个方法，方法的参数为一个菜单数组集合和一个菜单id，菜单数组的格式为树状json,如下面所示： 代码如下:[{“id”:28,”text”:”公司信息”,”children”:[  {“id”:1,”text”:”公司文化...
树状数组(详细分析+应用)，看不懂打死我!
TheWayForDream
07-03 5万+
树状数组介绍 在学习一个算法之前一定要清楚它能干嘛，能解决什么样的问题，对你解题是否有帮助，然后才去学习它! 那么接下来看如下几个问题 什么是树状数组 顾名思义就是一个结构为树形结构的数组，于二叉树的结构类似但又不同，它是在二叉树的结构上删除了一些中间节点，来看两幅图就明白了. 1.这是二叉树的结构 2.这是树状数组的结构 不难发现，树状数组相比于二叉树删除了一些节点，但是为什么要删除呢？这就和树状数组的一些性质(lowbit)有关了，不懂没关系，继续往下看. 树状数组可以解决什么问题呢？ 可以解决大部
树状数组 java_树状数组详解
weixin_42220669的博客
02-16 1379
先来看几个问题吧。1.什么是树状数组？顾名思义，就是用数组来模拟树形结构呗。那么衍生出一个问题，为什么不直接建树？答案是没必要，因为树状数组能处理的问题就没必要建树。和Trie树的构造方式有类似之处。2.树状数组可以解决什么问题可以解决大部分基于区间上的更新以及求和问题。3.树状数组和线段树的区别在哪里树状数组可以解决的问题都可以用线段树解决，这两者的区别在哪里呢？树状数组的系数要少很多，就比如字...
树状数组数据结构
qq_37464878的博客
02-22 2683
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 586
树状数组（Binary Indexed Tree，简称BIT）是一种用于高效处理数组范围查询和单点更新操作的数据结构。它解决了传统的线段树在处理范围查询时的低效问题，并且在某些情况下，比如查询和更新操作频繁的情况下，它比线段树更快。请注意，树状数组的索引是从1开始的，所以我们在所有操作中都对索引进行了加1的处理。此外，树状数组的大小通常是原始数组的大小加上1，以确保我们可以安全地使用索引来访问所有的节点。表示为一个二进制数，然后用这个二进制数的最后一个1来确定它是哪个父节点的子节点。调用来计算出区间和。
树状数组详解
萧何山的博客
07-31 1万+
文章目录前言一、树状数组概括二、树状数组的应用1.单点修改+区间查询总结 前言 树状数组或二叉索引树（Binary Indexed Tree），又以其发明者命名为 Fenwick 树。其初衷是解决数据压缩里的累积频率的计算问题，现多用于高效计算数列的前缀和、区间和。它可以以 O(logn) 的时间得到任意前缀和。并同时支持在 O(logn) 时间内支持动态单点值的修改。空间复杂度 O(n)。 一、树状数组概括 树状数组是一个查询和修改复杂度都为log(n)的数据结构。主要用于数组的单点修改&
树状数组与线段树
qq_46118239的博客
10-11 1209
树状数组与线段树
Python 树状数组
youyouxiong的博客
06-07 496
树状数组的核心思想是使用一个数组来存储原数组的累积和，然后利用数组的偏移来快速计算区间和。这种数据结构在时间复杂度上具有优势，对于单点更新和区间查询，它们的时间复杂度都是 (O(\log n))。请注意，树状数组通常从索引1开始，而不是0，这与 Python 中列表的索引方式不同。如果你需要从0开始，可以在调用。方法时，将索引减1。
php 生成树形数组,php递归生成无限极树状数组
weixin_29091105的博客
04-11 533
在生成多级树状数组之前，我们一般得到的数据结构如下[{"id": 6,"parent_id": 5,"name": "体育专题1","intro": "体育专题1111介绍",}, {"id": 5,"parent_id": 4,"name": "体育专题","intro": "体育专题介绍",}, {"id": 4,"parent_id": 0,"name": "体育","intro": "体育...
树状数组_洛谷_树状数组_
10-02
树状数组，也被称为线段树（Segment Tree），是一种数据结构，主要用于高效地处理动态区间查询和修改问题。在编程竞赛和算法设计中，树状数组是解决许多问题的利器，尤其是在面对需要频繁更新和查询区间信息的问题时...
算法NOIP树状数组校门外的树.pdf
05-02
树状数组的核心思想是通过特定的二进制索引操作，将一个一维数组转化为类似树形的数据结构，进而利用这种结构简化更新和查询操作。 在树状数组中，我们不直接维护前缀和数组S[]，而是将其划分为若干个小区间和，并...
树状数组 树状数组.ppt
09-17
树状数组 树状数组.ppt
【LSTM回归预测】基于emd结合长短记忆神经网络lstm实现风速回归预测附Matlab源码.rar
10-28
1.版本：matlab2014/2019a/2024a 2.附赠案例数据可直接运行matlab程序。 3.代码特点：参数化编程、参数可方便更改、代码编程思路清晰、注释明细。 4.适用对象：计算机，电子信息工程、数学等专业的大学生课程设计、期末大作业和毕业设计。
SVM classifier train test result
10-28
SVM classifier train test result
奇迹书屋_24.08.10.apk
10-28
奇迹书屋_24.08.10.apk
Qt文件拷贝器（源码）
最新发布
10-28
Qt多线程文件拷贝器
【Unity顶点纹理烘焙插件】Vertex Texture Baker
10-28
文件名：Vertex Texture Baker v2024.1.unitypackage Vertex Texture Baker 是一个 Unity 插件，专为开发者提供将纹理数据烘焙到顶点颜色中的工具。这种技术对于优化模型或场景中的资源管理和渲染性能非常有帮助，特别是在不需要高分辨率纹理或希望减少内存占用的情况下。 主要功能： 纹理数据烘焙到顶点颜色： 该插件允许开发者将模型的纹理数据烘焙到其顶点颜色中，从而替代高分辨率的纹理贴图。这样可以有效减少材质贴图的使用，降低内存和显存的消耗。 支持多种纹理类型： 颜色纹理：将颜色信息直接烘焙到顶点数据。 法线纹理 (Normal Map)：将法线信息转换并存储到顶点中，用于光照和细节渲染。 高度纹理 (Height Map)：可以烘焙地形等物体的高度信息到顶点上，适用于低多边形模型的细节增强。 提高性能： 烘焙后的模型不再依赖高分辨率纹理，减少了材质和纹理的调用次数，从而提升整体渲染性能，尤其在移动端设备和低端硬件上表现突出。 优化内存占用： 通过减少纹理贴图的使用，插件可以显著减少 GPU 和内存的占用量......
树状数组详解与应用
"这是一份关于树状数组的综合学习资料，主要针对树状数组的基本原理和在POJ编程竞赛中的应用进行了整理。文档中包含了树状数组的核心算法实现，包括`Lowbit`、`Update`和`Getsum`三个关键函数的详细解释。" 树状...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值