CSP202012-5 星际旅行 满分详解

最新推荐文章于 2023-08-05 20:38:30 发布
最新推荐文章于 2023-08-05 20:38:30 发布
阅读量3.3k 收藏 38
点赞数 15
分类专栏： 练习题目 文章标签： 算法 数据结构 csp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43381135/article/details/114678301
版权

CSP202012-5 星际旅行 满分详解

题目

题目可以在CSP官网中查看到哟！

结果

运行结果
注意：小编的代码要在CPP11标准 下提交才能满分通过哟！

算法分析

小编在读这道题题目的时候，感受到了题目的背景很花里胡哨，但是将这花里胡哨的背景撕去，看到本题题目的本质后，就能发现这道题用线段树就可以解决，在本题的题解中，小编使用的就是线段树，同时也进行了Lazy标记来进一步提高效率。

线段树是一个对区间修改、区间查询十分高效的一个算法，本题很显然就是对区间进行修改以及查询，用线段树算法是最好的办法啦。如果读者对最基本的线段树不是很了解，读者可以在CSDN搜索介绍线段树算法的博客或者在哔哩哔哩上面搜索介绍线段树的视频，耐心地看完，就可以对基本的线段树有了进一步地了解啦。

当然啦，线段树也是有优化的，利用Lazy标记可以提升线段树的效率，Lazy标记线段树的大致思想就是：修改区间的时候，在这个区间所有的终止节点上打上一个标记，代表这个点要进行什么样的修改；而等到区间查询的时候，如果访问到某个有标记的点，但又不能使用该点的值的时候，就把标记下传，继续线段树流程即可。在这里小编推荐一个博客可以很直观地了解线段树Lazy标记（这篇博客博主画了一个很直观的树结构来介绍Lazy标记的意义）。

接下来，小编将结合代码详细的介绍小编实现代码的过程。

详细代码讲解

1、输入并根据操作种类调用方法

首先输入n和m，n代表动力装置的数量，m代表操作的数量。根据题目，操作一共有四种分别为：动力增加、动力强化、动力转化和动力查询。题目里面说最开始n个动力装置的动力均为0，所以本题的线段树初始都是0，不用利用build来初始化线段树啦。动力增加与动力强化都是对区间进行修改，只是修改的方式不太一样，动力增加主要对区间进行加法，动力强化主要是对区间进行乘法，小编在主函数里面分别调用add()函数以及mul()函数来模拟动力增加与动力强化。动力转化也是属于区间修改的，小编在主函数里面调用rot()函数来模拟动力转化。最后就是动力查询了，这个是属于区间查询范围的，小编在主函数里面调用query()函数来模拟动力查询。具体代码如下：

int main()
{
	LL i, j;
	//输入n，m
	cin >> n >> m;
	LL start = 1, end = n, root;
	root = ++cnt;
	for (i = 1; i <= m; i++)
	{
		LL type;
		cin >> type;
		LL l, r;
		cin >> l >> r;
		//动力增加
		if (type == 1)
		{
			LL a, b, c;
			cin >> a >> b >> c;
			add(root, start, end, l, r, a, b, c);
		}
		//动力强化
		else if (type == 2)
		{
			LL k;
			cin >> k;
			mul(root, start, end, l, r, k);
		}
		//动力转化
		else if (type == 3)
		{
			rot(root, start, end, l, r);
		}
		//动力查询
		else if (type == 4)
		{
			LL f = 0, d = 0, e = 0;
			query(root, start, end, l, r, f, d, e);
			cout << ((f % MOD) * (f % MOD) % MOD + (d % MOD) * (d % MOD) % MOD + (e % MOD) * (e % MOD) % MOD) % MOD << endl;
		}
	}
	return 0;
}
2、交换函数

在实现动力转化期间，会涉及到数值的转化，因此，小编将此过程用一个函数来实现，方便后面的代码直接调用，具体的代码如下：

void swp(LL& a, LL& b)
{
	LL temp;
	temp = a;
	a = b;
	b = temp;
}
3、下传操作

带有Lazy标记的线段树在进行区间修改、区间查询的时候，是要进行下传操作的，小编通过调用pushdown()函数来实现这一过程。假设当前线段树操作运行到第p个节点，此时首先先要根据该点的Lazy标记进行相应的更新（一共是5个Lazy标记，分别是x坐标、y坐标、z坐标的增加量的lazy、乘法的Lazy以及转化的Lazy），根据这五个Lazy标记的含义，还是可以很清晰的将其更新到sumx、sumy、sumz数组中的；接下来，将父节点p上面的Lazy标记分别下传到其左右两子节点的Lazy上，同时将p节点自身的Lazy标记清空，具体的代码如下：

void pushdown(LL p, LL start, LL end)
{
	if (start == end)
	{
		lazyx[p] = lazyy[p] = lazyz[p] = lazymul[p] = lazyro[p] = 0;
		return;
	}
	LL& lchild = lson[p];
	LL& rchild = rson[p];
	if (!lchild) lchild = ++cnt;
	if (!rchild) rchild = ++cnt;
	LL mid = (start + end) >> 1;
	if (!lazymul[p]) lazymul[p] = 1;
	sumx[lchild] = (sumx[lchild] * (lazymul[p] % MOD) % MOD + ((mid - start + 1) % MOD) * (lazyx[p] % MOD) % MOD) % MOD;
	sumy[lchild] = (sumy[lchild] * (lazymul[p] % MOD) % MOD + ((mid - start + 1) % MOD) * (lazyy[p] % MOD) % MOD) % MOD;
	sumz[lchild] = (sumz[lchild] * (lazymul[p] % MOD) % MOD + ((mid - start + 1) % MOD) * (lazyz[p] % MOD) % MOD) % MOD;
	sumx[rchild] = (sumx[rchild] * (lazymul[p] % MOD) % MOD + ((end - mid) % MOD) * (lazyx[p] % MOD) % MOD) % MOD;
	sumy[rchild] = (sumy[rchild] * (lazymul[p] % MOD) % MOD + ((end - mid) % MOD) * (lazyy[p] % MOD) % MOD) % MOD;
	sumz[rchild] = (sumz[rchild] * (lazymul[p] % MOD) % MOD + ((end - mid) % MOD) * (lazyz[p] % MOD) % MOD) % MOD;
	for (LL i = 0; i < lazyro[p]; i++)
	{
		swp(sumx[lchild], sumy[lchild]);
		swp(sumy[lchild], sumz[lchild]);
		swp(sumx[rchild], sumy[rchild]);
		swp(sumy[rchild], sumz[rchild]);
	}
	LL u, v, w;
	u = lazyx[p];
	v = lazyy[p];
	w = lazyz[p];
	for (LL i = 0; i < lazyro[lchild]; i++)
	{
		swp(v, w);
		swp(u, v);
	}
	lazyx[lchild] = (lazyx[lchild] * (lazymul[p] % MOD) % MOD + u % MOD) % MOD;
	lazyy[lchild] = (lazyy[lchild] * (lazymul[p] % MOD) % MOD + v % MOD) % MOD;
	lazyz[lchild] = (lazyz[lchild] * (lazymul[p] % MOD) % MOD + w % MOD) % MOD;

	u = lazyx[p];
	v = lazyy[p];
	w = lazyz[p];
	for (LL i = 0; i < lazyro[rchild]; i++)
	{
		swp(v, w);
		swp(u, v);
	}
	lazyx[rchild] = (lazyx[rchild] * (lazymul[p] % MOD) % MOD + u % MOD) % MOD;
	lazyy[rchild] = (lazyy[rchild] * (lazymul[p] % MOD) % MOD + v % MOD) % MOD;
	lazyz[rchild] = (lazyz[rchild] * (lazymul[p] % MOD) % MOD + w % MOD) % MOD;

	if (lazymul[p] != 1)
	{
		if (!lazymul[lchild]) lazymul[lchild] = 1;
		lazymul[lchild] = (lazymul[lchild] * (lazymul[p] % MOD)) % MOD;
		if (!lazymul[rchild]) lazymul[rchild] = 1;
		lazymul[rchild] = (lazymul[rchild] * (lazymul[p] % MOD)) % MOD;
	}
	lazyro[lchild] = (lazyro[lchild] + lazyro[p]) % 3;
	lazyro[rchild] = (lazyro[rchild] + lazyro[p]) % 3;
	lazyx[p] = 0;
	lazyy[p] = 0;
	lazyz[p] = 0;
	lazymul[p] = 0;
	lazyro[p] = 0;
}
4、add()函数模拟动力增加

首先根据start、end、l、r四者直接的关系进行不同的操作（这个是线段树的基本知识）：如果当前节点的范围完全不在动力增加的范围，则直接返回即可；如果当前如果当前节点的范围完全在动力增加的范围，则直接对该节点的sumx、sumy、sumz数组以及lazy数组进行更新；其余的情况就是当前节点与动力增加的范围有交集，此时如果该节点有Lazy标记，则要进行下传操作，直接调用pushdown()函数即可。之后将当前节点进行二分，根据与l，r动力增加范围之间的关系对子节点进行add()操作即可；最后根据左右子节点的结果进行对父节点p的更新即可。具体代码如下：

void add(LL &p, LL start, LL end, LL l, LL r, LL a, LL b, LL c)
{
	if (!p) p = ++cnt;
	if (end <l || start>r) return;
	if (start >= l && end <= r)
	{
		sumx[p] = (sumx[p] + (end - start + 1) % MOD * (a % MOD) % MOD) % MOD;
		sumy[p] = (sumy[p] + (end - start + 1) % MOD * (b % MOD) % MOD) % MOD;
		sumz[p] = (sumz[p] + (end - start + 1) % MOD * (c % MOD) % MOD) % MOD;
		for (LL i = 0; i < lazyro[p]; i++)
		{
			swp(b, c);
			swp(a, b);
		}
		lazyx[p] = (lazyx[p] + a % MOD) % MOD;
		lazyy[p] = (lazyy[p] + b % MOD) % MOD;
		lazyz[p] = (lazyz[p] + c % MOD) % MOD;
		return;
	}
	if (lazyx[p] || lazyy[p] || lazyz[p] || lazymul[p] || lazyro[p]) pushdown(p, start, end);
	LL mid = (start + end)  >> 1;
	if (mid >= l)
		add(lson[p], start, mid, l, r, a, b, c);
	if (mid < r)
		add(rson[p], mid + 1, end, l, r, a, b, c);
	sumx[p] = (sumx[lson[p]] % MOD + sumx[rson[p] % MOD]) % MOD;
	sumy[p] = (sumy[lson[p]] % MOD + sumy[rson[p] % MOD]) % MOD;
	sumz[p] = (sumz[lson[p]] % MOD + sumz[rson[p] % MOD]) % MOD;
}
5、mul()函数模拟动力强化

与上一部分同属区间修改范畴，基本差不多。首先根据start、end、l、r四者直接的关系进行不同的操作（这个是线段树的基本知识）：如果当前节点的范围完全不在动力强化的范围，则直接返回即可；如果当前如果当前节点的范围完全在动力强化的范围，则直接对该节点的sumx、sumy、sumz数组以及lazy数组进行更新；其余的情况就是当前节点与动力强化的范围有交集，此时如果该节点有Lazy标记，则要进行下传操作，直接调用pushdown()函数即可。之后将当前节点进行二分，根据与l，r动力强化范围之间的关系对子节点进行mul()操作即可；最后根据左右子节点的结果进行对父节点p的更新即可。具体代码如下：

void mul(LL &p, LL start, LL end, LL l, LL r, LL k)
{
	if (!p) p = ++cnt;
	if (end <l || start>r)  return;
	if (start >= l && end <= r)
	{
		if (!lazymul[p]) lazymul[p] = 1;
		sumx[p] = (sumx[p] * (k % MOD)) % MOD;
		sumy[p] = (sumy[p] * (k % MOD)) % MOD;
		sumz[p] = (sumz[p] * (k % MOD)) % MOD;
		lazyx[p] = (lazyx[p] * (k % MOD)) % MOD;
		lazyy[p] = (lazyy[p] * (k % MOD)) % MOD;
		lazyz[p] = (lazyz[p] * (k % MOD)) % MOD;
		lazymul[p] = (lazymul[p] * (k % MOD)) % MOD;
		return;
	}
	if (lazyx[p] || lazyy[p] || lazyz[p] || lazymul[p] || lazyro[p])
		pushdown(p, start, end);
	LL mid = (start + end) >> 1;
	if (mid >= l)
		mul(lson[p], start, mid, l, r, k);
	if (mid < r)
		mul(rson[p], mid + 1, end, l, r, k);
	sumx[p] = (sumx[lson[p]] % MOD + sumx[rson[p] % MOD]) % MOD;
	sumy[p] = (sumy[lson[p]] % MOD + sumy[rson[p] % MOD]) % MOD;
	sumz[p] = (sumz[lson[p]] % MOD + sumz[rson[p] % MOD]) % MOD;
}
6、rot()函数模拟动力转化

与上一部分同属区间修改范畴，基本差不多。首先根据start、end、l、r四者直接的关系进行不同的操作（这个是线段树的基本知识）：如果当前节点的范围完全不在动力转化的范围，则直接返回即可；如果当前如果当前节点的范围完全在动力转化的范围，则直接对该节点的sumx、sumy、sumz数组以及lazy数组进行更新；其余的情况就是当前节点与动力转化的范围有交集，此时如果该节点有Lazy标记，则要进行下传操作，直接调用pushdown()函数即可。之后将当前节点进行二分，根据与l，r动力转化范围之间的关系对子节点进行mul()操作即可；最后根据左右子节点的结果进行对父节点p的更新即可。具体代码如下：

void rot(LL &p, LL start, LL end, LL l, LL r)
{
	if (!p) p = ++cnt;
	if (end<l || start>r) return;
	if (start >= l && end <= r)
	{
		swp(sumx[p], sumy[p]);
		swp(sumy[p], sumz[p]);
		lazyro[p] ++;
		lazyro[p] = lazyro[p] % 3;
		return;
	}
	if (lazyx[p] || lazyy[p] || lazyz[p] || lazymul[p] || lazyro) pushdown(p, start, end);
	LL mid = (start + end) >> 1;
	if (mid >= l)
		rot(lson[p], start, mid, l, r);
	if (mid < r)
		rot(rson[p], mid + 1, end, l, r);
	sumx[p] = (sumx[lson[p]] % MOD + sumx[rson[p] % MOD]) % MOD;
	sumy[p] = (sumy[lson[p]] % MOD + sumy[rson[p] % MOD]) % MOD;
	sumz[p] = (sumz[lson[p]] % MOD + sumz[rson[p] % MOD]) % MOD;
}
7、query()函数模拟动力查询

这一部分的操作属于区间查询的范畴。首先根据start、end、l、r四者直接的关系进行不同的操作（这个是线段树的基本知识）：如果当前节点的范围完全不在动力转化的范围，则直接返回即可；如果当前如果当前节点的范围完全在动力转化的范围，则直接将该节点的sumx、sumy、sumz数值更新到a，b，c中；其余的情况就是当前节点与动力转化的范围有交集，此时如果该节点有Lazy标记，则要进行下传操作，直接调用pushdown()函数即可。之后将当前节点进行二分，根据与l，r动力转化范围之间的关系对子节点进行query()操作即可。具体代码如下：

void query(LL &p, LL start, LL end, LL l, LL r, LL &a, LL &b, LL &c)
{
	if (!p) p = ++cnt;
	if (end<l || start>r) return;
	if (start >= l && end <= r)
	{
		a = (a + sumx[p] % MOD) % MOD;
		b = (b + sumy[p] % MOD) % MOD;
		c = (c + sumz[p] % MOD) % MOD;
		return;
	}
	if (lazyx[p] || lazyy[p] || lazyz[p] || lazymul[p] || lazyro[p]) pushdown(p, start, end);
	LL mid = (start + end) >> 1;
	if (mid >= l)
		query(lson[p], start, mid, l, r, a, b, c);
	if (mid < r)
		query(rson[p], mid + 1, end, l, r, a, b, c);
}

完整满分代码

#include<iostream>
#include<cstdio>
#define MOD 1000000007
#define maxn 10000000
using namespace std;
using LL = long long int;
LL n, m;
LL cnt = 0;
LL sumx[maxn], sumy[maxn], sumz[maxn];
LL lson[maxn], rson[maxn];
LL lazyx[maxn], lazyy[maxn], lazyz[maxn], lazymul[maxn], lazyro[maxn];
void swp(LL& a, LL& b)
{
	LL temp;
	temp = a;
	a = b;
	b = temp;
}
void pushdown(LL p, LL start, LL end)
{
	if (start == end)
	{
		lazyx[p] = lazyy[p] = lazyz[p] = lazymul[p] = lazyro[p] = 0;
		return;
	}
	LL& lchild = lson[p];
	LL& rchild = rson[p];
	if (!lchild) lchild = ++cnt;
	if (!rchild) rchild = ++cnt;
	LL mid = (start + end) >> 1;
	if (!lazymul[p]) lazymul[p] = 1;
	sumx[lchild] = (sumx[lchild] * (lazymul[p] % MOD) % MOD + ((mid - start + 1) % MOD) * (lazyx[p] % MOD) % MOD) % MOD;
	sumy[lchild] = (sumy[lchild] * (lazymul[p] % MOD) % MOD + ((mid - start + 1) % MOD) * (lazyy[p] % MOD) % MOD) % MOD;
	sumz[lchild] = (sumz[lchild] * (lazymul[p] % MOD) % MOD + ((mid - start + 1) % MOD) * (lazyz[p] % MOD) % MOD) % MOD;
	sumx[rchild] = (sumx[rchild] * (lazymul[p] % MOD) % MOD + ((end - mid) % MOD) * (lazyx[p] % MOD) % MOD) % MOD;
	sumy[rchild] = (sumy[rchild] * (lazymul[p] % MOD) % MOD + ((end - mid) % MOD) * (lazyy[p] % MOD) % MOD) % MOD;
	sumz[rchild] = (sumz[rchild] * (lazymul[p] % MOD) % MOD + ((end - mid) % MOD) * (lazyz[p] % MOD) % MOD) % MOD;
	for (LL i = 0; i < lazyro[p]; i++)
	{
		swp(sumx[lchild], sumy[lchild]);
		swp(sumy[lchild], sumz[lchild]);
		swp(sumx[rchild], sumy[rchild]);
		swp(sumy[rchild], sumz[rchild]);
	}
	LL u, v, w;
	u = lazyx[p];
	v = lazyy[p];
	w = lazyz[p];
	for (LL i = 0; i < lazyro[lchild]; i++)
	{
		swp(v, w);
		swp(u, v);
	}
	lazyx[lchild] = (lazyx[lchild] * (lazymul[p] % MOD) % MOD + u % MOD) % MOD;
	lazyy[lchild] = (lazyy[lchild] * (lazymul[p] % MOD) % MOD + v % MOD) % MOD;
	lazyz[lchild] = (lazyz[lchild] * (lazymul[p] % MOD) % MOD + w % MOD) % MOD;

	u = lazyx[p];
	v = lazyy[p];
	w = lazyz[p];
	for (LL i = 0; i < lazyro[rchild]; i++)
	{
		swp(v, w);
		swp(u, v);
	}
	lazyx[rchild] = (lazyx[rchild] * (lazymul[p] % MOD) % MOD + u % MOD) % MOD;
	lazyy[rchild] = (lazyy[rchild] * (lazymul[p] % MOD) % MOD + v % MOD) % MOD;
	lazyz[rchild] = (lazyz[rchild] * (lazymul[p] % MOD) % MOD + w % MOD) % MOD;

	if (lazymul[p] != 1)
	{
		if (!lazymul[lchild]) lazymul[lchild] = 1;
		lazymul[lchild] = (lazymul[lchild] * (lazymul[p] % MOD)) % MOD;
		if (!lazymul[rchild]) lazymul[rchild] = 1;
		lazymul[rchild] = (lazymul[rchild] * (lazymul[p] % MOD)) % MOD;
	}
	lazyro[lchild] = (lazyro[lchild] + lazyro[p]) % 3;
	lazyro[rchild] = (lazyro[rchild] + lazyro[p]) % 3;
	lazyx[p] = 0;
	lazyy[p] = 0;
	lazyz[p] = 0;
	lazymul[p] = 0;
	lazyro[p] = 0;
}
void add(LL &p, LL start, LL end, LL l, LL r, LL a, LL b, LL c)
{
	if (!p) p = ++cnt;
	if (end <l || start>r) return;
	if (start >= l && end <= r)
	{
		sumx[p] = (sumx[p] + (end - start + 1) % MOD * (a % MOD) % MOD) % MOD;
		sumy[p] = (sumy[p] + (end - start + 1) % MOD * (b % MOD) % MOD) % MOD;
		sumz[p] = (sumz[p] + (end - start + 1) % MOD * (c % MOD) % MOD) % MOD;
		for (LL i = 0; i < lazyro[p]; i++)
		{
			swp(b, c);
			swp(a, b);
		}
		lazyx[p] = (lazyx[p] + a % MOD) % MOD;
		lazyy[p] = (lazyy[p] + b % MOD) % MOD;
		lazyz[p] = (lazyz[p] + c % MOD) % MOD;
		return;
	}
	if (lazyx[p] || lazyy[p] || lazyz[p] || lazymul[p] || lazyro[p]) pushdown(p, start, end);
	LL mid = (start + end)  >> 1;
	if (mid >= l)
		add(lson[p], start, mid, l, r, a, b, c);
	if (mid < r)
		add(rson[p], mid + 1, end, l, r, a, b, c);
	sumx[p] = (sumx[lson[p]] % MOD + sumx[rson[p] % MOD]) % MOD;
	sumy[p] = (sumy[lson[p]] % MOD + sumy[rson[p] % MOD]) % MOD;
	sumz[p] = (sumz[lson[p]] % MOD + sumz[rson[p] % MOD]) % MOD;
}
void mul(LL &p, LL start, LL end, LL l, LL r, LL k)
{
	if (!p) p = ++cnt;
	if (end <l || start>r)  return;
	if (start >= l && end <= r)
	{
		if (!lazymul[p]) lazymul[p] = 1;
		sumx[p] = (sumx[p] * (k % MOD)) % MOD;
		sumy[p] = (sumy[p] * (k % MOD)) % MOD;
		sumz[p] = (sumz[p] * (k % MOD)) % MOD;
		lazyx[p] = (lazyx[p] * (k % MOD)) % MOD;
		lazyy[p] = (lazyy[p] * (k % MOD)) % MOD;
		lazyz[p] = (lazyz[p] * (k % MOD)) % MOD;
		lazymul[p] = (lazymul[p] * (k % MOD)) % MOD;
		return;
	}
	if (lazyx[p] || lazyy[p] || lazyz[p] || lazymul[p] || lazyro[p])
		pushdown(p, start, end);
	LL mid = (start + end) >> 1;
	if (mid >= l)
		mul(lson[p], start, mid, l, r, k);
	if (mid < r)
		mul(rson[p], mid + 1, end, l, r, k);
	sumx[p] = (sumx[lson[p]] % MOD + sumx[rson[p] % MOD]) % MOD;
	sumy[p] = (sumy[lson[p]] % MOD + sumy[rson[p] % MOD]) % MOD;
	sumz[p] = (sumz[lson[p]] % MOD + sumz[rson[p] % MOD]) % MOD;
}
void rot(LL &p, LL start, LL end, LL l, LL r)
{
	if (!p) p = ++cnt;
	if (end<l || start>r) return;
	if (start >= l && end <= r)
	{
		swp(sumx[p], sumy[p]);
		swp(sumy[p], sumz[p]);
		lazyro[p] ++;
		lazyro[p] = lazyro[p] % 3;
		return;
	}
	if (lazyx[p] || lazyy[p] || lazyz[p] || lazymul[p] || lazyro) pushdown(p, start, end);
	LL mid = (start + end) >> 1;
	if (mid >= l)
		rot(lson[p], start, mid, l, r);
	if (mid < r)
		rot(rson[p], mid + 1, end, l, r);
	sumx[p] = (sumx[lson[p]] % MOD + sumx[rson[p] % MOD]) % MOD;
	sumy[p] = (sumy[lson[p]] % MOD + sumy[rson[p] % MOD]) % MOD;
	sumz[p] = (sumz[lson[p]] % MOD + sumz[rson[p] % MOD]) % MOD;
}
void query(LL &p, LL start, LL end, LL l, LL r, LL &a, LL &b, LL &c)
{
	if (!p) p = ++cnt;
	if (end<l || start>r) return;
	if (start >= l && end <= r)
	{
		a = (a + sumx[p] % MOD) % MOD;
		b = (b + sumy[p] % MOD) % MOD;
		c = (c + sumz[p] % MOD) % MOD;
		return;
	}
	if (lazyx[p] || lazyy[p] || lazyz[p] || lazymul[p] || lazyro[p]) pushdown(p, start, end);
	LL mid = (start + end) >> 1;
	if (mid >= l)
		query(lson[p], start, mid, l, r, a, b, c);
	if (mid < r)
		query(rson[p], mid + 1, end, l, r, a, b, c);
}
int main()
{
	LL i, j;
	//输入n，m
	cin >> n >> m;
	LL start = 1, end = n, root;
	root = ++cnt;
	for (i = 1; i <= m; i++)
	{
		LL type;
		cin >> type;
		LL l, r;
		cin >> l >> r;
		//动力增加
		if (type == 1)
		{
			LL a, b, c;
			cin >> a >> b >> c;
			add(root, start, end, l, r, a, b, c);
		}
		//动力强化
		else if (type == 2)
		{
			LL k;
			cin >> k;
			mul(root, start, end, l, r, k);
		}
		//动力转化
		else if (type == 3)
		{
			rot(root, start, end, l, r);
		}
		//动力查询
		else if (type == 4)
		{
			LL f = 0, d = 0, e = 0;
			query(root, start, end, l, r, f, d, e);
			cout << ((f % MOD) * (f % MOD) % MOD + (d % MOD) * (d % MOD) % MOD + (e % MOD) * (e % MOD) % MOD) % MOD << endl;
		}
	}
	return 0;
}
人间之清欢
关注
  • 15
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
CSP2020-12-5星际旅行(未优化线段树60，优化后100，暴力可拿80！)
all23333333的博客
04-15 751
题目描述： 乔帝要规划一次星际旅行，星际空间可以视为一个 3 维坐标系，乔帝有 n(n≤1,000,000,000) 个动力装置排成一行(下标从 1 到 n )。 第 i 个动力装置可以让他的飞船 3 个维度的坐标分别增加 xi,yi,zi 。一开始这些动力装置的所有参数都是 0 。 在规划过程中，乔帝可能会对动力装置进行调整，也可能会对一些动力装置的动力进行评估。 具体来说，乔帝会进行 m(m≤40000) 次操作，每次操作可能是以下四种操作之一： 动力增加：指定一个区间 [L,R] 和三个参数 a,b,
CCF202009-4 星际旅行（100分题解链接）
海岛Blog
08-25 2101
试题编号： 202009-4 试题名称： 星际旅行 时间限制： 1.0s 内存限制： 256.0MB 问题描述： 问题描述 在一个n维欧几里得空间的宇宙中，小 A 打算完成一次星际旅行。 利用n维直角坐标系，宇宙中每个点的位置都可以用n维坐标来表示。其中，在宇宙中心的O点（未必是坐标系原点）处，有一个半径为r的超球体黑洞，任何物体若落入黑洞内部（不包括其表面）则无法逃脱。 小 A 选定了m个不在黑洞内部的点P1,P2,…,Pm，作为他星际旅行的目标。不会有两个点处于同一位置。 为了提前做好旅行规划，小 A
CSP 202009-4 星际旅行
想买很多漂亮衣服但是买不起的博客
02-26 650
2022.2.26 学习 CSP 202009-4 星际旅行 参考博客：第二十次csp认证 第四题 星际旅行题解（大佬啊） 心得： 仔细分析题目，寻找解题方式，然后再代码，不要一头雾水的一遍写代码一遍瞎想。。 #include <bits/stdc++.h> using namespace std; int n,m,r; int o[101]; int s[2001][101];//m个点 double d[2001];//m个点到o点的距离 double rd[2001];//m个点与圆做切线
CCF- CSP 202012-5星际旅行 80分骗分题解
只须一笑不须愁X的博客
09-16 929
【代码】CCF- CSP 202012-5星际旅行 80分骗分题解。
CSP计算机软件能力认证 2022年12月 题解
qq_18626053的博客
03-14 518
树上启发式合并，用 multiset 维护当前的值的集合，用 val 记录当前的答案，每进来一个值现在 multiset 里面找前驱和后继，因为新进来的值可能对这俩造成影响，然后再把离自己近的加到答案里面。先把树建出来，dfs下去的时候记一下最早的时间，回溯的时候记录最晚时间。看起来像线段树优化建图，还没写，写了再更新。
信息学奥赛入门组复赛CSP 2019-J2题目详解.pdf
07-13
本篇内容主要涵盖了2019年CCF非专业级软件能力认证CSP-J/S的第二轮入门组CSP 2019-J2的三道题目，包括T1数字游戏、T2交通换乘和T3纪念品的解题策略和代码实现。 **T1 数字游戏** 这是一个关于字符串处理的问题。...
信息学奥赛入门组复赛CSP 2021-J2题目详解.pdf
07-13
【信息学奥赛入门组复赛CSP 2021-J2题目详解】涉及到的是信息学竞赛中的算法问题，主要包括两道题目：分糖果（candy）和插入排序（sort）。以下是这两道题目的详细解析及解决方案： **第一题 分糖果（candy）** ...
信息学奥赛入门组复赛CSP 2020-J2题目详解.pdf
07-13
本资料主要涉及的信息学竞赛是CCF非专业级软件能力认证（CSP-J/S），特别是2020年第二轮认证的入门组（CSP 2020-J2）。这个竞赛旨在培养青少年的计算机科学能力，通过解决一系列编程问题来评估他们的逻辑思维和技术...
2022 CSP-J1 CSP-S1 初赛 资料集（2022.07.08).pdf
07-08
知识点 5：CSP-J1 CSP-S1 初赛复习方法 本资源提供了 CSP-J1 CSP-S1 初赛的复习方法，旨在帮助选手更好地备战考试。 知识点 6：CSP-J1 CSP-S1 初赛知识汇总 本资源提供了 CSP-J1 CSP-S1 初赛的知识汇总，旨在帮助...
CSP-J模拟赛：真题复现
08-02
【CSP-J模拟赛：真题复现】 CSP-J（中国计算机学会青少年软件编程能力认证初级）是一项针对青少年的编程能力评估考试，旨在检验考生的编程基础和逻辑思维能力。本模拟赛名为FCC - PCS-J，旨在与CSP-J保持相似的难度...
ccf csp 202212星际网络 4分（未优化）
weixin_44124824的博客
02-26 918
星际网络求解的抛砖引玉
CCF-CSP认证历年真题解
热门推荐
海岛Blog
01-28 32万+
CSP认证考什么怎么考？ CCF计算机职业资格认证的每一道试题都十分经典，覆盖现实世界中方方面面的问题。这个历年试题解主要使用C/C++语言编写，将逐步增加Python和Java的解题程序。程序中附有注释，力求解题思路清晰简洁，值得珍藏与模仿。 逐题改写过程中，富文本编辑器写的博客将全部用Markdown编辑器改写。改写的第一题，都增加了Python和Java的解题程序。 2021.04第22次： CCF202104-1 灰度直方图（100分）【计数】 CCF202104-2 邻域均值（100分.
星际网络Ⅱ做题笔记
最新发布
m0_66822426的博客
08-05 130
星际网络Ⅱ题目详细注释和做题笔记
第 20 次 CSP认证 202009-4 星际旅行
Running Snail
09-14 2594
样例一输入： 2 3 2 3 1 5 1 1 3 3 -2 样例一输入： 3 8 1 0 0 0 0 0 1 0 1 0 1 0 0 1 1 1 -1 -1 0 -1 0 -1 0 -1 -1 -1 -1 -1
CCF CSP认证 202009-4 星际旅行
qq_43385440的博客
11-25 1141
CCF CSP认证 202009-4 星际旅行，题面，问题分析，c++代码。
CSP认证 202009-4 星际旅行 Python 题解 思路清晰
qq_43613342的博客
11-16 774
CSP认证 202009-4 星际旅行 Python 题解 思路清晰 本题找对数学关系就很容易求了，分三种情况： P1,P2的连线 与圆心的距离 >=r,即这条直线在园外，P1和P2的最短距离就是欧式距离P1P2的连线。 P1,P2的连线 与圆心的距离 <r,此时还要先判断这条线段是否在园外，判断条件为角OP1P2或者角OP2P1是否为钝角或直角，如果在园外那么也很简单，P1和P2的最短距离就是欧式距离P1P2的连线。 P1,P2的连线穿过园，那么它们之间的距离分三段计算，具体看代码。 im
CCF历年真题整理【已更新至202104】
WINGREZ‘S BLOG
12-20 12万+
说明：本文持续更新，若长时间未更新，请评论催催我。 以下题目均来自cspro.org，点击进入测试页面，侵删歉。 部分题目我已经解决，并给出参考代码。然而有些我还没有尝试解决，但先把题目贴给大家，大家可以自行去官网练习。 如果对我的解法有疑问，可以联系我一起交流学习。CCF交流学习QQ群：696037138 需要了解CCF的常见问题，请看这篇博客：CCF考前必看（最后更新时间：2019.10.03...
星际旅行（思维很好的欧拉路）
Bluelanzhan的博客
11-07 413
把每条边拆成两条。欧拉（回）路，只有0或2两个奇点。因为2条边经过一次，m-2条边经过两次，可以考虑删除两条边，使剩下的图有0或2两个奇点。所以这两条边要么是任意两个自环，要么是有一个公共端点的两条边，要么是一个自环和任意一条边。 我们要判断，整个图联不联通，因为要经过m条边。然而我们判断所有边联通的点联不联通，不是判断所有点联不联通。如下图，所有点不联通，但是能找到航线。 #inc...
acm-星际旅行
zzyy17的专栏
11-12 817
星际旅行 时间限制：20000 ms  |  内存限制：65535 KB 难度：5 描述 在半人马星系，有M*N个星球，它们排成了M行N列，每个星球与其上下左右的星球都有一条星际航道相连，每个星球从属于一个国家，同一个国家中的所有星球都可以通过使用星际之门相连在一起。 现在小渡想从坐标为(1,1)的星球（左上角）航行到坐标为(M,N)的星球，为了体验星际旅行的美妙感觉，他想使自己通
2023 SCP-S初赛CSP-JS C++模拟试题详解：非专业认证关键点
CCF CSP非专业级别的能力认证，即CCF CSP-JS，是一项针对软件开发者的入门和提高级别的考试，由CCF（中国计算机学会）组织。该认证分为CSP-J（初级）和CSP-S（高级）两个层次，主要考察算法和编程技能。竞赛分为两轮...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值