线段树

最新推荐文章于 2023-09-22 21:17:03 发布
最新推荐文章于 2023-09-22 21:17:03 发布
阅读量275 收藏
点赞数
分类专栏： ACM
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq789045/article/details/52741549
版权



POJ 3264 模板题目

#include<stdio.h>
#include<algorithm>
using namespace std;

const int INF = 1 << 30;

int minV = INF;
int maxV = -INF;

struct Node
{
	int maxV;
	int minV;
	int L, R;
	int mid()
	{
		return (L + R) / 2;
	}
};

Node tree[800010];

void buildTree(int root, int L, int R)
{
	tree[root].L = L;
	tree[root].R = R;
	tree[root].maxV = -INF;
	tree[root].minV = INF;
	if (L != R)
	{
		buildTree(2 * root + 1, L, (L + R) / 2);
		buildTree(2 * root + 2, (L + R) / 2 + 1, R);
	}
}

void insert(int root, int i, int v)
{
	if (tree[root].L == tree[root].R)
	{
		tree[root].minV = tree[root].maxV=v;
		return;
	}
	tree[root].minV = min(tree[root].minV, v);
	tree[root].maxV = max(tree[root].maxV, v);

	if (i <= tree[root].mid())
		insert(2 * root + 1, i, v);
	else
		insert(2 * root + 2, i, v);
}

void query(int root, int s, int e)
{
	if (tree[root].minV >= minV && tree[root].maxV <= maxV)
		return;
	if (tree[root].L == s && tree[root].R == e)
	{
		minV = min(minV, tree[root].minV);
		maxV = max(maxV, tree[root].maxV);
		return;
	}
	if (e <= tree[root].mid())
		query(2 * root + 1, s, e);
	else if (s>tree[root].mid())
		query(2 * root + 2, s, e);
	else
	{
		query(2 * root + 1, s, tree[root].mid());
		query(2 * root + 2, tree[root].mid() + 1, e);
	}
}

int main()
{
	int n, q, h;
	

	scanf("%d%d", &n, &q);
	buildTree(0, 1, n);

	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &h);
		insert(0, i, h);
	}
	for (int i = 0; i<q; i++)
	{
		int s, e;
		scanf("%d%d", &s, &e);
		minV = INF;
		maxV = -INF;
		query(0, s, e);
		printf("%d\n", maxV - minV);
	}
}


POJ 3468 模板题2

#include<stdio.h>
#include<algorithm>
using namespace std;

struct CNode
{
	int L, R;
	CNode *left,* right;
	long long nsum;
	long long lnc;
	int mid()
	{
		return (L + R) / 2;
	}
};

CNode Tree[200010];
int nCount = 0;

void buildTree(CNode * pRoot, int L, int R)
{
	pRoot->L = L;
	pRoot->R = R;
	pRoot->nsum = 0;
	pRoot->lnc = 0;
	if (L == R)
		return;
	nCount++;
	pRoot->left = Tree + nCount;
	nCount++;
	pRoot->right = Tree + nCount;
	buildTree(pRoot->left, L, (L + R) / 2);
	buildTree(pRoot->right, (L + R) / 2 + 1, R);
}

void insert(CNode* pRoot, int i, int v)
{
	if (pRoot->L == i && pRoot->R == i)
	{
		pRoot->nsum = v;
		return;
	}
	pRoot->nsum += v;
	if (i <= pRoot->mid())
		insert(pRoot->left, i, v);
	else
		insert(pRoot->right, i, v);

}

void add(CNode * pRoot, int a, int b, long long c)
{
	if (pRoot->L == a && pRoot->R == b)
	{
		pRoot->lnc += c;
		return;
	}
	pRoot->nsum+=(b-a+1)*c;
	if (b <= pRoot->mid())
		add(pRoot->left, a, b, c);
	else if (a>pRoot->mid())
		add(pRoot->right, a, b, c);
	else
	{
		add(pRoot->left, a, pRoot->mid(), c);
		add(pRoot->right, pRoot->mid()+1, b, c);
	}
}

long long querySum(CNode* pRoot, int a, int b)
{
	if (pRoot->L == a && pRoot->R == b)
	{
		return pRoot->nsum + (pRoot->R - pRoot->L + 1)*pRoot->lnc;
	}
	pRoot->nsum += (pRoot->R - pRoot->L + 1)*pRoot->lnc;
	add(pRoot->left, pRoot->L, pRoot->mid(), pRoot->lnc);
	add(pRoot->right, pRoot->mid()+1, pRoot->R, pRoot->lnc);
	pRoot->lnc = 0;

	if (b <= pRoot->mid())
		return querySum(pRoot->left, a, b);
	else if (a>pRoot->mid())
		return querySum(pRoot->right, a, b);
	else
	{
		return querySum(pRoot->left, a, pRoot->mid()) + querySum(pRoot->right, pRoot->mid() + 1, b);
	}
}


int main()
{
	int n, q, a, b, c;
	char cmd[10];
	scanf("%d%d", &n, &q);
	nCount = 0;
	buildTree(Tree, 1, n);
	for (int i = 1; i <= n; i++)
	{
		scanf("%d", &a);
		insert(Tree, i, a);
	}
	for (int i = 0; i<q; i++)
	{
		scanf("%s", cmd);
		if (cmd[0] == 'C')
		{
			scanf("%d%d%d", &a, &b, &c);
			add(Tree, a, b, c);
		}
		else
		{
			scanf("%d%d", &a, &b);
			printf("%lld\n", querySum(Tree, a, b));
		}
	}
}


POJ 2528 海报张贴

#include<stdio.h>
#include<algorithm>
#include<string.h>
using namespace std;

struct Node
{
	int l, r;
	bool iscovered;//Full coverage
	int left, right;
	int mid()
	{
		return (l + r) / 2;
	}
};

Node tree[50000];

struct Poster
{
	int l, r;
};

Poster poster[10010];
int sortArr[20020];
int hashArr[10000010];

int n;
int cnt;

void buildTree(int root, int a, int b)
{
	tree[root].iscovered = false;
	tree[root].l = a;
	tree[root].r = b;
	if (a == b)
		return;
	tree[root].left = 2 * root + 1;
	tree[root].right = 2 * root + 2;
	buildTree(tree[root].left, a, tree[root].mid());
	buildTree(tree[root].right, tree[root].mid() + 1, b);
}


bool insert(int root, int a, int b)//1 ,wan quan fu gai
{
	if (tree[root].iscovered == true)
		return true;

	if (tree[root].l == a &&  tree[root].r == b)
	{
		tree[root].iscovered = true;
		return false;
	}
	bool result;
	if (b <= tree[root].mid())
		result = insert(tree[root].left, a, b);
	else if (a>tree[root].mid())
		result = insert(tree[root].right, a, b);
	else
	{

		bool result1 = insert(tree[root].left, a, tree[root].mid());
		bool result2 = insert(tree[root].right, tree[root].mid() + 1, b);
		result = result1&&result2;
	}
	if (tree[tree[root].left].iscovered == true && tree[tree[root].right].iscovered == true)
		tree[root].iscovered = true;
	return result;
}

int main()
{
	int c;
	scanf("%d", &c);

	while (c--)
	{
		scanf("%d", &n);
		cnt = 0;
		for (int i = 1; i <= n; i++)
		{
			scanf("%d%d", &poster[i].l, &poster[i].r);
			sortArr[cnt++] = poster[i].l;
			sortArr[cnt++] = poster[i].r;
		}
		sort(sortArr, sortArr + cnt);
		cnt = unique(sortArr, sortArr + cnt) - sortArr;
		memset(hashArr, -1, sizeof(hashArr));
		for (int i = 0; i<cnt; i++)
		{
			hashArr[sortArr[i]] = i;
		}
		buildTree(0, 0, cnt);

		int ans = 0;
		for (int i = n; i >= 1; i--)
		{
			if (!insert(0, hashArr[poster[i].l], hashArr[poster[i].r]))
				ans++;
		}
		printf("%d\n", ans);
	}
}



POJ 1151 矩形面积(区间两头的点)

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
using namespace std;

const int MAXN = 110;

map<double, int> yMap;

struct Node
{
	double len;
	int cover;

	int l, r;
};

struct Line
{
	double x, y1, y2;
	bool isLeft;
	bool operator<(const Line & rhs)const
	{
		return x<rhs.x;
	}
};

Node tree[MAXN * 5];
Line lines[MAXN * 2];

int n, cnt;
double y[MAXN * 2];

void build(int root, int l, int r)
{
	tree[root].l = l;
	tree[root].r = r;
	tree[root].len = 0;
	tree[root].cover = 0;
	if (r > l + 1)
	{
		build(2 * root, l, (l + r) / 2);
		build(2 * root + 1, (l + r) / 2, r);
	}
}

void insert(int root, int l, int r)
{
	if (tree[root].l == l && tree[root].r == r)
	{
		tree[root].cover++;
		tree[root].len = y[r] - y[l];
		return;
	}

	int mid = (tree[root].l + tree[root].r) / 2;
	if (r <= mid)
		insert(2 * root, l, r);
	else if (l >= mid)
		insert(2 * root + 1, l, r);
	else
	{
		insert(2 * root, l, mid);
		insert(2 * root + 1, mid, r);
	}

	if (tree[root].cover == 0)
	{
		tree[root].len = tree[2 * root].len + tree[2 * root + 1].len;
		
	}

}

void del(int root, int l, int r)
{
	if (tree[root].l == l && tree[root].r == r)
	{
		tree[root].cover--;
		if (tree[root].cover == 0)
		{
			if (tree[root].r - tree[root].l > 1)
				tree[root].len = tree[2 * root].len + tree[2 * root + 1].len;
			else
				tree[root].len = 0;
		}
		return;
	}
	else
	{
		int mid = (tree[root].l + tree[root].r) / 2;
		if (r <= mid)
			del(2 * root, l, r);
		else if (l >= mid)
			del(2 * root + 1, l, r);
		else
		{
			del(2 * root, l, mid);
			del(2 * root + 1, mid, r);
		}
	}
	if (tree[root].cover == 0)
	{
		tree[root].len = tree[2 * root].len + tree[2 * root + 1].len;
	}
}



int main()
{
	int t = 1;
	while (true)
	{
		yMap.clear();
		double x1, x2, y1, y2;
		scanf("%d", &n);
		if (n == 0)
			return 0;
		for (int i = 0; i < n; i++)
		{
			scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
			lines[2 * i].x = x1;
			lines[2 * i + 1].x = x2;
			lines[2 * i].y1 = lines[2 * i + 1].y1 = y1;
			lines[2 * i].y2 = lines[2 * i + 1].y2 = y2;
			lines[2 * i].isLeft = true;
			lines[2 * i + 1].isLeft = false;
			y[2 * i] = y1;
			y[2 * i + 1] = y2;
		}
		sort(y, y + 2 * n);
		cnt = unique(y, y + 2 * n) - y;
		for (int i = 0; i < cnt; i++)
			yMap[y[i]] = i;


		sort(lines, lines + 2 * n);
		build(1, 0, cnt - 1);
		double ans = 0;
		for (int i = 0; i < 2 * n - 1; i++)
		{
			if (lines[i].isLeft)
				insert(1, yMap[lines[i].y1], yMap[lines[i].y2]);
			else
				del(1, yMap[lines[i].y1], yMap[lines[i].y2]);
			ans += tree[1].len*(lines[i + 1].x - lines[i].x);

		}
		printf("Test case #%d\nTotal explored area: %.2f\n\n", t++, ans);
	}
}


POJ 1151 矩形面积(区间)

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<map>
using namespace std;

const int MAXN = 110;

map<double, int> yMap;

struct Node
{
	double len;
	int cover;

	int l, r;
};

struct Line
{
	double x, y1, y2;
	bool isLeft;
	bool operator<(const Line & rhs)const
	{
		return x < rhs.x;
	}
};

Node tree[MAXN * 5];
Line lines[MAXN * 2];

int n, cnt;
double y[MAXN * 2];

void build(int root, int l, int r)
{
	tree[root].l = l;
	tree[root].r = r;
	tree[root].len = 0;
	tree[root].cover = 0;
	if (r != l)
	{
		build(2 * root, l, (l + r) / 2);
		build(2 * root + 1, (l + r) / 2 + 1, r);
	}
}

void insert(int root, int l, int r)
{
	if (tree[root].l == l && tree[root].r == r)
	{
		tree[root].cover++;
		tree[root].len = y[r + 1] - y[l];
		return;
	}

	int mid = (tree[root].l + tree[root].r) / 2;
	if (r <= mid)
		insert(2 * root, l, r);
	else if (l >= mid+1)
		insert(2 * root + 1, l, r);
	else
	{
		insert(2 * root, l, mid);
		insert(2 * root + 1, mid + 1, r);
	}

	if (tree[root].cover == 0)
	{
		tree[root].len = tree[2 * root].len + tree[2 * root + 1].len;

	}

}

void del(int root, int l, int r)
{
	if (tree[root].l == l && tree[root].r == r)
	{
		tree[root].cover--;
		if (tree[root].cover == 0)
		{
			if (tree[root].r != tree[root].l)
				tree[root].len = tree[2 * root].len + tree[2 * root + 1].len;
			else
				tree[root].len = 0;
		}
		return;
	}
	else
	{
		int mid = (tree[root].l + tree[root].r) / 2;
		if (r <= mid)
			del(2 * root, l, r);
		else if (l >= mid+1)
			del(2 * root + 1, l, r);
		else
		{
			del(2 * root, l, mid);
			del(2 * root + 1, mid + 1, r);
		}
	}
	if (tree[root].cover == 0)
	{
		tree[root].len = tree[2 * root].len + tree[2 * root + 1].len;
	}
}



int main()
{
	int t = 1;
	while (true)
	{
		yMap.clear();
		double x1, x2, y1, y2;
		scanf("%d", &n);
		if (n == 0)
			return 0;
		for (int i = 0; i < n; i++)
		{
			scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
			lines[2 * i].x = x1;
			lines[2 * i + 1].x = x2;
			lines[2 * i].y1 = lines[2 * i + 1].y1 = y1;
			lines[2 * i].y2 = lines[2 * i + 1].y2 = y2;
			lines[2 * i].isLeft = true;
			lines[2 * i + 1].isLeft = false;
			y[2 * i] = y1;
			y[2 * i + 1] = y2;
		}
		sort(y, y + 2 * n);
		cnt = unique(y, y + 2 * n) - y;
		for (int i = 0; i < cnt; i++)
			yMap[y[i]] = i;


		sort(lines, lines + 2 * n);
		build(1, 0, cnt - 1 - 1);
		double ans = 0;
		for (int i = 0; i < 2 * n - 1; i++)
		{
			if (lines[i].isLeft)
				insert(1, yMap[lines[i].y1], yMap[lines[i].y2]-1);
			else
				del(1, yMap[lines[i].y1], yMap[lines[i].y2]-1);
			ans += tree[1].len*(lines[i + 1].x - lines[i].x);

		}
		printf("Test case #%d\nTotal explored area: %.2f\n\n", t++, ans);
	}
}


POJ 3321 苹果树 树状数组

#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
using namespace std;

#define MAXN 100010

vector<vector<int> > graph(100010);

int start[MAXN];
int End[MAXN];
int c[MAXN * 2];

int n;

int ncount;
int lowBit[MAXN*2];
int hasApple[MAXN];

void dfs(int u)
{
	start[u] = ++ncount;
	for (int i = 0; i<graph[u].size(); i++)
	{
		dfs(graph[u][i]);
	}
	End[u] = ++ncount;
}



void modify(int num, int val)
{
	while (num <= ncount)
	{
		c[num] += val;
		num += lowBit[num];
	}
}

int query(int num)
{
	int sum = 0;
	while (num>0)
	{
		sum += c[num];
		num -= lowBit[num];
	}
	return sum;
}

int main()
{
	scanf("%d", &n);
	int u, v;
	ncount = 0;




	for (int i = 0; i<MAXN; i++)
		hasApple[i] = 1;


	for (int i = 0; i<n - 1; i++)
	{
		scanf("%d%d", &u, &v);
		graph[u].push_back(v);
	}

	dfs(1);

	for (int i = 0; i <= ncount; i++)
		lowBit[i] = (i&(-i));

	for (int i = 0; i <= ncount; i++)
		c[i] = i - (i - lowBit[i]);

	int m;
	scanf("%d", &m);

	char cmd[5];

	int a;

	for (int i = 0; i<m; i++)
	{
		scanf("%s%d", cmd, &a);
		if (cmd[0] == 'C')
		{
			if (hasApple[a])
			{
				hasApple[a] = 0;
				modify(start[a], -1);
				modify(End[a], -1);
			}
			else
			{
				hasApple[a] = 1;
				modify(start[a], 1);
				modify(End[a], 1);
			}
		}
		else
		{
			int t1 = query(start[a] - 1);
			int t2 = query(End[a]);
			printf("%d\n", (t2 - t1) / 2);
		}
	}


}


qq789045
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树建树
12-14
线段树是一种二叉树，也就是说，每个线段都可以用一二叉树表示 比如一个长度为4的线段可以如此表示： ——————————————-4 1————-2————-3————4 1 2 3 4 如果你要表示线段上的和，最上面的根...
线段树详解
orz
05-20 1万+
1. 什么是线段树 顾名思义 ， 线段树是一棵二叉树 ， 但不同的是这棵树的结点储存的值是一个数列中 [l,r][l,r][l,r] 的某个需要的值 （例如，求和，求最大值，求最小值） 这是一棵典型的线段树 ，其性质是 ： 若其中一子节点编号为 aaa ， 则该节点左儿子编号为 2a2a2a ， 其右儿子编号为 2a+12a+12a+1 2. 线段树的用处 线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是 O(log2n)O(log_2 n)O(log2​n). 3.
线段树 从入门到进阶（超清晰，简单易懂）
热门推荐
繁凡さん的博客
02-12 8万+
目录第一部 概念引入第二部 简单（无pushdown）的线段树1、单点修改，区间查询2、区间修改，单点查询第三部 进阶线段树第四部 乘法（根号）线段树1、乘法线段树2、根号线段树模板题与代码：单点修改，区间查询：洛谷树状数组模板1区间修改，单点查询：洛谷树状数组模板2区间加法，洛谷线段树模板1区间乘法：洛谷线段树模板2区间根号，bzoj3211 线段树是什么？？线段树怎么写？？ 如果你在考提高组前...
什么是线段树
ThinPikachu的博客
04-04 1736
线段树的概念 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。 线段树的应用 线段树 segmentTree 是一个二叉树，每个结点保存数组 nums 在区间 [left, right] 的最...
李超线段树
最新发布
fzyyyyyyyy的博客
09-22 945
李超线段树是巨佬李超发明的一种，又名李超树。代码简短，思想简明，用途广泛。
线段树练习题集
UncleJokerly
04-28 2282
线段树题目整合 1.hdu1166 敌兵布阵 更新节点,区间求和。 2.hdu1754 I Hate It 更新节点,区间最值. .3.hdu1698 Just a Hook 成段更新,总区间求和. .4.hdu1394 Minimum Inversion Number 更新节点,区间求和 .5.hdu1779（这个爆炸了，别做了） 成段更新,区间最值 .6.pku...
线段树模板
听取WA声一片
10-28 2129
线段树 打标记
LibreOJ-dfs序2 (dfs序，线段树）
01-03
LibreOJ-dfs序2 (dfs序，线段树） 题目描述 给一棵有根树，这棵树由编号为1~N 的 N个结点组成。根结点的编号为R。每个结点都有一个权值，结点 的权值为 。 接下来有 M组操作，操作分为两类： 1 a x，表示将结点 的子...
第十一届蓝桥杯校内赛：选节目(线段树解法)
01-06
选节目 小明要组织一台晚会，总共准备了 n 个节目。然后晚会的时间有限，他只能最终选择其中的 m 个节目。这 n 个节目是按照小明设想的顺序给定的，顺序不能改变。 小明发现，观众对于晚上的喜欢程度与前几个节目的...
北大ACM暑期培训感想
wwj_bupt
10-05 3424
博客从7月17日就没更新了，18日开始参加了半个月的ACM培训，然后一直刷老师课上讲过的题目。智商捉急，现在剩下计算几何这章不想刷了。   收获很多，锻炼了思维，学了几个算法，增加了受虐能力，培养了良好的心理素质。。。   打了沈阳和北京的网络赛，均未打进网络赛。北京赛区有两道水题，另一位队友告诉我思路，我拍代码，第一道水题（用map的）我花了2个小时才AC，只是提交一次就AC了，当时很开心。
贪心——特殊密码锁
wwj_bupt
10-06 1615
特殊密码锁 #include #include #include #include #include #include using namespace std; #define MAXN 35 int len; bitset goal; bitset ori; int cnt; int best; void turn(bitset & b,int i) { b.flip(i)
网络流
wwj_bupt
10-06 760
POJ 1273 简单BFS网络流模板 #include #include #include using namespace std; int g[300][300]; int Prev[300]; bool visited[300]; int n, m; unsigned augment() { queue q; memset(Prev, 0, sizeof(Prev)); me
图论
wwj_bupt
10-06 525
强连通分量 POJ 2186 popular cow 从一个没有入度的连通分量遍历图 #include #include #include #include #include #include #include #include using namespace std; const int INF = 1 << 30; int n, m; vector > g(10010);
广搜 深搜
wwj_bupt
10-06 403
海贼王之伟大航路 #include #include #include #include #include using namespace std; #define MAXN 20 #define INFINITE 1<<30 int N; int graph[MAXN][MAXN]; typedef pair Path_End; map dp; //queue q; int bes
水题 A Simple Job
wwj_bupt
10-06 369
A Simple Job #include #include #include #include using namespace std; typedef pair Pii; map m1; map m3; map m2; bool operator<(const Pii & a, const Pii &b) { if (a.first != b.first) retu
动态规划
wwj_bupt
10-05 336
poj1163 #include #include #include #define MAXN 105 int n; int num[MAXN][MAXN]; int d[MAXN]; int max(int a,int b) { if(a<b) return b; else return a; } int main(){ scanf("%d",&n); f
线段树详解与应用
"线段树基础" 线段树是一种数据结构，主要用于处理区间或段上的数据查询和更新操作，常用于解决动态区间统计问题。它是由二叉树结构实现的，每个节点代表一个特定的区间，而这个区间在树的不同层级被不断细分。线段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值