线段树学习、

最新推荐文章于 2022-05-02 22:22:05 发布
最新推荐文章于 2022-05-02 22:22:05 发布
阅读量183 收藏
点赞数
分类专栏： 算法學習
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sasuke__/article/details/76888323
版权

这篇博客比较便于理解：Gakki

联系衔接：你想变强吗

单点更新区间加减懒惰标记这些都是基础、

POJ 2886

题意：给出n个人的名字和他手中的数字ai，n个人围成一圈，给出一个数字k，代表k这个人第一个出去，如果k这个人的数字是正数，代表顺时针走ak次的人出去，负数就逆时针，现在要求一个F(p)的最大值，F(p)代表p的因子个数，比如6 有因子个数 1 2 3 6所以F(6) = 4，令第i个人出去的值是F(i)，现在要求F(i)的最大值，最大值相同输出最先出去的那个人

思路：首先我们可以用素数筛求出每个数的因子个数，那么我们就可以知道1到n中那个数的因子最多了，使用线段树维护这个区间还有多少人，假设第i轮是第p个出去，那么在区间里找到第p个位置即可，mod实际上代表的是还剩下多少个人，由于数很大，要进行模运算，但原本的位置是1 ～ mod， mod对应的是0 ～ mod - 1，所以这里我们要转化一下，把1～n转化到0～mod - 1，然后再转化回1 ～ n

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 5e5 + 10;
const int INF = 1e9 + 10;
bool isprime[qq];
int prime[qq];
int n, m, top;
char name[qq][15];
int num[qq];
int tree[qq << 2];
int factor[qq], of[qq];
void Init() {
	top = 0;
	for(int i = 0; i < qq; ++i) {
		of[i] = i;
		factor[i] = 1;
	}
	for(int i = 2; i < qq; ++i) {
		if(!isprime[i]) {
			prime[++top] = i;
		}
		for(int j = 1; j <= top && i * prime[j] < qq; ++j) {
			isprime[i * prime[j]] = true;
			if(i % prime[j] == 0) {
				break;
			}
		}
	}
	for(int i = 1; i <= top; ++i) {
		for(int j = prime[i]; j < qq; j += prime[i]) {
			int cnt = 1;
			while(of[j] % prime[i] == 0) {
				of[j] /= prime[i];
				cnt++;
			}
			factor[j] *= cnt;
		}
	}
}
void PushUp(int rt) {
	tree[rt] = tree[rt << 1] + tree[rt << 1 | 1];
}
void BuildTree(int l, int r, int rt) {
	tree[rt] = (r - l + 1);
	if(l == r)	return;
	int m = (l + r) >> 1;
	BuildTree(l, m, rt << 1);
	BuildTree(m + 1, r, rt << 1 | 1);
}
int Change(int l, int r, int rt, int k) {
	tree[rt]--;
	if(l == r)	return l;
	int m = (l + r) >> 1;
	if(tree[rt << 1] >= k) {
		return Change(l, m, rt << 1, k);
	}
	return Change(m + 1, r, rt << 1 | 1, k - tree[rt << 1]);
}
map<int, bool> mp;

int main(){
	Init();
	int &mod = tree[1];
	while(scanf("%d%d", &n, &m) != EOF) {
		for(int i = 1; i <= n; ++i) {
			scanf("%s %d", name[i], num + i);
		}
		BuildTree(1, n, 1);
		int maxn = 0;
		for(int i = 1; i <= n; ++i) {
			maxn = max(maxn, factor[i]);
		}
		int cnt;
		for(int i = 1; i <= n; ++i) {
			if(maxn == factor[i]) {
				cnt = i;
				break;
			}
		}
		int pos = 0;
		num[pos] = 0;
		for(int i = 0; i < cnt; ++i) {
			if(num[pos] > 0) {
				m = ((m + num[pos] - 2) % mod + mod) % mod + 1;
			} else {
				m = ((m + num[pos] - 1) % mod + mod) % mod + 1;
			}
			pos = Change(1, n, 1, m);
		}
		printf("%s %d\n", name[pos], maxn);
	}
	return 0;
}



POJ 2528

题意：有一块广告版长度无限不考虑宽度，顺序给出n个广告牌，它的会贴在广告牌的[ai, bi]，顺序去贴广告牌，问最后能看到几个广告

思路：一个很简单的思路就是直接给区间[ai, bi]赋值标记数字，最后统计有多少不同的数字，但是范围太大了 达到了1e9，这样建树是不可的，但是注意n的范围很小，所以我们可以考虑把坐标给离散化，把出现的区间数字从小到大排序然后映射到区间较小的范围去，最后实现最开始的简单思路统计即可

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 1e4 + 10;
const int INF = 1e9 + 10;
int li[qq], ri[qq], num;
int x[qq << 3], col[qq << 4], ans;
bool hs[qq];
void Init() {
	mst(col, -1);
	mst(hs, false);
}
void PushDown(int rt) {
	if(col[rt] != -1) {
		col[rt << 1] = col[rt << 1 | 1] = col[rt];
		col[rt] = -1;
	}
}
int Search(int l, int r, int val) {
	while(l <= r) {
		int m = (l + r) >> 1;
		if(x[m] == val)	return m;
		else if(x[m] < val) l = m + 1;
		else	r = m - 1;
	}
	return 0;
}
void UpDate(int l, int r, int rt, int x, int y, int val) {
	if(x <= l && r <= y) {
		col[rt] = val;
		return;
	}
	PushDown(rt);
	int m = (l + r) >> 1;
	if(m >= x)	UpDate(l, m, rt << 1, x , y, val);
	if(m < y)	UpDate(m + 1, r, rt << 1 | 1, x, y, val);
}
void Query(int l, int r, int rt) {
	if(l == r) {
		if(col[rt] == -1)	return;
		if(!hs[col[rt]])	++ans;
		hs[col[rt]] = true;
		return;
	}
	PushDown(rt);
	int m = (l + r) >> 1;
	Query(l, m, rt << 1);
	Query(m + 1, r, rt << 1 | 1);
}

int main(){
	int t;
	scanf("%d", &t);
	while(t--) {
		Init();
		int n;	scanf("%d", &n);
		int m = 0;
		for(int i = 0; i < n; ++i) {
			scanf("%d%d", li + i, ri + i);
			x[++m] = li[i];
			x[++m] = ri[i];
		}
		sort(x + 1, x + 1 + m);
		int num = 1;
		for(int i = 2; i <= m; ++i) {
			if(x[i] != x[i - 1])	x[++num] = x[i];
		}
		for(int i = num; i > 1; --i) {
			if(x[i] - x[i - 1] > 1)	x[++num] = x[i - 1] + 1;
		}
		sort(x + 1, x + 1 + num);
		for(int i = 0; i < n; ++i) {
			int l = Search(1, num, li[i]);
			int r = Search(1, num, ri[i]);
			UpDate(1, num, 1, l, r, i + 1);
		}
		ans = 0;
		Query(1, num, 1);
		printf("%d\n", ans);
	}
	return 0;
}



POJ2777

区间覆盖操作

题意：给出L，颜色总数T以及O次操作，每次操作

C 1 1 2
P 1 2
第一种代表把区间1 1 内的点染成颜色2

第二种询问区间1 2内有多少种颜色

最初0 ～ L内的点都是颜色1

思路：线段树的区间覆盖问题，这题要好好体会一下，之后很多题都运用到了这种思想

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 100000 + 10;
const int INF = 1e9 + 10;
int color[qq << 2], lazy[qq << 2];
int n, T, Q;
void PushDown(int rt) {
	if(color[rt] != -1) {
		color[rt << 1] = color[rt << 1 | 1] = color[rt];
		color[rt] = -1;
	}
	/*if(lazy[rt] != -1) {
		lazy[rt << 1] = lazy[rt << 1 | 1] = lazy[rt];
		lazy[rt] = -1; 
	}*/
}
void Change(int l, int r, int rt, int x, int y, int val) {
	if(x <= l && r <= y) {
		color[rt] = val;
//		lazy[rt] = val;
		return;
	}
	PushDown(rt);
	int m = (l + r) >> 1;
	if(m >= x)	Change(l, m, rt << 1, x, y, val);
	if(m < y)	Change(m + 1, r, rt << 1 | 1, x, y, val);
}
int ans;
bool hs[35];
void Query(int l, int r, int rt, int x, int y) {
	if(color[rt] != -1) {
		if(!hs[color[rt]])	++ans;
		hs[color[rt]] = true;
		return;
	}
	PushDown(rt);
	int m = (l + r) >> 1;
	if(m >= x)	Query(l, m, rt << 1, x, y);
	if(m < y)	Query(m + 1, r, rt << 1 | 1, x, y);
}

int main(){
	scanf("%d%d%d", &n, &T, &Q);
	char st[5];
	int a, b, c;
	color[1] = 1;
	while(Q--) {
		scanf("%s%d%d", st, &a, &b);
		if(a > b) {
			swap(a, b);
		}
		if(st[0] == 'P') {
			mst(hs, false);
			ans = 0;
			Query(1, n, 1, a, b);
			printf("%d\n", ans);
		} else {
			scanf("%d", &c);
			Change(1, n, 1, a, b, c);
		}
	}
	return 0;
}



POJ3225

这题是真的难想、看了聚聚们的分析才懂

参考：Gakki

说一点自己做这题的感想吧、首先这里要求的是区间，但我们线段树维护的只是点，所以这里用到了这种用偶数表示点奇数来表示区间的这样一种想法(太妙了)， 之后就是区间之间的覆盖，覆盖很简单，但是难点在于区间01互换，这里用lazy标记来标志区间是否互换，覆盖的操作又可以去除区间01互换操作带来的影响。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <utility>

using namespace std;
#define LL long long
#define pb push_back
#define mk make_pair
#define mst(a, b)	memset(a, b, sizeof a)
#define REP(i, x, n)	for(int i = x; i <= n; ++i)
const int MOD = 1e9 + 7;
const int qq = 65535 * 2 + 2;
const int INF = 1e9 + 10;
int cover[qq << 2], lazy[qq << 2];
bool mark[qq];
void PushDown(int rt) {
	if(cover[rt] != -1)	cover[rt] ^= 1;
	else	lazy[rt] ^= 1;
}
void PushDate(int rt) {
	if(cover[rt] != -1) {
		cover[rt << 1] = cover[rt << 1 | 1] = cover[rt];
		lazy[rt << 1] = lazy[rt << 1 | 1] = 0;
		cover[rt] = -1;
	}
	if(lazy[rt]) {
		PushDown(rt << 1);
		PushDown(rt << 1 | 1);
		lazy[rt] = 0;
	}
}
void UpDate(int l, int r, int rt, int x, int y, int ch) {
	if(x <= l && r <= y) {
		if(ch == 'U')	cover[rt] = 1, lazy[rt] = 0;
		else if(ch == 'D')	cover[rt] = lazy[rt] = 0;
		else if(ch == 'S' || ch == 'C')	PushDown(rt);
		return;
	}
	PushDate(rt);
	int m = (l + r) >> 1;
	if(m >= x)	UpDate(l, m, rt << 1, x, y, ch);
	else if(ch == 'I' || ch == 'C')	cover[rt << 1] = lazy[rt << 1] = 0;
	if(m < y)	UpDate(m + 1, r, rt << 1 | 1, x, y, ch);
	else if(ch == 'I' || ch == 'C')	cover[rt << 1 | 1] = lazy[rt << 1 | 1] = 0;
}
void Query(int l, int r, int rt) {
	if(cover[rt] == 1) {
		for(int i = l; i <= r; ++i) {
			mark[i] = true;
		}
		return;
	}
	if(cover[rt] == 0)	return;
	if(l == r)	return;
	PushDate(rt);
	int m = (l + r) >> 1;
	Query(l, m, rt << 1);
	Query(m + 1, r, rt << 1 | 1);
}
int main(){
	int l, r;
	char a, b, c;
	while(scanf("%c %c%d,%d%c", &a, &b, &l, &r, &c) != EOF) {
		l <<= 1, r <<= 1;
		if(b == '(')	l++;
		if(c == ')')	r--;
		if(l > r) {
			if(a == 'I' || a == 'C')	cover[1] = lazy[1] = 0;
		} else {
			UpDate(0, qq, 1, l, r, a);
		}
		getchar();
	}
	bool f = false;
	int s = -1, t = -1;
	Query(0, qq, 1);
	for(int i = 0; i < qq; ++i) {
		if(mark[i])	s = (s == -1 ? i : s) , t = i;
		else if(s != -1) {
			if(f)	printf(" ");
			f = true;
			printf("%c%d,%d%c", s & 1 ? '(' : '[', s >> 1, (t + 1) >> 1, t & 1 ? ')' : ']');
			s = -1;
		}
	}
	if(!f)	printf("empty set");
	puts("");
	return 0;
}


UESTC 360

参考：聚聚

Yokile_
关注
专栏目录
线段树学习
jiqiren1994的博客
09-12 161
一、简介 线段树是一种平衡二叉搜索树(完全二叉树)，它将一个线段区间划分成一些单元区间。对于线段树中的每一个非叶子节点，表示区间[a, b]的和，它的左孩子表示的区间为[a,(a+b)/2]，右孩子表示的区间为[(a+b)/2+1,b]，最后的叶子节点数目为N，与数组下标对应。线段树一般包括建立、查询、插入、更新等操作，建立规模为N的时间复杂度是 O(NlogN)，其他操作时间复杂度为O(logN) 。 二、结构 由于线段树是完全二叉树，线段树可以使用数组保存，对二叉树进行层次遍历。 假设某个节点下标为i，
线段树学习笔记（个人整理模板）
最新发布
12-25
个人线段树学习整理
线段树学习（一）
爱.NET
03-29 108
先从书上把定义抄下来： 一棵二叉树，记为 T (a,b)，参数 a,b表示该节点表示区间[a,b)。区间的长度b-a 记为 L。 递归定义 T[a,b]：若 L&gt;1 ：[a, (a+b)/2]为 T 的左儿子，[(a+b) /2,b]为 T 的右儿子。 若 L=1 ：T 为一个叶子节点。 区间[1, 10]的线段树表示方法如下： 这里需要注意一点，图中一共有9个叶子节点，也就是说，...
线段树模板+模板题(HDU1166)
HKer_YM的博客
08-20 418
题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=1166 原来都是用的别人的模板, 这次自己又重新看了一遍线段树(基础), 重新回顾了一遍, 敲了一遍模板 模板的注释写的蛮详细的, 这里就不讲解线段树了, emmmm 代码 #include <bits/stdc++.h> using namespace std; const int MA...
22/5/2
aidaqiudeaichao的博客
05-02 256
1，cf Game with Chips；2，acwing 243.一个简单的整数问题2（线段树）；3，亚特兰蒂斯（扫描线）；4，维护序列； 题意：给你n x m的棋盘，有k个芯片分布在棋盘上，操作是左右上下各平移一格，要求第i个芯片至少经过一次给定位置；芯片遇到墙后，若仍往墙的方向走，则会不动；多个芯片可以在同一格； 操作次数不超过2nm次； 输出操作序列和操作步数；没有序列输出-1； 思路：直接将所有的芯片先移动到（1，1）在带着整体一个个走，遍历一遍棋盘，必能完成要求； 而且不会超过2nm；
线段树学习步骤
08-09
以下是对线段树学习步骤的详细解析： **1. 基础概念理解** 线段树是一种二叉树，每个节点都对应一个区间，根节点对应整个数组的区间。节点的左右子节点分别对应区间的左半部分和右半部分。线段树的每个叶子节点存储...
线段树学习ppt
10-22
线段树学习ppt
线段树学习资料
09-25
线段树是一种数据结构，它主要用于高效处理区间（或线段）上的查询和修改操作。在计算机科学中，线段树通常被用作解决区间最值、区间加减、区间统计等问题。它实际上是一棵特殊的二叉树，每个节点代表一个区间，而每...
线段树学习——入门篇
morestep的专栏
01-10 785
线段树——入门篇 简介 对于广大的OIer来说，线段树并不是一个陌生的词。作为一种比较高大上的数据结构，线段树有许多的优点。它有着过硬的区间处理功能，在解决区间问题上能够占据一席之地，其区间修改和查询的时间复杂度都是O(log2n)的，因此许多区间性质的问题都可以用它来维护以获得良好的效率，而它本身也可以处理许多基础的区间问题。 当然，它也有缺点，最明显的就是它的空间浪费问题，如果是堆式建法
线段树入门学习总结
without的博客
05-14 311
** 线段树 线段树是一种二叉搜索树，与区间树相似，它将一些区间划分成一些单元区间，每个单元区间对应线段树上的一个叶节点。 对于线段树中每个非叶子结点【a，b】，他的左儿子表示的区间为【a，（a+b)/2】，右儿子表示的区间【(a+b)+1,b】，因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。 其时间复杂度为O(m*logN). 线段树有很多模板，基本上每道题都是稍微改下或者...
线段树全面学习 （慢慢更新）
UniversalCode的海贼船
03-29 172
线段树的介绍以后再补充，先给算法题型分类吧！ 首先明确一下,如果难以转化或者满足区间加和问题,那么使用线段树就很难解决问题,所以推荐使用 离线的莫队算法(不支持复杂的修改): 对查询的q个区间进行排序 以及 在线的分块算法. 一 、简单点更新，区间查询的线段树问题 这里以区间和为例: hdu1166 #include&lt;iostream&gt; using namespace s...
线段树学习笔记
qq_36172410的博客
05-12 116
线段树的构造 void build(Node* cur,int l,int r) { cur->Left=l;//区间左端点 cur->Right=r;//区间右端点 if (l+1<r)//如果不是初等区间，那么继续递归构建 { cur->LeftChild=new Node; cur->rightChild=new Node; build(cur->Left...
线段树学习总结
lifelike
08-04 286
队伍分好后，我负责数据结构部分。。。。 以后要狂补数据结构了，不能再做水题找存在感了。 今天总结一下线段树 以后长期更新题型。。 **part 1 线段树是是什么？**线段树是一种可以方便维护数列的数据结构。 更新和查找都可以在log(n)的复杂度内完成。 经（我）证（不）明（会）其最差空间复杂度为4*n。记住就好。 线段树可以看做维护线段的树part 2 线段树如何的结构是什么？首先，
线段树的初学认知及操作步骤
i_like1ac的博客
07-24 171
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。 线段树主要作用就是单点，区间查询和修改值。它的实现复杂度比较低，应用也比较广泛。 单点修改和查询基本步...
超级详细的线段树入门教程【附模板】
weixin_45761011的博客
11-10 1330
来看一个简单的例子 现在给出一个包含n个整数的数组，对该数组进行m次操作 每次操作给出一个值 op 若 op == 1 则将第 p 的元素改成 k 若 op == 2 则求出区间[l, r]内的最大值并输出 现在来分析这个问题 很显然暴力的做法复杂度高达O(nm)，那么现在考虑来优化这个问题 假设给出的数组是 {1, 5, 2, 3, 4, 8} 我们很容易发现 max{1, 5, 2, 3, 4, 8} = max(max{1, 5, 2}, max{3, 4, 8}}; max{1, 5, 2} =
线段树学习（单点更新+区间更新+区间查询）(C++模板)
Amove
06-07 6300
一、线段树的用处         在对一组连续的数据进行修改或者求和（求最值）操作时,线段树可以通过快速的修改子区间上的值来达成你的目标。     二、线段树是什么         线段树是一种二叉搜索树，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一条线段对应的状态。         看一副图来理解（图片魔改自百度百科）：  ...
自学线段树的一些最最基本的操作
Hello,I'm Proking.
07-29 2342
在最近两天的自学线段树当中，我领略了很多，接下来就讲一下我所领悟的东西。 首先，线段树的风格是比较重要的。每一个人写线段树都有很不一样的写法，我现在是看了老师教材里的写法写的，当然还有很多不一样的写法——如非递归、用record记录左儿子和右儿子之类的。 我的风格，也是教材里的风格是把x*2和x*2+1视为x的左儿子右儿子，另外我也觉得这样子挺方便的，与堆的储存方式很相像。
线段树 从入门到进阶（超清晰，简单易懂）
热门推荐
繁凡さん的博客
02-12 8万+
目录第一部 概念引入第二部 简单（无pushdown）的线段树1、单点修改，区间查询2、区间修改，单点查询第三部 进阶线段树第四部 乘法（根号）线段树1、乘法线段树2、根号线段树模板题与代码：单点修改，区间查询：洛谷树状数组模板1区间修改，单点查询：洛谷树状数组模板2区间加法，洛谷线段树模板1区间乘法：洛谷线段树模板2区间根号，bzoj3211 线段树是什么？？线段树怎么写？？ 如果你在考提高组前...
线段树详解与应用
"更新线段树-线段树学习ppt" 线段树是一种数据结构，主要用于高效地处理一系列区间或线段上的查询和修改操作。它通常被用来解决区间求和、区间最大值、区间最小值等问题。线段树通过分治的思想构建，将一个大区间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值