线段树合集 I

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

简介

基于个人对线段树的理解，线段树的核心思想就在于离散化和滞后性

hdu 1166 敌兵布阵（入门级）

hdu 1542 Atlantis

将线段离散化，自己一开始利用线段树将沿y坐标的矩阵归并可惜总是wa，最后借鉴了别人的方法

#include <cstdio>
#include <algorithm>
using namespace std;

const int MAXN = 5000;
double MM[MAXN];
double sum;
struct node 
{
    double len;
    int bz;
}data[MAXN<<2];

struct line
{
    double x1, x2, y;
    int typ;
    bool operator < (const line & a) const
    {
        if (y != a.y)    return y < a.y;
        return typ > a.typ;
    }
}mLine[MAXN*2];

#define ll (cnt<<1)
#define rr ((cnt<<1)|1)
#define lson l,m,ll
#define rson m,r,rr
#define mid m=(l+r)>>1

void build(int l, int r, int cnt)
{
    data[cnt].bz = 0;
    data[cnt].len = 0.0;
    if (l+1 == r) return;
    int mid;
    build(lson);
    build(rson);
}

void pushUP (int l, int r, int cnt )
{
    if (data[cnt].bz)
        data[cnt].len = MM[r] - MM[l];
    else
    {
        if (l+1 == r) data[cnt].len = 0.0;
        else
            data[cnt].len = data[ll].len + data[rr].len;
    }
}

void solve(int t, int x1, int x2, int l, int r, int cnt)
{
    if (x1 <= l && x2 >= r)
    {
        data[cnt].bz += t;
        pushUP(l, r, cnt);
        return;
    }
    if (l+1 == r) return;
    int mid;
    if (x1 < m) solve(t, x1, x2, lson);
    if (x2 > m) solve(t, x1, x2, rson);
    pushUP(l, r, cnt);
}
int n, m, d;
int mfind(double c)
{
    int p, q;
    p = 0;
    q = d - 1;
    while( p <= q )
    {
        int md=(p+q)/2;
        if(MM[md]==c)
            return md;
        if(MM[md]<c)
            p=md+1;
        else
            q=md-1;
    }
    return -1;
}
int main() 
{
    int cs = 0;
    while (scanf("%d", &n) != EOF && n)
    {
        m = 0;
        sum = 0.0;
        double x1, y1, x2, y2;
           for (int i = 0; i< n; ++i)
        {            
            scanf("%lf%lf%lf%lf", &x1, &y1, &x2, &y2);
            if ( (y2-y1)*(x2-x1) == 0.0) continue;
            line tp;
            tp.x1 = x1; tp.x2 = x2;
            tp.y = y1; tp.typ = 1;
            MM[m] = x1;
            mLine[m++] = tp;
            
            tp.y = y2; tp.typ = -1;
            MM[m] = x2;
            mLine[m++] = tp;
        }
        sort(mLine, mLine+m);
        sort(MM, MM+m);
        d = 1;
        for (int i = 1; i< m; ++i)
        {
            if (MM[i] != MM[d-1])
            {
                MM[d++] = MM[i];
            }
        }
        build(0, d-1, 1);
        for (int i = 0; i< m-1; ++i)
        {
            int a = mfind(mLine[i].x1);
            int b = mfind(mLine[i].x2);
            solve(mLine[i].typ, a, b, 0, d-1, 1);
            sum += data[1].len * (mLine[i+1].y - mLine[i].y);
        }
        printf("Test case #%d\n", ++cs);
        printf("Total explored area: %.2lf\n\n", sum);
    }
    return 0;
}


hdu 2795 Billboard

题目有个陷阱，实际上段数等于h和n的最小值就可以

#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <cstring>
#include <map>
#include <set>
#include <iostream>
#include <cmath>
using namespace std;
#ifdef __GNUC__
#define LL long long
#else
#define LL __int64
#endif

const int MAXN = 200005;
#define ll (cnt<<1)
#define rr ((cnt<<1)|1)
#define lson l,md,ll
#define rson md+1,r,rr
#define mid md=(l+r)>>1
int h, w, n; 
int mxNum[MAXN*3];
void build(int l, int r, int cnt)
{
	mxNum[cnt] = w;
	if (l == r) return;
	int mid;
	build(lson);
	build(rson);
}

int solve(int a, int l, int r, int cnt)
{
	if (l == r)
	{
		mxNum[cnt] -= a;
		return l;
	}
	int e;
	int mid;
	if (mxNum[ll] >= a)
	{
		e = solve(a, lson);
	}
	else
	{
		e = solve(a, rson);
	}
	mxNum[cnt] = max(mxNum[ll], mxNum[rr]);
	return e;
}
int main() 
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    while (scanf("%d%d%d", &h, &w, &n) != EOF)
    {
    	h = min(h, n);
    	build(1, h, 1);
    	while (n--)
    	{
	    	int a, b;
	    	scanf("%d", &a);
	    	if (a > mxNum[1]) b = -1;
	    	else
	    	{
	    		b = solve(a, 1, h, 1);
	    	}
	    	printf("%d\n", b);
	    }
    }
    return 0;
}


hdu 3308 LCIS

线段树合并，算是基础上的稍加变化

#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <cstring>
#include <map>
#include <set>
#include <iostream>
#include <cmath>
using namespace std;
// hdu 3308
#define ll (rot<<1)
#define rr (ll | 1)
#define mid mm = (l+r)>>1
#define lson l,mm,ll
#define rson mm+1,r,rr
const int MAXN = 100005<<2;
struct mNode
{
	int l, r;
	int lf, rt, md;
}node[MAXN];
int num[MAXN];
int n, m;
inline void solve(mNode *a, mNode *bl, mNode *br)
{
	a->md = max(bl->md, br->md);
	int mm = bl->r;
	if (num[mm] < num[1+mm])
	{
		int k = bl->rt + br->lf;
		a->md = max(a->md, k);
		if (bl->lf == (bl->r-bl->l+1))
		{
			a->lf = bl->lf + br->lf;
		}
		else
		{
			a->lf = bl->lf;
		}
		if (br->rt == (br->r-mm))
		{
			a->rt = bl->rt + br->rt;
		}
		else
		{
			a->rt = br->rt;
		}
	}	
	else
	{
		a->lf = bl->lf;
		a->rt = br->rt;
	}
}
void build(int l, int r, int rot)
{
	node[rot].l = l;
	node[rot].r = r;
	if (l == r)
	{
		node[rot].lf = node[rot].rt= node[rot].md = 1;
		return;
	}
	int mid;
	build(lson);
	build(rson);
	solve(node+rot, node+(ll), node+(rr));
}
void change(int a, int b, int l, int r, int rot)
{
	if (l == r)
	{
		num[l] = b;
		node[rot].lf = node[rot].rt= node[rot].md = 1;
		return;
	}
	int mid;
	if (a <= mm) change(a, b, lson);
	else change(a, b, rson);
	solve(node+rot, node+(ll), node+(rr));
}
mNode query(int x, int y, int l, int r, int rot)
{
	mNode res, a, b;
	if (x <= l && y >= r)
	{
		return node[rot];
	}
	int mid;
	if (y <= mm)
	{
		return query(x, y, lson);
	}
	if (x > mm)
	{
		return query(x, y, rson);
	}
	a = query(x, y, lson);
	b = query(x, y, rson);
	res.l = a.l; res.r = b.r;
	solve(&res, &a, &b);
	return res;
}
char c[5];
int main() 
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
	int t;
	scanf("%d", &t);
	while(t--)
	{
		scanf("%d%d", &n, &m);
		for(int i = 0; i< n; ++i)
		{
			int a;
			scanf("%d", num+i);
		}
		build(0, n-1, 1);
		while (m--)
		{
			int a, b;
			scanf("%s%d%d", c, &a, &b);
			if (c[0] == 'U')
			{
				change(a, b, 0, n-1, 1);
			}
			else
			{
				mNode res = query(a, b, 0, n-1, 1);
				printf("%d\n", res.md);
			}
		}
	}
    return 0;
}


hdu 4027 Can you answer these queries?

 

线段树应用，但题目的突破口是 2^63 最多被开方6次

#include <cstdio>
#include <vector>
#include <string>
#include <algorithm>
#include <queue>
#include <cstring>
#include <map>
#include <set>
#include <iostream>
#include <cmath>
using namespace std;
// hdu 4027
typedef __int64 LL;
#define ll (rot<<1)
#define rr (ll | 1)
#define mid mm = (l+r)>>1
#define lson l,mm,ll
#define rson mm+1,r,rr
const int MAXN = 100005<<2;
struct mNode
{
	LL all;
	int flg;
}data[MAXN];
LL num[MAXN];
void build(int l, int r, int rot)
{
	data[rot].flg = 0;
	if (l == r)
	{	
		data[rot].all = num[l];
		if (num[l] == 1) data[rot].flg = 1;
		return;
	}
	int mid;
	build(lson);
	build(rson);
	data[rot].all = data[ll].all + data[rr].all;
	data[rot].flg = data[ll].flg & data[rr].flg;
}
void add(int x, int y, int l, int r, int rot)
{
	if (data[rot].flg) return;
	if (l == r)
	{
		data[rot].all = (LL)sqrt(data[rot].all);
		if (data[rot].all == 1) data[rot].flg = 1;
		return;
	}	
	int mid;
	if (x <= mm) add(x, y, lson);
	if (y > mm) add(x, y, rson);
	data[rot].all = data[ll].all + data[rr].all;
	data[rot].flg = data[ll].flg & data[rr].flg;
}
LL query(int x, int y, int l, int r, int rot)
{
	LL sum = 0;
	if (x <= l && y >= r )
	{
		return data[rot].all;
	}
	int mid;
	if (x <= mm) sum += query(x, y, lson);
	if (y > mm) sum += query(x, y, rson);
	return sum;
}
int main() 
{
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
	int n, t = 0;
	while (scanf("%d", &n) != EOF)
	{
		printf("Case #%d:\n", ++t);
		for (int i = 1; i<= n; ++i)
		{
			scanf("%I64d", &num[i]);
		}
		build(1, n, 1);
		int k;
		scanf("%d", &k);
		while (k--)
		{
			int a, b, c, d, e;
			scanf("%d%d%d", &a, &d, &e);
			b = min(d, e);
			c = max(d, e);
			if (a == 0)
			{
				add(b, c, 1, n, 1);
			}
			else
			{
				printf("%I64d\n", query(b, c, 1, n, 1));
			}
		}
		puts("");
	}
    return 0;
}

hdu 3974 Assign the task

简单题 
#include <cstdio>
#include <iostream>
#include <cmath>
using namespace std;
/* 
	acm.hdu.edu.cn/showproblem.php?pid=3974
*/
const int MAXN = 50005*2;
#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 lf[MAXN], rt[MAXN], cnt;
struct Edge
{
	int v, next;
}edge[MAXN*2];
int head[MAXN], e, fa[MAXN];
int data[MAXN*2], sz[MAXN*2];
void m_init()
{
	memset(head, -1, sizeof head);
	memset(fa, -1, sizeof fa);
	e = cnt = 0;
}
void add(int u, int v)
{
	fa[v] = u;
	edge[e].v = v;
	edge[e].next = head[u];
	head[u] = e++;
}
void build(int l, int r, int root)
{
	data[root] = -1;
	sz[root] = 0;
	if (l == r) return;
	int mid;
	build(lson); build(rson);
}
void pushDown(int root)
{
	if (!sz[root]) return;
	sz[root] = 0;
	data[ll] = data[rr] = data[root];
	sz[ll] = sz[rr] = 1;
}
void change(int c, int x, int y, int l, int r, int root)
{
	if (x <= l && y >= r)
	{
		data[root] = c; sz[root] = 1;
		return;
	}
	pushDown(root);
	int mid;
	if (x <= m) change(c,x,y,lson);
	if (y > m) change(c,x,y,rson);
}
int query(int x, int l, int r, int root)
{
	if (l == r) return data[root];
	pushDown(root);
	int mid;
	if (x <= m) return query(x,lson);
	if (x > m) return query(x,rson);
}
void dfs(int u)
{
	lf[u] = cnt++;
	for (int i= head[u]; ~i; i = edge[i].next)
	{
		dfs(edge[i].v);
	}
	rt[u] = cnt-1;
}
char str[3];
int main() 
{
#ifndef ONLINE_JUDGE
	freopen("in.txt", "r", stdin);
#endif
	int t, cs = 0;
	int n, m;
	scanf("%d", &t);
	while (t--)
	{
		printf("Case #%d:\n", ++cs);
		m_init();
		scanf("%d", &n);
		for (int i = 1; i< n; ++i)
		{
			int v, u;
			scanf("%d%d", &v, &u);
			add(u,v);
		}
		int k;
		for (int i = 1; i<= n; ++i)
		{
			if (fa[i] == -1)
			{
				k = i;
				break;
			}
		}
		dfs(k);
		build(0, cnt-1, 1);
		scanf("%d", &m);
		while (m--)
		{
			int a, b;
			scanf("%s", str);
			if (str[0] == 'C')
			{
				scanf("%d", &a);
				printf("%d\n", query(lf[a],0,cnt-1,1));
			}
			else
			{
				scanf("%d%d", &a, &b);
				change(b, lf[a], rt[a], 0, cnt-1, 1);
			}
		}
	}
    return 0;
}


deprecated_tzg
关注
专栏目录
【算法】线段树详解
_Alexander_的博客
08-20 5万+
线段树，是一种二叉搜索树。它功能强大，支持区间求和，区间最大值，区间修改，单点修改等操作。 它的时间复杂度是O(nlogn)的。 十分良心，欢迎阅读！
线段树合集
zero_orez6的博客
04-22 213
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.
线段树（java）
lianggege88的博客
04-07 3192
线段树描述： 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，实际应用时一般还要开4N的数组以免越界，因此有时需要离散化让空间压缩。 例图如下： 代码实现如下：主要实现了线段树的构建，单点更新、区间和、最大值和一些测试用例 import java.util.Scanner; public class Xds { //线段树
什么是线段树
ThinPikachu的博客
04-04 1754
线段树的概念 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。 线段树的应用 线段树 segmentTree 是一个二叉树，每个结点保存数组 nums 在区间 [left, right] 的最...
李超线段树
weach的博客
07-29 4177
什么是李超线段树 先以一个问题引入： 在平面上有两种操作（强制在线）： 插入一条表达式为 L : y = k*x+b 的直线，给出 k ,b 。 给出 t，求当前所有直线中与直线 x = t 交点的纵坐标最大是多少 直线取 max 应该是得到一个下凸包，像这样（黑色的）： 李超线段树是什么？线段树，当然是要维护区间 [L , R] 的一个信息，李超线段树维护的就是中点处最高的直线 比如下图，区间 [ 0 , 4 ] 的中点 x = 2 的最高直线为红色直线 利用这一信息，可以在 O(log n )
动态开点线段树
qq_41673789的博客
10-29 1万+
学了一个小知识点——动态开点。感觉挺有意思，对于线段树的短板：空间，有挺好的补足作用。 前置知识: 熟练掌握的[线段树]，最好了解一点点的[权值线段树] 线段树动态开点 在一些计数问题中，线段树用于维护值域(一段权值范围)，这样的线段树也称为权值线段树。为了降低空间复杂度，我们可以不建出整棵线段树的结构，而是在最初只建立一个根节点，代表整个区间，当需要访问线段树的某棵子树(某个子区间)时，再建立...
线段树练习题集
UncleJokerly
04-28 2295
线段树题目整合 1.hdu1166 敌兵布阵 更新节点,区间求和。 2.hdu1754 I Hate It 更新节点,区间最值. .3.hdu1698 Just a Hook 成段更新,总区间求和. .4.hdu1394 Minimum Inversion Number 更新节点,区间求和 .5.hdu1779（这个爆炸了，别做了） 成段更新,区间最值 .6.pku...
线段树 从入门到进阶（超清晰，简单易懂）
热门推荐
繁凡さん的博客
02-12 8万+
目录第一部 概念引入第二部 简单（无pushdown）的线段树1、单点修改，区间查询2、区间修改，单点查询第三部 进阶线段树第四部 乘法（根号）线段树1、乘法线段树2、根号线段树模板题与代码：单点修改，区间查询：洛谷树状数组模板1区间修改，单点查询：洛谷树状数组模板2区间加法，洛谷线段树模板1区间乘法：洛谷线段树模板2区间根号，bzoj3211 线段树是什么？？线段树怎么写？？ 如果你在考提高组前...
动态开点线段树说明
Practitioner
12-28 1223
按顺序遍历这个 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++编程， 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 使用线段树可以快速的查找某一个节点在若干条线段中出现的...
线段树
03-26
线段树，是一种数据结构，主要用于高效地处理区间（或线段）上的查询与修改操作。在计算机科学中，线段树通常用于解决区间最值、区间加减、区间求和等问题，它通过将问题分解成更小的部分来实现快速响应。线段树的...
线段树的一种实现
12-25
线段树是一种高效的数据结构，常用于处理区间查询与更新问题。它的核心思想是将一个一维数组通过分治策略转化为一棵二叉树，每个节点代表一个区间的值，这棵树通常具有平衡性质，比如平衡二叉搜索树的特性。线段树在...
线段树_线段树_
10-01
线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的...
基于JavaScript和HTML的前端私教课程设计源码
09-24
该项目是一个基于JavaScript和HTML的前端私教课程设计源码，主要使用JavaScript语言开发。项目共包含54个文件，其中33个JavaScript文件，7个HTML文件，6个Markdown文件，4个Java文件，2个PDF文件，1个JSON文件，1个YAML文件。该课程设计旨在提供高效的前端学习资源。
嵌入式学习之光照不足报警检测电路.zip
09-24
嵌入式学习，电子信息技术
python1Python脚本 模拟登录知乎， 爬虫，操作excel，微信公众号，远程开机PGL.zip
最新发布
09-24
[python1]Python脚本。模拟登录知乎， 爬虫，操作excel，微信公众号，远程开机【PGL】.zip [python1]Python脚本。模拟登录知乎， 爬虫，操作excel，微信公众号，远程开机【PGL】.zip [python1]Python脚本。模拟登录知乎， 爬虫，操作excel，微信公众号，远程开机【PGL】.zip
基于C语言的思维车载设备OTA升级模块设计源码
09-24
该项目是基于C语言的思维车载设备OTA升级模块设计源码，包含42个文件，其中包括16个头文件（.h）、15个源文件（.c）、3个JSON配置文件、1个Git忽略文件、1个主Makefile文件、1个构建目录、1个Markdown文档以及多个子目录下的Makefile文件。该模块专为思维车载设备设计，实现了一键OTA升级功能，提高了设备的维护效率和用户体验。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值