[HDU - 4578]Transformation（线段树+多重懒标记）

最新推荐文章于 2024-08-19 01:03:13 发布
最新推荐文章于 2024-08-19 01:03:13 发布
阅读量575 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： # 数据结构题目 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_72060925/article/details/130349306
本文详细介绍了如何使用线段树配合懒标记解决具有加、乘、赋值三种区间操作的问题，涉及到pushup和pushdown函数的实现，以及处理不同标记下传的优先级策略。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

[HDU - 4578]Transformation（线段树+多重懒标记）

一、问题

在这里插入图片描述

二、分析

这道题涉及到了区间操作，所以我们用线段树算法。同时，这道题里面有区间修改的操作，所以我们还要用到懒标记。

这里一共有三种区间的操作，分别是：加、乘、赋值。这三种操作无法用一个懒标记来统一，所以我们需要使用三个懒标记来完成这道题。

这道题的查询操作也分为三种，一次方的和、二次方的和、三次方的和。

所以我们需要去维护三种 s u m sum sum。

1、节点定义

/*
tag_1 --> 加法
tag_2 --> 乘法
tag_3 --> 赋值
*/
struct Node
{
	int l, r;
	int sum1, sum2, sum3;
	int tag_1, tag_2, tag_3;
}tre[N * 4];

2、pushup

p u s h u p pushup pushup函数就是利用子节点来更新父节点，这个操作比较简单，直接合并三种和即可。

//lson 是左儿子， rson是右儿子
void pushup(int u)
{
	tre[u].sum1 = (tre[lson].sum1 + tre[rson].sum1) % mod;
	tre[u].sum2 = (tre[lson].sum2 + tre[rson].sum2) % mod;
	tre[u].sum3 = (tre[lson].sum3 + tre[rson].sum3) % mod;
}

3、pushdown

p u s h d o w n pushdown pushdown操作是将三种懒标记下传的操作。这里需要注意两个问题：
1、每种标记如何下传？
2、三种标记之间下传的优先级问题。

（1）每种标记如何下传？

赋值

赋值公式如下图所示：
在这里插入图片描述
l e n = r − l + 1 len = r - l + 1 len=r−l+1
另外需要注意在计算过程中进行取模。

乘法

如下图所示：
在这里插入图片描述
提取公因式即可。

加法

加法是最难处理的，分类讨论一下。
先说一次方。
在这里插入图片描述
再说二次方
在这里插入图片描述
最后说三次方
在这里插入图片描述

（2）三种标记下传的优先级问题

对于某一个区间而言，三种操作可能同时出现。当出现赋值操作的时候，说明在此操作之前出现的加、乘都没有用了，因为都被当前的赋值操作覆盖掉了。所以我们最先考虑的是赋值操作。

如果该区间没有赋值操作，我们考虑的就是乘法操作，乘法出现的时候，说明在此次操作之前的加法操作的数值p也同样需要翻对应的倍数。

最后我们考虑加法。

综合上述讨论，我们可以写出下面的函数实现：

另外我们需要注意，在下传的过程中，我们要将左右区间的标记转化到对应的数值上。

void pushdown(int u)
{
	auto &root = tre[u], &left = tre[lson], &right = tre[rson];
	if(root.tag_3)
	{
		int c = root.tag_3;
		int len1 = (left.r - left.l + 1);
		left.sum1 = len1 * c % mod;
		left.sum2 = len1 * c * c % mod;
		left.sum3 = len1 * c % mod * c % mod * c % mod;
		
		int len2 = (right.r - right.l + 1);
		right.sum1 = len2 * c % mod;
		right.sum2 = len2 * c * c % mod;
		right.sum3 = len2 * c * c * c % mod;
		
		left.tag_3 = right.tag_3 = c;
		left.tag_1 = right.tag_1 = 0;
		left.tag_2 = right.tag_2 = 1;
		root.tag_3 = 0;
	}
	if(root.tag_2 != 1)
	{
		int c = root.tag_2;
		left.sum1 = left.sum1 * c % mod;
		left.sum2 = left.sum2 * c * c % mod;
		left.sum3 = left.sum3 * c * c * c % mod;

		right.sum1 = right.sum1 * c % mod;
		right.sum2 = right.sum2 * c * c % mod;
		right.sum3 = right.sum3 * c * c * c % mod;		
		
		right.tag_2 = c * right.tag_2 % mod;
		left.tag_2 = c * left.tag_2 % mod;

		right.tag_1 = c * right.tag_1 % mod;
		left.tag_1 = c * left.tag_1 % mod;

		root.tag_2 = 1; 
	}

	if(root.tag_1)
	{
		int c = root.tag_1;

		int s1 = left.sum1;
		int s2 = left.sum2;
		
		int len1 = left.r - left.l + 1;
		left.sum1 = (left.sum1 + len1 * c) % mod;
		left.sum2 = (left.sum2 + 2 * s1 * c + len1 * c * c) % mod;
		left.sum3 = (left.sum3 + 3 * c * s2 + 3 * s1 * c * c + len1 * c * c * c) % mod;
		
		s1 = right.sum1;
		s2 = right.sum2;
		int len2 = right.r - right.l + 1;
		right.sum1 = (right.sum1 + len2 * c) % mod;
		right.sum2 = (right.sum2 + 2 * s1 * c + len2 * c * c % mod) % mod;
		right.sum3 = (right.sum3 + 3 * c * s2 % mod + 3 * s1 * c * c % mod + len2 * c % mod * c % mod * c % mod ) % mod;
		
		left.tag_1 = (c + left.tag_1) % mod;
		right.tag_1 = (c + right.tag_1) % mod;
		root.tag_1 = 0;
	}
}

以上就是这道题所有的难点，剩下的函数操作就比较常规了。大家直接看代码实现即可。

三、代码

#include<bits/stdc++.h>
#define endl '\n'
#define INF 0x3f3f3f3f
#define lson u << 1
#define rson u << 1 | 1
#define int long long
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
const int N = 1e5 + 10;
const int mod = 1e4 + 7;
int n, m;
struct Node
{
	int l, r;
	int sum1, sum2, sum3;
	int tag_1, tag_2, tag_3;
}tre[N * 4];

void pushup(int u)
{
	tre[u].sum1 = (tre[lson].sum1 + tre[rson].sum1) % mod;
	tre[u].sum2 = (tre[lson].sum2 + tre[rson].sum2) % mod;
	tre[u].sum3 = (tre[lson].sum3 + tre[rson].sum3) % mod;
}

void pushdown(int u)
{
	auto &root = tre[u], &left = tre[lson], &right = tre[rson];
	if(root.tag_3)
	{
		int c = root.tag_3;
		int len1 = (left.r - left.l + 1);
		left.sum1 = len1 * c % mod;
		left.sum2 = len1 * c * c % mod;
		left.sum3 = len1 * c % mod * c % mod * c % mod;
		
		int len2 = (right.r - right.l + 1);
		right.sum1 = len2 * c % mod;
		right.sum2 = len2 * c * c % mod;
		right.sum3 = len2 * c * c * c % mod;
		
		left.tag_3 = right.tag_3 = c;
		left.tag_1 = right.tag_1 = 0;
		left.tag_2 = right.tag_2 = 1;
		root.tag_3 = 0;
	}
	if(root.tag_2 != 1)
	{
		int c = root.tag_2;
		left.sum1 = left.sum1 * c % mod;
		left.sum2 = left.sum2 * c * c % mod;
		left.sum3 = left.sum3 * c * c * c % mod;

		right.sum1 = right.sum1 * c % mod;
		right.sum2 = right.sum2 * c * c % mod;
		right.sum3 = right.sum3 * c * c * c % mod;		
		
		right.tag_2 = c * right.tag_2 % mod;
		left.tag_2 = c * left.tag_2 % mod;

		right.tag_1 = c * right.tag_1 % mod;
		left.tag_1 = c * left.tag_1 % mod;

		root.tag_2 = 1; 
	}

	if(root.tag_1)
	{
		int c = root.tag_1;

		int s1 = left.sum1;
		int s2 = left.sum2;
		
		int len1 = left.r - left.l + 1;
		left.sum1 = (left.sum1 + len1 * c) % mod;
		left.sum2 = (left.sum2 + 2 * s1 * c + len1 * c * c) % mod;
		left.sum3 = (left.sum3 + 3 * c * s2 + 3 * s1 * c * c + len1 * c * c * c) % mod;
		
		s1 = right.sum1;
		s2 = right.sum2;
		int len2 = right.r - right.l + 1;
		right.sum1 = (right.sum1 + len2 * c) % mod;
		right.sum2 = (right.sum2 + 2 * s1 * c + len2 * c * c % mod) % mod;
		right.sum3 = (right.sum3 + 3 * c * s2 % mod + 3 * s1 * c * c % mod + len2 * c % mod * c % mod * c % mod ) % mod;
		
		left.tag_1 = (c + left.tag_1) % mod;
		right.tag_1 = (c + right.tag_1) % mod;
		root.tag_1 = 0;
	}
}

void build(int u, int l, int r)
{
	if(l == r)
	{
		tre[u] = {l, r};
		tre[u].tag_2 = 1;
		return;
	}
	int mid = l + r >> 1;
	tre[u] = {l, r};
	tre[u].tag_2 = 1;
	build(lson, l, mid);
	build(rson, mid + 1, r);
}

void modify(int u, int l, int r, int c, int op)
{
	if(tre[u].l >= l && tre[u].r <= r)
	{
		auto &root = tre[u];
		if(op == 1)
		{
			int s1 = root.sum1;
			int s2 = root.sum2;
			root.sum1 = (root.sum1 + (root.r - root.l + 1) * c) % mod;
			root.sum2 = (root.sum2 + 2 * s1 * c % mod + (root.r - root.l + 1) * c % mod * c % mod) % mod;
			root.sum3 = (root.sum3 + 3 * c * s2 % mod + 3 * s1 * c * c % mod + (root.r - root.l + 1) * c % mod * c * c % mod ) % mod;
			root.tag_1 = (c + root.tag_1) % mod;
		}
		else if(op == 2)
		{
			root.sum1 = root.sum1 * c % mod;	
			root.sum2 = root.sum2 * c * c % mod;
			root.sum3 = root.sum3 * c % mod * c % mod * c % mod;
			root.tag_2 = c * root.tag_2 % mod;
			root.tag_1 = c * root.tag_1 % mod;
		}
		else
		{
			root.sum1 = (root.r - root.l + 1) * c % mod;
			root.sum2 = (root.r - root.l + 1) * c * c % mod;
			root.sum3 = (root.r - root.l + 1) * c % mod * c % mod * c % mod;
			root.tag_3 = c;
			root.tag_1 = 0;
			root.tag_2 = 1;
		}
		return;
	}
	pushdown(u);
	int mid = tre[u].l + tre[u].r >> 1;
	if(l <= mid)
		modify(lson, l, r, c, op);

	if(r > mid)
		modify(rson, l, r, c, op);

	pushup(u);
}

int query(int u, int l, int r, int op)
{
	if(tre[u].l >= l && tre[u].r <= r)
	{
		if(op == 1)
			return tre[u].sum1;
		else if(op == 2)
			return tre[u].sum2;
		else
			return tre[u].sum3;
	}
	int mid = tre[u].l + tre[u].r >> 1;
	int res = 0;
	pushdown(u);
	if(l <= mid)
		res = (res + query(lson, l, r, op)) % mod;
	if(r > mid)
		res = (res + query(rson, l, r, op)) % mod;
	return res;
}

void solve()
{
	while(cin >> n >> m, n || m)
	{
		memset(tre, 0, sizeof tre);
		build(1, 1, n);
		while(m--)
		{
			int opt, l, r, c;
			cin >> opt >> l >> r >> c;
			if(opt != 4)
				modify(1, l, r, c, opt);
			else
				cout << query(1, l, r, c) << endl;
		}
	}
}

signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
	cout.tie(0);

	solve();
}
HDU - 4578 Transformation（线段树）
qq_38367681的博客
07-29 963
异常变态的正常线段树。给你三种操作，三种输出方式： 1.让l~r区间的所有值加c； 2.让l~r区间的所有值乘c； 3.让l~r区间的所有值变成c； 4.让l~r区间的所有值都先求p（1~3）次方，然后求和输出。 别人都是一看题懵逼好简单操作好复杂，我就比较优秀，一看题就懵逼感觉很难不知道怎么做，我对不起这几天努力学的线段树，对不起。其实我考虑到分三种lazy数组，三种ans数组（正常大...
HDU 4578 Transformation(线段树+做了4天的神题+详解)
HJY
07-29 1804
Yuanfang is puzzled with the question below: There are n integers, a 1, a 2, …, a n. The initial values of them are 0. There are four kinds of operations. Operation 1: Add c to each number between a x and a y inclusive. In other words, do transformation
hdu 4578 Transformation
08-13 3088
题意：给你一个数组，初始值为零，有四种操作 （1）"1 x y c",代表 把区间 [x,y] 上的值全部加c （2）"2 x y c",代表 把区间 [x,y] 上的值全部乘以c （3）"3 x y c" 代表 把区间 [x,y]上的值全部赋值为c （4）"4 x y p" 代表 求区间 [x,y] 上值的p次方和1 因为P只有1到3，(x+c)^2=(x^2)+(2*x*c+c^2)
HDU - 4578 Transformation
子灬丶逾
07-31 320
HDU - 4578 Transformation 题 意:给你n个数字，开始都是0，m次操作，1 x y p:区间[x,y]每个数都加上p。2 x y c :区间[x,y]全部都乘p,3 x y c.将区间[x,y]的值全部都设为c。4 x y p,查询[x,y]所有值的p次方和。 数据范围: 1&lt;=n,m&lt;=1e5 1&lt;=c&lt;=1e4 x,y&lt;=n ...
K - Transformation HDU - 4578(线段树）
日月
09-24 316
Yuanfang is puzzled with the question below: There are n integers, a 1, a 2, …, a n. The initial values of them are 0. There are four kinds of operations. Operation 1: Add c to each number between a x...
Transformation HDU - 4578
sunyutian1998的博客
05-21 342
点击打开链接 维护一次幂二次幂三次幂的三个区间和 再维护乘法加法赋值的三个lazy标记 几个幂次和之间是有公式的 如图 而lazy标记的使用也需要技巧 首先赋值的优先级最高 只要赋值操作 其他两种操作直接舍弃 而加法和乘法虽然优先级一样 但是乘法操作不止影响乘法lazy 也影响加法lazy 具体见代码   #include &lt;bits/stdc++.h&gt; using ...
Transformation HDU - 4578（线段树多种操作）
仰望蓝天的博客
05-28 272
三个数组分别是lazadd lazmul lazc 记录加数，乘数，和设定的数，lazc1 表示一次方之和lazc2 lazc3 以此类推，其中最要注意的就是乘操作和加操作顺序不同答案是不同的，所以假如设定乘法为先，那么下推函数就要把乘法标记下推放在加法前面，而且更新函数里面，如果在更新乘法的时候碰到此处标记有加法标记存在，先把加数乘了，在更新子树，就可以保证既是顺序不一样答案是一样的，就...
HDU-4578 线段树 懒惰标记的下推顺序（好题）
安得广厦千万间的博客
05-29 1197
链接 点击打开链接Yuanfang is puzzled with the question below: There are n integers, a1, a2, …, an. The initial values of them are 0. There are four kinds of operations.Operation 1: Add c to each number betwee...
HDU4578-Transformation-多种区间修改、查询的线段树
最新发布
2301_79917474的博客
08-19 252
二百行动漫码量，站内有很多大佬讲过了。
kuangbin线段树专题
Fau的博客
11-24 5042
写在前面的话 博主也是个新手, 最近正在写kuangbin的线段树专题, 感觉整体线段树专题的难度也是从易到难的. 但是的确在做题过程中遇到了 许多困难, 也学到了很多东西, 希望这些能帮到后来者. 当然如果您有不同的见解, 或者发现了代码中的错误, 也希望您能提出我们一同探讨. 关于个人写代码习惯: ​ ①本人没有太多宏定义使用的习惯, 只有一个for循环的宏定义, 希望不会影响到大家的代码观感. ​ ②本人写代码有压行的习惯. 因为希望自己写出的代码尽可能短以及利于自己理解. 如果这篇博客帮助到了您,
线段树总结
热门推荐
11-27 2万+
之前做了些线段树相关的题目，开学一段时间后，想着把它整理下，完成了大牛NotOnlySuccess的博文“完全版线段树”里的大部分题目，其博文地址Here，然后也加入了自己做过的一些题目。整理时，更新了之前的代码风格，不过旧的代码仍然保留着。       同样分成四类，不好归到前四类的都分到了其他。树状数组能做，线段树都能做（如果是内存限制例外），所以也有些树状数组的题目，会标示出来，并且放到其
HDU - 4578 -Transformation（线段树）
horihori_的博客
11-25 488
有地方写残了一直wa#include <iostream> #include <cstdio> #include <cstdlib> #include <cstring> #include <algorithm> #include <cmath> using namespace std; #define lson l,m,rt<<1 #define rson m+1,r,rt<<1|1 #defin
HDU - 4578
bjfu170203101的博客
09-02 401
加inline 快200ms 2000ms。 这一题 就是一个序列，4种操作，区间加，乘，赋值。 然后询问区间和，平方和，立方和。 更新了正解：。。花了6小时。 这种方法复杂度稳定nlogn。 直接把3种操作打3个标记，三个输出维护3种数组。 add,mul,ass 输出很简单。关键怎么维护。 先说更新标记。 来了一个3操作，覆盖。 既然要将x-y区间覆盖成p。那...
Transformation HDU - 4578 （线段树，审题很重要）
sgh666666的博客
05-29 536
Yuanfang is puzzled with the question below: There are n integers, a 1, a 2, …, a n. The initial values of them are 0. There are four kinds of operations. Operation 1: Add c to each number between a x...
【区间更新+多种操作】K - Transformation HDU - 4578
qq_41037114的博客
07-26 457
K - Transformation HDU - 4578 Yuanfang is puzzled with the question below:  There are n integers, a 1, a 2, …, a n. The initial values of them are 0. There are four kinds of operations.  Operation 1:...
hdu 4578 线段树(标记处理)
diaocuiguo2493的博客
04-16 131
Transformation Time Limit: 15000/8000 MS (Java/Others)Memory Limit: 65535/65536 K (Java/Others) Total Submission(s): 4095Accepted Submission(s): 1008 Problem Description Yu...
HDU 4578-Transformation（线段树）
梧桐下的四叶草
11-11 1120
J - Transformation Time Limit:8000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status Practice HDU 4578 Appoint description:  System Crawler  (2015-11-11) Desc
HDU 2000-2099系列题解深入剖析
由于给定的信息重复提及“HDU+2000-2099+解题报告”，但没有提供具体的解题内容，我将基于这个范围内的题目可能涉及的知识点进行概括。 杭电在线评测系统（HDU）是一个在线的编程竞赛和练习平台，题目编号通常按照...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值