牛课月赛9-红球进黑洞-(多个线段树+异或)

已于 2022-03-05 18:34:56 修改
阅读量105 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 算法 动态规划 矩阵
于 2022-03-04 18:27:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52398496/article/details/123282883
版权
这篇博客探讨了如何使用线段树解决区间异或、或、与操作的问题。通过建立不同类型的线段树，如20线段树，实现了对每个位上的1进行计数，从而快速处理区间查询和更新。文章还提供了区间异或、或、与操作的代码实现，并给出了区间最大值查询的AndRMQ问题的解决方案。总结强调了深入思考和理解数据结构在算法中的重要性。
摘要由CSDN通过智能技术生成

C

题意:
就是给你两个操作，一种是查询l到r的和，一种是让l到r都异或X。

思考：
就是建立20线段树，看看每一位有多少个1就行了。
同时类似的题目有区间或：RMQ
还有区间与:And RMQ

代码：

区间异或代码：

int T,n,m,k;
int va[N];
int cnt[N];

struct Node{
	int L,R;
	int laz;
	int sum;
};

struct segtree
{
	int now;
	Node t[4*N];
	void pushdown(int node)
	{
		int laz = t[node].laz;
		if(laz)
		{
			t[node_l].laz ^= laz;
			t[node_l].sum = (t[node_l].R-t[node_l].L+1)-t[node_l].sum;
			t[node_r].laz ^= laz;
			t[node_r].sum = (t[node_r].R-t[node_r].L+1)-t[node_r].sum;
			t[node].laz ^= 1;
		}
		return ;
	}
	void build(int node,int l,int r)
	{
		t[node].L = l,t[node].R = r;
		if(l==r)
		{
			t[node].sum = (va[l]>>now&1);
			return ;
		}
		int mid = l+r>>1;
		build(node_l,l,mid);build(node_r,mid+1,r);
		t[node].sum = t[node_l].sum+t[node_r].sum;
	}
	void update(int node,int l,int r,int value)
	{
		if(t[node].L>=l&&t[node].R<=r)
		{
			t[node].sum = (t[node].R-t[node].L+1)-t[node].sum;
			t[node].laz ^= value;
			return ;
		}
		pushdown(node);
		int mid = (t[node].L+t[node].R)>>1;
		if(l<=mid) update(node_l,l,r,value);
		if(r>mid) update(node_r,l,r,value);
		t[node].sum = t[node_l].sum+t[node_r].sum;
	}
	int query(int node,int l,int r)
	{
		if(t[node].L>=l&&t[node].R<=r) return t[node].sum;
		pushdown(node);
		int mid = (t[node].L+t[node].R)>>1;
		if(r<=mid) return query(node_l,l,r);
		else if(l>mid) return query(node_r,l,r);
		else return query(node_l,l,mid)+query(node_r,mid+1,r);
	}
}tr[25];

signed main()
{
	IOS;
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>va[i];
	for(int i=0;i<=22;i++) 
	{
		tr[i].now = i;
		tr[i].build(1,1,n);
	}
	while(m--)
	{
		int op,a,b,c;
		cin>>op>>a>>b;
		if(op==1)
		{
			int ans = 0;
			for(int i=0;i<=22;i++)
			ans += tr[i].query(1,a,b)*(1ll<<i);
			cout<<ans<<"\n";
		}
		else
		{
			cin>>c;
			for(int i=0;i<=22;i++)
			{
				if(!(c>>i&1)) continue;
				tr[i].update(1,a,b,1);
			}
		}
	}
	return 0;
}

区间或代码：
 
int T,n,m,k;
int va[N];
int cnt[N];

struct Node{
	int L,R;
	int laz;
	int sum;
};

struct segtree
{
	int now;
	Node t[4*N];
	void pushdown(int node)
	{
		int laz = t[node].laz;
		if(laz)
		{
			t[node_l].laz = 1;
			t[node_l].sum = (t[node_l].R-t[node_l].L+1);
			t[node_r].laz = 1;
			t[node_r].sum = (t[node_r].R-t[node_r].L+1);
			t[node].laz = 0;
		}
		return ;
	}
	void build(int node,int l,int r)
	{
		t[node].L = l,t[node].R = r;
		if(l==r)
		{
			t[node].sum = (va[l]>>now&1);
			return ;
		}
		int mid = l+r>>1;
		build(node_l,l,mid);build(node_r,mid+1,r);
		t[node].sum = t[node_l].sum+t[node_r].sum;
	}
	void update(int node,int l,int r,int value)
	{
		if(t[node].L>=l&&t[node].R<=r)
		{
			t[node].sum = (t[node].R-t[node].L+1);
			t[node].laz = value;
			return ;
		}
		pushdown(node);
		int mid = (t[node].L+t[node].R)>>1;
		if(l<=mid) update(node_l,l,r,value);
		if(r>mid) update(node_r,l,r,value);
		t[node].sum = t[node_l].sum+t[node_r].sum;
	}
	int query(int node,int l,int r)
	{
		if(t[node].L>=l&&t[node].R<=r) return t[node].sum;
		pushdown(node);
		int mid = (t[node].L+t[node].R)>>1;
		if(r<=mid) return query(node_l,l,r);
		else if(l>mid) return query(node_r,l,r);
		else return query(node_l,l,mid)+query(node_r,mid+1,r);
	}
}tr[25];

signed main()
{
	IOS;
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>va[i];
	for(int i=0;i<=22;i++) 
	{
		tr[i].now = i;
		tr[i].build(1,1,n);
	}
	while(m--)
	{
		string op;
		int a,b,c;
		cin>>op>>a>>b;
		if(op=="SUM")
		{
			ll ans = 0;
			for(int i=0;i<=22;i++)
			ans += tr[i].query(1,a,b)*(1ll<<i);
			cout<<ans<<"\n";
		}
		else
		{
			cin>>c;
			for(int i=0;i<=22;i++)
			{
				if(!(c>>i&1)) continue;
				tr[i].update(1,a,b,1);
			}
		}
	}
	return 0;
}

区间与代码：
int T,n,m,k;
int va[N];
int cnt[N];

struct Node{
	int L,R;
	int laz;
	int sum;
};

struct segtree
{
	int now;
	Node t[4*N];
	void pushdown(int node)
	{
		int laz = t[node].laz;
		if(laz)
		{
			t[node_l].laz = 1;
			t[node_l].sum = 0;
			t[node_r].laz = 1;
			t[node_r].sum = 0;
			t[node].laz = 0;
		}
		return ;
	}
	void build(int node,int l,int r)
	{
		t[node].L = l,t[node].R = r;
		if(l==r)
		{
			t[node].sum = (va[l]>>now&1);
			return ;
		}
		int mid = l+r>>1;
		build(node_l,l,mid);build(node_r,mid+1,r);
		t[node].sum = t[node_l].sum+t[node_r].sum;
	}
	void update(int node,int l,int r,int value)
	{
		if(t[node].L>=l&&t[node].R<=r)
		{
			t[node].sum = 0;
			t[node].laz = value;
			return ;
		}
		pushdown(node);
		int mid = (t[node].L+t[node].R)>>1;
		if(l<=mid) update(node_l,l,r,value);
		if(r>mid) update(node_r,l,r,value);
		t[node].sum = t[node_l].sum+t[node_r].sum;
	}
	void change(int node,int x,int value)
	{
		if(t[node].L==x&&t[node].R==x)
		{
			t[node].sum = value;
			return ;
		}
		pushdown(node);
		int mid = (t[node].L+t[node].R)>>1;
		if(x<=mid) change(node_l,x,value);
		else change(node_r,x,value);
		t[node].sum = t[node_l].sum+t[node_r].sum;
	}
	int query(int node,int l,int r)
	{
		if(t[node].L>=l&&t[node].R<=r) return t[node].sum;
		pushdown(node);
		int mid = (t[node].L+t[node].R)>>1;
		if(r<=mid) return query(node_l,l,r);
		else if(l>mid) return query(node_r,l,r);
		else return query(node_l,l,mid)+query(node_r,mid+1,r);
	}
}tr[32];

signed main()
{
	IOS;
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>va[i];
	for(int i=0;i<=30;i++) 
	{
		tr[i].now = i;
		tr[i].build(1,1,n);
	}
	while(m--)
	{
		string op;
		int a,b,c;
		cin>>op>>a>>b;
		if(op=="AND")
		{
			cin>>c;
			for(int i=0;i<=30;i++)
			{
				if((c>>i&1)) continue;
				tr[i].update(1,a,b,1);
			}	
		}
		if(op=="UPD")
		{
			for(int i=0;i<=30;i++)
			tr[i].change(1,a,(b>>i&1));
		}
		if(op=="QUE")
		{
			int ans = 0;
			for(int i=0;i<=30;i++)
			ans += tr[i].query(1,a,b)*(1ll<<i);
			cout<<ans<<"\n";
		}
	}
	return 0;
}

And RMQ的真正题意是求的区间最大值：

struct Node{
	int L,R;
	int sum;
	int maxn;
}t[4*N];

int T,n,m,k;
int va[N];

void build(int node,int l,int r)
{
	t[node].L = l,t[node].R = r;
	if(l==r)
	{
		t[node].sum = va[l];
		t[node].maxn = va[l];
		return ;
	}
	int mid = l+r>>1;
	build(node_l,l,mid);
	build(node_r,mid+1,r);
	t[node].sum = t[node_l].sum|t[node_r].sum;
	t[node].maxn = max(t[node_l].maxn,t[node_r].maxn);
}

void update1(int node,int x,int value)
{
	if(t[node].L>x||t[node].R<x) return ;
	if(t[node].L==x&&t[node].R==x)
	{
		t[node].sum = value;
		t[node].maxn = value;
		return ;
	}
	update1(node_l,x,value);
	update1(node_r,x,value);
	t[node].sum = t[node_l].sum|t[node_r].sum;
	t[node].maxn = max(t[node_l].maxn,t[node_r].maxn);
}

void update2(int node,int l,int r,int value)
{
	if(t[node].L>r||t[node].R<l) return ;
	if(t[node].L==t[node].R)
	{
		t[node].sum &= value;
		t[node].maxn &= value;
		return ;
	}
	if((value&t[node].sum)==t[node].sum) return ;
	update2(node_l,l,r,value);
	update2(node_r,l,r,value);
	t[node].sum = t[node_l].sum|t[node_r].sum;
	t[node].maxn = max(t[node_l].maxn,t[node_r].maxn);
}

int query(int node,int l,int r)
{
	if(t[node].L>r||t[node].R<l) return -inf;
	if(t[node].L>=l&&t[node].R<=r) return t[node].maxn;
	int mid = l+r>>1;
	return max(query(node_l,l,r),query(node_r,l,r));
}

signed main()
{
	IOS;
	cin>>n>>m;
	for(int i=1;i<=n;i++) cin>>va[i];
	build(1,1,n);
	for(int i=1;i<=m;i++)
	{
		string op;
		cin>>op;
		if(op=="AND")
		{
			int a,b,c;
			cin>>a>>b>>c;
			update2(1,a,b,c);
		}
		if(op=="UPD")
		{
			int a,b;
			cin>>a>>b;
			update1(1,a,b);
		}
		if(op=="QUE")
		{
			int a,b;
			cin>>a>>b;
			cout<<query(1,a,b)<<"\n";
		}
	}
	return 0;
}

总结：
多多思考。

可爱美少女
关注
专栏目录
[nowcoder]红球进黑洞
dxyinme-Zz
06-17 299
题目 链接：https://ac.nowcoder.com/acm/contest/6046/C 时间限制：C/C++ 3秒，其他语言6秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 在心理疏导室中有一种奇特的疏导工具，叫做红球。红球被提前分为了许多正方形小方格。 每当有人来找ATB做心理疏导时，ATB就会让他去先玩红球，然后通过红球小格方的高度来判断一个人的压力程度的高低 具体地讲，ATB会让该人对于一个序列执行以下操作 区间求和，
【2017西安邀请赛：A】XOR（区间异或最大值多次查询---线段树+线性基合并）
Cassie_zkq的博客
07-15 1119
补题地址：https://nanti.jisuanke.com/t/A1607 题目： Consider an arrayAwith n elements . Each of its element isA[i](1≤i≤n). Then gives two integersQ,K, andQqueries follow . Each query , give youL,...
红球进黑洞（思维 + 线段树 + 懒标记）
qq_53398102的博客
07-23 141
这个题有点难搞啊…我焯，一遍过！！！
牛客—— 红球进黑洞 （线段树+位运算）
我们都有光明的未来
08-05 276
牛客—— 红球进黑洞 （线段树+位运算） 铭宇巨巨推荐的题！ 原题链接 题意： 给定一个序列，两种操作，一是区间求和，二是将区间里的每个数都异或x。 思路： 一眼就线段树，关键是怎么维护第二个操作。 借助最小异或生成树的思想以及异或题的常见套路，我们可以把每个数都进行二进制拆分，用线段树分别维护每一位上的0和1。 对于操作二，我们只需要分别维护每一位的值即可；对于操作一，计算区间里1的个数乘以对应的位数，就相当于是二进制转化为十进制的过程。 代码： #pragma GCC optimize(3) #prag
牛客小白月赛9 C-红球进黑洞
idemor的博客
11-28 203
有一个长50000的序列，ATB会让该人对于一个序列执行以下操作： 1. 区间求和，即输入l,r，输出 2. 区间异或，即输入l,r,k，对于l ≤ i ≤ r，将xi变为 操作次数最多为1e5。 思路：对所有数对应二进制的某一位创建线段树，总计创建20棵线段树，当区间所有点都异或k的时候， 需要做的操作只是将k的二进制中存在的位的那些棵线段树进行修改，将对应区间中的1变成0，0变成1， ...
牛客小白月赛9 C 红球进黑洞【线段树+模拟位运算】
哇-WA 的博客
11-17 300
时间限制：C/C++ 3秒，其他语言6秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述  在心理疏导室中有一种奇特的疏导工具，叫做红球。红球被提前分为了许多正方形小方格。 每当有人来找ATB做心理疏导时，ATB就会让他去先玩红球，然后通过红球小格方的高度来判断一个人的压力程度的高低 具体地讲，ATB会让该人对于一个序列执行以...
牛客算法周周练11C - 红球进黑洞（二维线段树+区间异或+区间求和）
在读NLP硕士
06-18 275
链接：https://ac.nowcoder.com/acm/contest/6046/C 来源：牛客网 时间限制：C/C++ 3秒，其他语言6秒 空间限制：C/C++ 262144K，其他语言524288K 64bit IO Format: %lld 题目描述 在心理疏导室中有一种奇特的疏导工具，叫做红球。红球被提前分为了许多正方形小方格。 每当有人来找ATB做心理疏导时，ATB就会让他去先玩红球，然后通过红球小格方的高度来判断一个人的压力程度的高低 具体地讲，ATB会让该人对于一个序列执行以下操作 区
（线段树）小白月赛9-C红球进白洞
weixin_40588429的博客
11-20 157
https://ac.nowcoder.com/acm/contest/275/C 具体地讲，ATB会让该人对于一个序列执行以下操作 区间求和，即输入l, r，输出xi(l &amp;lt;= i &amp;lt;= r)的和 区间异或，即输入l,r,k，对于l ≤ i ≤ r，将xi变为xi ^ k 可是ATB天天算计那么多答案，已经对这份工作产生了厌烦，所以请你帮帮他，对于一组给定的数据，输出对应的答案 ...
蓝桥杯2024年第十五届省赛真题-最大异或结点
05-01
蓝桥杯2024年第十五届省赛真题-最大异或结点
bp-异或
02-17
"bp-异或"这个标题和描述可能是指一个与C++编程相关的项目或者问题，其中“bp”可能是项目、算法或者变量的缩写，而“异或”是计算机科学中的逻辑运算符。在C++中，异或操作符是`^`，用于执行位级的异或操作。这个...
xor.zip_puttinge9a_区间异或最大_字典树查找区间异或最大值_寻找最窄区间_异或最大值
09-24
在给定的压缩包文件中，我们可以看到一个名为"xor.zip_puttinge9a_区间异或最大_字典树查找区间异或最大值_寻找最窄区间_异或最大值"的文件，这暗示了使用字典树（Trie）数据结构来解决这一问题。 首先，让我们深入...
牛客OI月赛12-提高组 C. 区间异或和异或区间最大值异或区间最小值（分治+字典树）
积极的防守者的博客
09-28 1707
题目链接 题目大意 给你n个数，对于一个区间[l,r]，xorsum=这个区间所有异或和，min = 区间最小值，max = 区间最大值，要求xorsum ^ min ^ max最大。 解题思路 对于xor最大，我们一般会往两个方向想：一.线性基 二.01字典树 这题是用字典树。如果只是求xorsum最大，我们可以维护一个前缀异或和的字典树，然后每次得到新的前缀异或和，先在字典树查一下能得到的最大...
二叉树最小深度
2301_80161204的博客
09-27 468
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1280
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1008
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
最新发布
wnm23的专栏
10-02 511
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1280
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 498
排序是将多个数据，依指定的顺序进行排列的过程。
线段相交的异或值 （线段树 or 优先队列）
05-30
线段相交的异或值可以用线段树或优先队列来实现。 一种常见的实现方式是使用线段树。我们可以在每个节点上保存一个异或值，表示这个节点对应的线段是否与查询线段相交。对于查询线段，我们可以在树上从根节点开始往...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值