线段树合集 III

最新推荐文章于 2022-12-28 21:37:51 发布
最新推荐文章于 2022-12-28 21:37:51 发布
阅读量715 收藏
点赞数
分类专栏： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/solotzg/article/details/17061769
版权

hdu 4747 Mex

这道题明显考的是思维方式，线段树作为成段更新求和的辅助。
for i = 1:n
x(i) = 从1到i区间内符合题意的值
end
for i = n:1
y(i) = num(i)下次出现的最近位置
end
res=x(1:n)
for cur = 1:n-1
更新cur+1:y[cur]-1的值，这里用到线段树
res+=结果(cur+1:n)
end 
#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
/* 
	http://acm.hdu.edu.cn/showproblem.php?pid=4747
*/
const int MAXN = 200010;
const int INF = MAXN<<2;
const int ZERO = -1;
#define LL __int64
#define ll (root<<1)
#define rr (ll|1)
#define lson l,m,ll
#define rson m+1,r,rr
#define mid m=(l+r)>>1
int n, cur;
int data[MAXN], num[MAXN], next[MAXN], pp[MAXN];
struct _MEX
{
	int mx, mn;
	LL sum;
	int sz;
}mex[MAXN*3];
void pushUP(int l, int r, int m, int root)
{
	mex[root].sum = 0;
	mex[root].mx = ZERO; mex[root].mn = INF;
	int z = ll, y = rr;
	if (m >= cur)
	{
		mex[root].sum += mex[z].sum;
		mex[root].mx = max(mex[root].mx, mex[z].mx);
		mex[root].mn = min(mex[root].mn, mex[z].mn);
	}
	if (r >= cur)
	{
		mex[root].sum += mex[y].sum;
		mex[root].mx = max(mex[root].mx, mex[y].mx);
		mex[root].mn = min(mex[root].mn, mex[y].mn);
	}
}
void pushDOWN(int l, int r, int m, int root)
{
	if (mex[root].sz == -1) return;
	int z = ll, y = rr;
	if (m >= cur)
	{
		int k = max(cur, l);
		mex[z].sum = (LL)(m-k+1) * (LL)mex[root].sz;
		mex[z].mx = mex[z].mn = mex[root].sz;
		mex[z].sz = mex[root].sz;
	}
	if (r >= cur)
	{
		int k = max(cur, m+1);
		mex[y].sum = (LL)(r-k+1) * (LL)mex[root].sz;
		mex[y].mx = mex[y].mn = mex[root].sz;
		mex[y].sz = mex[root].sz;
	}
	mex[root].sz = -1;
}
void build(int l, int r, int root)
{
	mex[root].sz = -1;
	if (l == r)
	{
		mex[root].mx = mex[root].mn = data[l];
		mex[root].sum = data[l];
		return;
	}
	int mid;
	build(lson); build(rson);
	pushUP(l,r,m,root);
}
void change(int c, int x, int y, int l, int r, int root)
{
	if (x <= l && y >= r )
	{
		if (c < mex[root].mn)
		{
			mex[root].mx = mex[root].mn = c;
			mex[root].sz = c;
			int k = max(cur, l);
			mex[root].sum = (LL)(r-k+1) * c;		
			return;
		}
		if (c > mex[root].mx)
		{
			if (l >= cur) return;
		}		
	}
	int mid;
	pushDOWN(l,r,m,root);
	if (x <= m && m >= cur)
	{
		change(c,x,y,lson);
	}
	if (y > m && r >= cur)
	{
		change(c,x,y,rson);
	}
	pushUP(l,r,m,root);
}

int main() 
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	while (scanf("%d", &n)!=EOF && n)
	{
		for (int i = 0; i< n; ++i)
		{
			scanf("%d", &num[i]);
			if (num[i] > n) num[i] = n+1;
		}
		int c = 0;
		memset(next, 0, sizeof next);
		for (int i = 0; i< n; ++i)
		{
			next[num[i]] = 1;
			while (next[c]) c++;
			data[i] = c;
		}
		memset(pp, -1, sizeof pp);
		for (int i = n-1; i>= 0; --i)
		{
			next[i] = pp[num[i]];
			pp[num[i]] = i;
		}
		cur = 0;
		build(0,n-1, 1);
		LL res = mex[1].sum;
		for (int i = 0; i < n-1; ++i)
		{
			cur = i+1;
			if (num[i] != num[i+1])
			{				
				if (next[i] == -1)
					change(num[i], i+1, n-1, 0, n-1, 1);
				else
					change(num[i], i+1, next[i]-1, 0, n-1, 1);				
			}
			else
			{
				change(INF,i+1,i+1,0,n-1,1);
			}
			res += mex[1].sum;
		}
		printf("%I64d\n", res);		
	}
    return 0;
}


hdu 3642 Get The Treasury

利用线段树求区间重叠，原理上和 hdu 1255 差不多。。。
加入点优化，Node 中的 one ，two， more 表示 大于等于 1,2,3 次，这样在段汇总的时候就可以省去一些步骤 
#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
/* 
	http://acm.hdu.edu.cn/showproblem.php?pid=3642
*/
const int MAXN = 3000;
#define LL __int64  
#define ll (root<<1)  
#define rr (ll|1)  
#define lson l,mm,ll  
#define rson mm,r,rr  
#define mid mm=(l+r)>>1  
struct mFace
{
	int y;
	int x1, x2, z1, z2;
	int sz;
	mFace(){}
	mFace(int _y, int _x1, int _x2, int _z1, int _z2, int _sz)
	:y(_y), x1(_x1), x2(_x2), z1(_z1), z2(_z2), sz(_sz)
	{}
	bool operator < (const mFace & a) const
	{
		return y < a.y;
	}
}mf[MAXN], tp[MAXN];
struct Node
{
	int one, two, more;
	int c, x1, x2, y;	// cnt; range x1, x2; y
	int l, r;	// index
	int len;
	void init()
	{
		one = two = more = 0;
		c = 0; len = x2-x1;
	}
}nd[MAXN*3];
int xx[MAXN], zz[MAXN];
void build (int l, int r, int root)
{
	nd[root].x1 = xx[l]; nd[root].x2 = xx[r];
	nd[root].l = l, nd[root].r = r;
	nd[root].init();
	if (l+1 == r) return;
	int mid;
	build(lson);
	build(rson);
}
void pushUP(int root)
{
	int l = nd[root].l, r = nd[root].r;
	if (nd[root].c == 0)
	{
		if (l+1 == r)
		{
			nd[root].one = nd[root].two = nd[root].more = 0;
		}
		else
		{
			nd[root].one = nd[ll].one + nd[rr].one;
			nd[root].two = nd[ll].two + nd[rr].two;
			nd[root].more = nd[ll].more + nd[rr].more;
		}
	}
	else if (nd[root].c == 1)
	{
		nd[root].one = nd[root].len;
		if (l + 1 == r)
		{			
			nd[root].two = nd[root].more = 0;
		}
		else
		{
			nd[root].two = nd[ll].one + nd[rr].one;
			nd[root].more = nd[ll].two + nd[rr].two;
		}
	}
	else if (nd[root].c == 2)
	{
		nd[root].one = nd[root].two = nd[root].len;
		if (l+1 == r)
		{
			nd[root].more = 0;
		}
		else
		{
			nd[root].more = nd[ll].one + nd[rr].one;
		}
	}
	else
	{		
		nd[root].one = nd[root].two = nd[root].more = nd[root].len;
	}
}
void change(int root, int x1, int x2, int c)
{
	if (x1 <= nd[root].x1 && x2 >= nd[root].x2)
	{
		nd[root].c += c;
		if (nd[root].c == 2)
		{
			printf("");
		}
		pushUP(root);
		return;
	}
	if (x1 < nd[ll].x2)	change(ll, x1, x2, c);
	if (x2 > nd[rr].x1) change(rr, x1, x2, c);
	pushUP(root);
}
int main() 
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	int t;
	scanf("%d", &t);
	for (int _ = 1; _ <= t; ++_)
	{
		printf("Case %d: ", _);
		int n, k = 0;
		scanf("%d", &n);
		for (int i = 0; i< n; ++i)
		{
			int x1, y1, z1, x2, y2, z2;
			scanf("%d%d%d%d%d%d", &x1, &y1, &z1, &x2, &y2, &z2);
			mf[k] = mFace(y1, x1, x2, z1, z2, 1);
			xx[k] = x1; zz[k++] = z1;
			mf[k] = mFace(y2, x1, x2, z1, z2, -1);
			xx[k] = x2; zz[k++] = z2;
		}
		sort(mf, mf+k);
		sort(xx, xx+k);
		sort(zz, zz+k);
		int k1 = unique(xx, xx+k) - xx;
		int k2 = unique(zz, zz+k) - zz;
		build(0,k1-1,1);
		LL res = 0;
		int m;
		for (int i = 0; i < k2-1; ++i)
		{
			m = 0;
			for (int j = 0; j< k; ++j)
			{
				if (mf[j].z1 <= zz[i] && mf[j].z2 >= zz[i+1])
				{
					tp[m++] = mf[j];
				}
			}
			LL sum = 0;
			for (int j = 0; j< m; ++j)
			{
				if (j != 0)
					sum += (LL)nd[1].more * (LL)(tp[j].y - tp[j-1].y);
				change(1, tp[j].x1, tp[j].x2, tp[j].sz);
			}
			res += sum * (zz[i+1] - zz[i]);
		}
		printf("%I64d\n", res);
	}	
    return 0;
}


hdu 4419 Colourful Rectangle

如果搞懂了上一题，这题也差不多了，稍微加点变化 
#include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
// http://acm.hdu.edu.cn/showproblem.php?pid=4419
const int MAXN = 25000;
#define LL __int64  
#define ll (root<<1)  
#define rr (ll|1)  
#define lson l,mm,ll  
#define rson mm,r,rr  
#define mid mm=(l+r)>>1  
struct mFace
{
	int y, x1, x2;
	int c, f;
	bool operator < (const mFace & a) const
	{
		return y < a.y;
	}
	void getIn(int yy, int xx1, int xx2, int cc, int ff)
	{
		y = yy; x1 = xx1; x2 = xx2; c = cc; f = ff;
	}
}mf[MAXN];
const int MONE = 10*4;
const int MC = 5*4;
struct Node
{
	int one[10];
	int c[5], d;
	int x1, x2;	
	int l, r;
	int len;
	void init()
	{
		memset(one, 0, MONE);
		memset(c, 0, MC);
		d = 0;
		len = x2-x1;
	}
	void cal()
	{
		d = 0;
		for (int i = 0; i< 3; ++i)
		{
			if (c[i]) d |= 1<<i;
		}
	}
}nd[MAXN*3];
int xx[MAXN];
void build (int l, int r, int root)
{
	nd[root].x1 = xx[l]; nd[root].x2 = xx[r];
	nd[root].l = l, nd[root].r = r;
	nd[root].init();
	if (l+1 == r) return;
	int mid;
	build(lson);
	build(rson);
}
void pushUP(int root)
{
	int l = nd[root].l, r = nd[root].r;
	int d = nd[root].d;
	if (d == 0)
	{
		if (l+1 == r)
		{
			memset(nd[root].one, 0, MONE);			
		}
		else
		{
			for (int i = 1; i<8; ++i)
			{
				nd[root].one[i] = nd[ll].one[i] + nd[rr].one[i];
			}
		}
	}
	else
	{
		if (l+1 == r)
		{
			for (int i = 1; i< 8; ++i)
			{
				if ((i&d) == i)
				{
					nd[root].one[i] = nd[root].len;
				}
				else
				{
					nd[root].one[i] = 0;
				}
			}
		}
		else
		{
			for (int i = 1; i< 8; ++i)
			{
				if ((i&d) == i)
				{
					nd[root].one[i] = nd[root].len;
				}
				else
				{
					int a = i-(i&d);
					nd[root].one[i] = nd[ll].one[a] + nd[rr].one[a];
				}
			}
		}
	}
}
void change(int root, int x1, int x2, int c, int ff)
{
	if (x1 <= nd[root].x1 && x2 >= nd[root].x2)
	{
		nd[root].c[c] += ff;
		nd[root].cal();
		pushUP(root);
		return;
	}
	if (x1 < nd[ll].x2)	change(ll, x1, x2, c, ff);
	if (x2 > nd[rr].x1) change(rr, x1, x2, c, ff);
	pushUP(root);
}
char str[5];
int mot[10] = {1,2,4,3,5,6,7};
int main() 
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	int t;
	scanf("%d", &t);
	for (int _ = 1; _ <= t; ++_)
	{
		printf("Case %d:\n", _);
		int n, k = 0;
		scanf("%d", &n);
		for (int i = 0; i< n; ++i)
		{			
			int x1, x2, y1, y2, c, f;
			scanf("%s%d%d%d%d", str, &x1, &y1, &x2, &y2);
			switch (str[0])
			{
				case 'R': c = 0; break;
				case 'G': c = 1; break;
				case 'B': c = 2; break;
			}
			mf[k].getIn(y1,x1,x2,c,1);
			xx[k++] = x1;
			mf[k].getIn(y2,x1,x2,c,-1);
			xx[k++] = x2;
		}
		sort(mf, mf+k);
		sort(xx,xx+k);
		int k1 = unique(xx, xx+k) - xx;
		build(0,k1-1,1);
		LL res[10], nima; 
		LL tp[10];
		int ap[10];
		memset(res, 0, sizeof res);
		for (int i = 0; i< k; ++i)
		{
			if (i != 0)
			{
				memcpy(ap, nd[1].one, MONE);
				tp[7] = ap[7]; tp[6] = ap[6]-ap[7]; tp[5]=ap[5]-ap[7];
				tp[3]=ap[3]-ap[7];
				LL cao = tp[7]+tp[6]+tp[5]+tp[3];
				tp[4]=ap[4]-tp[5]-tp[6]-tp[7]; 
				tp[2]=ap[2]-tp[3]-tp[6]-tp[7];  
				tp[1]=ap[1]-tp[3]-tp[5]-tp[7]; 
				nima = (mf[i].y - mf[i-1].y);
				for (int j = 1; j< 8; ++j)
					res[j] += tp[j]*nima;
			}
			change(1, mf[i].x1, mf[i].x2, mf[i].c, mf[i].f);
		}
		for (int i = 0; i< 7; ++i)
		{
			printf("%I64d\n", res[mot[i]]);
		}
	}	
    return 0;
}


hdu 4288 Coder

算是线段树里一个比较巧妙的应用吧
LL num[5]; 表示该段中偏移i个位置后，每隔5个数相加和
int cnt; 表示段中数的个数
结果显而易见就是 总段偏移2个位置后（从第三个数起）的结果 
#include <cstdio>
#include <iostream>
#include <cmath>
#include <set>
#include <algorithm>
using namespace std;
// http://acm.hdu.edu.cn/showproblem.php?pid=4288
const int MAXN = 100005;
#define LL __int64  
#define ll (root<<1)  
#define rr (ll|1)  
#define lson l,mm,ll  
#define rson mm+1,r,rr  
#define mid mm=(l+r)>>1  
const int N = 5*sizeof(LL);
struct Node
{
	LL num[5];
	int cnt;
	int x1, x2;	
	void init() {memset(num, 0, N); cnt = 0;}
}nd[MAXN*3];
int xx[MAXN], q[MAXN], s[MAXN];
void build (int l, int r, int root)
{
	nd[root].x1 = xx[l]; nd[root].x2 = xx[r];
	nd[root].init();
	if (l == r) return;
	int mid;
	build(lson);
	build(rson);
}
void pushUP(int root)
{
	int l = ll, r = rr, c1, c2;
	nd[root].cnt = (c1=nd[l].cnt) + nd[r].cnt;
	for (int i = 0; i< 5; ++i)
	{
		if (c1 < i)
		{
			nd[root].num[i] = nd[l].num[i] + nd[r].num[i-c1];
		}
		else if (c1 == i)
		{
			nd[root].num[i] = nd[r].num[0];
		}
		else
		{
			c2 = (c1-i)%5;
			if (c2 != 0) c2 = 5-c2;
			nd[root].num[i] = nd[l].num[i] + nd[r].num[c2];
		}		
	}
}
void change(int root, int x, int c)
{
	if (nd[root].x2 == nd[root].x1)
	{
		if (c == 1)
		{
			nd[root].cnt = 1;
			nd[root].num[0] = x;
		}
		else
		{
			nd[root].init();
		}
		return;
	}
	if (x <= nd[ll].x2) change(ll,x,c);
	else change(rr,x,c);
	pushUP(root);
}
char str[5];
set<int> mset;
set<int>::iterator it;
int main() 
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	int n;
	while (scanf("%d", &n) != EOF)
	{
		mset.clear();
		for (int i = 0; i< n; ++i)
		{			
			scanf("%s", str);
			if (strcmp(str, "add") == 0)
			{
				scanf("%d", s+i);
				q[i] = 1;
				mset.insert(s[i]);
			}
			else if (strcmp(str, "del") == 0)
			{
				scanf("%d", s+i);
				q[i] = -1;
			}
			else
			{
				q[i] = 3;
			}
		}
		int k = 0;
		for (it = mset.begin(); it != mset.end(); ++it)
		{
			xx[k++] = *it;
		}
		build(0,k-1,1);
		for (int i = 0; i< n; ++i)
		{
			if (q[i] != 3) 
				change(1,s[i],q[i]);
			else 
				printf("%I64d\n", nd[1].num[2]);
		}
	}	
    return 0;
}


hdu 4267 A Simple Problem with Integers

这算是比较灵活的线段树的应用
一开始卡在如何解决延迟更新的问题上，借鉴了别人的思路，把求结果的那部分从低开始递归，这样就不需要延迟更新
算是个教训吧 
#include <cstdio>
#include <iostream>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
// http://acm.hdu.edu.cn/showproblem.php?pid=4267
using namespace std;
const int MAXN = 50005;
const int NN = 11*sizeof(int);
#define ll (root<<1)
#define rr (ll | 1)
#define lson l,m,ll
#define rson m+1,r,rr
#define mid m=(l+r)>>1
struct node
{
	int l, r;
	int sz[11];
}data[MAXN*3];
int num[MAXN], mmp[MAXN];
void build(int l, int r, int root)
{
	data[root].l = l; data[root].r = r;
	memset(data[root].sz, 0, NN);
	if (l == r) 
	{
		mmp[l] = root;
		return;
	}
	int mid;
	build(lson);
	build(rson);
}
void change(int c, int k, int x, int y, int l, int r, int root)
{
	if (x > y) return;
	if (x == l && y == r)
	{
		data[root].sz[k] += c;
		return;
	}
	int mid;
	if (y <= m) change(c,k,x,y,lson);
	else if (x > m) change(c,k,x,y,rson);
	else
	{
		change(c,k,x,m,lson);
		int a = (m-x)/k;
		change(c,k,x+(a+1)*k, y,rson);
	}
}
int getSum(int a, int root)
{
	int l = data[root].l;
	int res = 0;
	for (int i = 1; i< 11; ++i)
	{
		if ((a-l)%i == 0) res += data[root].sz[i];
	}
	if (root != 1) res += getSum(a,root>>1);
	return res;
}

int main() 
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	int n;
	while (scanf("%d", &n) != EOF)
	{
		for (int i = 1; i<= n; ++i) scanf("%d", num+i);
		build(1,n,1);
		int m;
		scanf("%d", &m);
		while (m--)
		{
			int t,a,b,k,c;
			scanf("%d", &t);
			if (t == 1)
			{
				scanf("%d%d%d%d", &a, &b, &k, &c);
				change(c,k,a,b,1,n,1);
			}
			else
			{
				scanf("%d", &a);
				printf("%d\n", num[a]+getSum(a,mmp[a]));
			}
		}
	}
    return 0;
}


deprecated_tzg
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【算法】线段树详解
_Alexander_的博客
08-20 5万+
线段树，是一种二叉搜索树。它功能强大，支持区间求和，区间最大值，区间修改，单点修改等操作。 它的时间复杂度是O(nlogn)的。 十分良心，欢迎阅读！
线段树合集
zero_orez6的博客
04-22 188
1.线段树基本概念及模板 2.线段树基础例题 3.线段树扩展操作——懒标记 4.线段树扩展操作——懒标记例题 待作者补充…
线段树详解
orz
05-20 9802
1. 什么是线段树 顾名思义 ， 线段树是一棵二叉树 ， 但不同的是这棵树的结点储存的值是一个数列中 [l,r][l,r][l,r] 的某个需要的值 （例如，求和，求最大值，求最小值） 这是一棵典型的线段树 ，其性质是 ： 若其中一子节点编号为 aaa ， 则该节点左儿子编号为 2a2a2a ， 其右儿子编号为 2a+12a+12a+1 2. 线段树的用处 线段树的用处就是，对编号连续的一些点进行修改或者统计操作，修改和统计的复杂度都是 O(log2n)O(log_2 n)O(log2​n). 3.
线段树（java）
lianggege88的博客
04-07 3087
线段树描述： 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。 例图如下： 代码实现如下：主要实现了线段树的构建，单点更新、区间和、最大值和一些测试用例 import java.util.Scanner; public class Xds { //线段树
什么是线段树
ThinPikachu的博客
04-04 1664
线段树的概念 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。 线段树的应用 线段树 segmentTree 是一个二叉树，每个结点保存数组 nums 在区间 [left, right] 的最...
李超线段树
weach的博客
07-29 3881
什么是李超线段树 先以一个问题引入： 在平面上有两种操作（强制在线）： 插入一条表达式为 L : y = k*x+b 的直线，给出 k ,b 。 给出 t，求当前所有直线中与直线 x = t 交点的纵坐标最大是多少 直线取 max 应该是得到一个下凸包，像这样（黑色的）： 李超线段树是什么？线段树，当然是要维护区间 [L , R] 的一个信息，李超线段树维护的就是中点处最高的直线 比如下图，区间 [ 0 , 4 ] 的中点 x = 2 的最高直线为红色直线 利用这一信息，可以在 O(log n )
动态开点线段树
qq_41673789的博客
10-29 9209
学了一个小知识点——动态开点。感觉挺有意思，对于线段树的短板：空间，有挺好的补足作用。 前置知识: 熟练掌握的[线段树]，最好了解一点点的[权值线段树] 线段树动态开点 在一些计数问题中，线段树用于维护值域(一段权值范围)，这样的线段树也称为权值线段树。为了降低空间复杂度，我们可以不建出整棵线段树的结构，而是在最初只建立一个根节点，代表整个区间，当需要访问线段树的某棵子树(某个子区间)时，再建立...
线段树详解 （原理，实现与应用）
热门推荐
岩之痕
09-09 13万+
线段树详解 By 岩之痕 一：综述 线段树是一种可以快速进行区间修改和区间查询的数据结构。点修改，区间修改和区间查询的复杂度都是O(log2(n)) 并且，线段树可以维护很多种类的信息。说到线段树就不得不提一下树状数组，树状数组维护的信息必须满足区间减法，因为树状数组只是维护1到X的信息，通过相减来得到区间信息，代码简单而且速度快，占用空间又少于线段树，所以一般情况下可以用树状数组的地方就
线段树练习题集
UncleJokerly
04-28 2209
线段树题目整合 1.hdu1166 敌兵布阵 更新节点,区间求和。 2.hdu1754 I Hate It 更新节点,区间最值. .3.hdu1698 Just a Hook 成段更新,总区间求和. .4.hdu1394 Minimum Inversion Number 更新节点,区间求和 .5.hdu1779（这个爆炸了，别做了） 成段更新,区间最值 .6.pku...
动态开点线段树说明
Practitioner
12-28 991
按顺序遍历这个 arr 数组，最小值 2 被取出，其原始位置是 4，且 4 号位置右侧没有比自己更小的数，接下来在开点线段树中把把 4 号位置的值加1，表示 4 号位置被处理过了，在线段树中查4号位置以后并没有任何标记记录，说明没有比这个数更小的数了，直接设置4号位置的ans值为0。接下来是 1 号位置的 8， 在线段树中，查到右侧有三个标记过的，说明有三个比它小的数，直接在 ans 中把 1 号位置设置为 3， 然后在线段树中把 1 号位置标记为 1 ，说明处理过，此时。
线段树建树
12-14
线段树是一种二叉树，也就是说，每个线段都可以用一二叉树表示 比如一个长度为4的线段可以如此表示： ——————————————-4 1————-2————-3————4 1 2 3 4 如果你要表示线段上的和，最上面的根...
线段树模板
02-03
手打了一份线段树代码，用于c++编程， 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的...
线段树_线段树_
10-01
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的...
线段树解题报告
01-03
H Moving Points 题目链接：...思路：树状数组维护，类似于树状数组求逆序对+思维（思维量很小） #include using namespace std; const int N = 2e5+9; typedef long long ll; struct node{ ...ll c1[N
C语言线段树讲解
06-15
C语言线段树讲解，C语言线段树讲解课件，C语言线段树讲解PPT
前18大旋转修整器企业占据全球87%的市场份额.docx
05-06
前18大旋转修整器企业占据全球87%的市场份额
Planet-SkySat-Imagery-Product-Specification-Jan2020.pdf
05-06
SKYSAT IMAGERY PRODUCT SPECIFICATION PLANET.COM VIDEO Full motion videos are collected between 30 and 120 seconds by a single camera from any of the active SkySats. Videos are collected using only the Panchromatic half of the camera, hence all videos are PAN only. Videos are packaged and delivered with a video mpeg-4 file, plus all image frames with accompanying video metadata and a frame index file (reference Product Types below)
Screenshot_20240506_133458_com.netease.yhtj.vivo.jpg
05-06
Screenshot_20240506_133458_com.netease.yhtj.vivo.jpg
2019年A~F题特等奖论文合集.pdf
最新发布
05-06
大学生，数学建模，美国大学生数学建模竞赛，MCM/ICM，历年美赛特等奖O奖论文
Python 线段树
10-06
Python中的线段树是一种用于解决区间查询问题的数据结构。线段树可以被看作是一棵二叉树，其中每个节点代表了一个区间。每个内部节点都有两个子节点，左子节点代表区间的左半部分，右子节点代表区间的右半部分。叶...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值