【计几】线段树+扫描线

最新推荐文章于 2023-07-31 08:38:44 发布
最新推荐文章于 2023-07-31 08:38:44 发布
阅读量188 收藏
点赞数
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51948235/article/details/120640146
版权

这一块没有复习，先扔这日后完善。

线段树学习

为什么开4*N空间？

为什么查询操作时间为 O ( 4 ∗ l o g 2 n ) O(4*log_2{n}) O(4∗log2​n) ？

  • 从第二层开始，每个区间（最多有两个）都会被分为两块，其中一块继续向下递归，另一块return。 因为有 l o g 2 n log_2{n} log2​n 层，因此时间为 O ( 2 ∗ l o g 2 n + 2 ∗ l o g 2 n ) O(2*log_2{n} + 2*log_2{n}) O(2∗log2​n+2∗log2​n) 。

在这里插入图片描述

关于build函数和modify函数：

  • 进入函数后分为两类：是否到达叶节点。否则递归两个孩子或者其中一个。

关于query函数：

  • 我们要保证从主函数或递归进入query函数时，下一节点的区间和查询区间有交集，否则不进入下一层query。
  • 进入函数后分为四类：完全被查询区间覆盖（1种），部分被查询区间覆盖（3种）。
  • query返回类型可以看作在此节点，对查询区间[l,r]的数据的整合后返回的对象。因此在Acwing245中就可以返回node，看作孩子节点在[l,r]内的有效范围的一个整合。

Acwing245-你能回答这些问题吗

#include<iostream>
#include<cstdio>
#include<vector>
#include<map>
using namespace std;

const int N=5e5 + 10;
typedef long long LL;

struct node{
    int l, r;
    int tmax, lmax, rmax, sum;
}tr[4 * N];

void pushup(node & a, node & b, node & c){
    a.sum = b.sum + c.sum;
    a.lmax = max(b.lmax, b.sum + c.lmax);
    a.rmax = max(c.rmax, c.sum + b.rmax);
    a.tmax = max(max(b.tmax, c.tmax), b.rmax + c.lmax);
}
void pushup(int u){
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}
void build(int u, int l, int r)
{
    tr[u] = {l, r};
    if(l == r) return ;
    int mid = l + r >> 1;
    build(u << 1, l, mid);
    build(u << 1 | 1, mid + 1, r);
}
node query(int u, int l, int r)
{
    if(tr[u].l >= l && tr[u].r <= r) return tr[u];
    int mid = tr[u].l + tr[u].r >> 1;
    if(r <= mid) return query(u << 1, l, r);
    else if(l >= mid + 1) return query(u << 1 | 1, l, r);
    else{
        node left = query(u << 1, l, r);
        node right = query(u << 1 | 1, l, r);
        node now; pushup(now, left, right);
        return now;
    }
}
void modify(int u, int x, int tmax)
{
    if(tr[u].l == tr[u].r) tr[u] = {x, x, tmax, tmax, tmax, tmax};
    else{
        int mid = tr[u].l + tr[u].r >> 1;
        if(x <= mid) modify(u << 1, x, tmax);
        else modify(u << 1 | 1, x, tmax);
        pushup(u);
    }
}

int main()
{
    int n, m, x, op, y; scanf("%d %d", &n, &m);
    build(1, 1, n);
    for(int i=1; i<=n; i++)
    {
        scanf("%d", &x);
        modify(1, i, x);
    }
    while(m--)
    {
        scanf("%d %d %d", &op, &x, &y);
        if(op == 1)
        {
            if(x > y) swap(x, y);
            printf("%d\n", query(1, x, y).tmax);
        }
        else modify(1, x, y);
    }

    system("pause");

    return 0;
}

Acw246-区间最大公约数

  • 原序列的最大公约数等于等差序列的最大公约数，因此维护等差序列。
  • 相当于区间修改，单点查询。
#include<iostream>
#include<cstdio>
#include<vector>
#include<map>
using namespace std;

const int N=5e5 + 10;
typedef long long LL;

struct node{
    LL l, r;
    LL sum, d;
}tr[4 * N];
LL w[N];

LL gcd(LL a, LL b){
    if(!b) return a;
    return gcd(b, a % b);
}

void pushup(node & a, node & b, node & c){
    a.sum = b.sum + c.sum;
    a.d = gcd(b.d, c.d);
}
void pushup(int u){
    pushup(tr[u], tr[u << 1], tr[u << 1 | 1]);
}
void build(int u, int l, int r)
{
    if(l == r) tr[u] = {l, r, w[l] - w[l - 1], w[l] - w[l - 1]};
    else{
        tr[u] = {l, r};
        int mid = l + r >> 1;
        build(u << 1, l, mid);
        build(u << 1 | 1, mid + 1, r);
        pushup(u);
    }
}
node query(int u, int l, int r)
{
    if(tr[u].l >= l && tr[u].r <= r) return tr[u];
    int mid = tr[u].l + tr[u].r >> 1;
    if(r <= mid) return query(u << 1, l, r);
    else if(l >= mid + 1) return query(u << 1 | 1, l, r);
    else{
        node left = query(u << 1, l, r);
        node right = query(u << 1 | 1, l, r);
        node now; pushup(now, left, right);
        return now;
    }
}
void modify(int u, int x, LL d)
{
    if(tr[u].l == x && tr[u].r == x){
        LL t = tr[u].sum + d;
        tr[u] = {x, x, t, t};
    }
    else{
        int mid = tr[u].l + tr[u].r >> 1;
        if(x <= mid) modify(u << 1, x, d);
        else modify(u << 1 | 1, x, d);
        pushup(u);
    }
}

int main()
{
    int n, m, l, r; scanf("%d %d", &n, &m);
    char op; LL d;
    for(int i=1; i<=n; i++) scanf("%lld", &w[i]);
    build(1, 1, n);
    while(m--)
    {
        scanf(" %c %d %d", &op, &l, &r);
        if(op == 'C')
        {
            scanf("%lld", &d);
            modify(1, l, d);
            if(r + 1 <= n) modify(1, r + 1, -d);
        }else
        {
            node left = query(1, 1, l);
            if(l == r){
                printf("%lld\n", llabs(left.sum));
            }else{
                node right = query(1, l + 1, r);
                printf("%lld\n", llabs(gcd(left.sum, right.d)));
            }
        }
    }

    system("pause");

    return 0;
}

#10129. 「一本通 4.3 练习 3」维护序列

问题：动态加和动态乘结合起来怎么做？

思路：先乘后加，就容易得到懒标记的递推式，按照递推式pushdown即可。

代码：https://loj.ac/s/1249505

扫描线 + 线段树

一维扫描线：扫描线Sweep Line算法总结

二维扫描线：

文章：一文读懂扫描线算法

题目：Acwing-247亚特兰蒂斯

关于不用pushdown的思考：

  • 一：可以不用pushdown就可以：如果问的是至少覆盖一次的区间长度，那么一个节点对应的区间 1. 只要被完全覆盖一次及以上，其两个孩子区间就不用考虑了。左边界一定要等到另一个和他配对的右边界到来才会消失，期间不可能出现空洞。 2. 没有被完全覆盖，要考虑孩子区间，有效区间从孩子区间转移过来。https://www.acwing.com/solution/content/1051/
  • 二：为什么使用普通线段树区间修改的pushdown会错呢？：我们写普通线段树区间修改时，pushdown都不需要使用孩子区间来更新父亲区间，修改信息更新到此区间即可，不向下更新。但是在这道题里面，pushdown要用到孩子区间来更新此区间，就会造出现使用未更新的信息的情况。因此这里会出错。

AC代码：

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

typedef long long LL;
const int N=1e4 + 10;

double y[N * 2];
int pos;
int find(double k) { return lower_bound(y, y + pos, k) - y; }

struct Seg{
	double x, y1, y2;
	int k;
	bool operator < (const Seg & a) const { return x < a.x; }
}seg[N * 2];

struct node{
	int l, r;
	int cnt;
	double len;
}tr[N * 8];

void pushup(int u)
{
	if(tr[u].cnt) tr[u].len = y[tr[u].r] - y[tr[u].l];
	else if(tr[u].l != tr[u].r - 1) tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
	else tr[u].len = 0;
}
void build(int u, int l, int r)
{
	if(l == r - 1) tr[u] = {l, r, 0, 0};//这里的叶子区间是两个相邻y之间的区间，而不是单点。例：[2，3]
	else{
		tr[u] = {l, r, 0, 0};
		int mid = l + r >> 1;
		build(u << 1, l, mid); build(u << 1 | 1, mid, r);
	}
}
void modify(int u, int l, int r, int k)
{
	if(tr[u].l >= l && tr[u].r <= r)
	{
		tr[u].cnt += k;
		pushup(u);
	}else{
		int mid = tr[u].l + tr[u].r >> 1;
		if(l < mid) modify(u << 1, l, r, k);
		if(r > mid) modify(u << 1 | 1, l, r, k);
		pushup(u);
	}
}


int main()
{
	int n, T = 1;
	while(scanf("%d", &n), n)
	{
		double x1, y1, x2, y2;
		for(int i=0; i<n; i++)
		{
			scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);
			y[i << 1] = y1, y[i << 1 | 1] = y2;
			seg[i << 1] = {x1, y1, y2, 1}; seg[i << 1 | 1] = {x2, y1, y2, -1};
		}
		sort(y, y + 2 * n); sort(seg, seg + 2 * n);
		pos = unique(y, y + 2 * n) - y;
		build(1, 0, pos - 1);

		double res = 0;
		for(int i=0; i<2 * n; i++)
		{
			if(i) res += (seg[i].x - seg[i - 1].x) * tr[1].len;
			modify(1, find(seg[i].y1), find(seg[i].y2), seg[i].k);
		}
		printf("Test case #%d\nTotal explored area: %.2f\n\n", T++, res);
	}
	

	system("pause");
	return 0;
}

hdu 1255 覆盖的面积

题解：https://www.cnblogs.com/scau20110726/archive/2013/04/14/3020998.html

思路：题解讲的非常好了。

  • 在Atlantis题目中，cnt定义为节点代表区间被完全覆盖的次数，len定义为被覆盖了一次或以上的长度。

  • 而在此题中，len1表示该该区间内被覆盖了1次或以上的长度，len2表示被覆盖了2次或以上的长度

  • 其中的pushup操作类似于状态转移方程。

  • 在Atlantis题目中，一个节点对应的区间 1. 只要被完全覆盖一次及以上，其两个孩子区间就不用考虑了。左边界一定要等到另一个和他配对的右边界到来才会消失，期间不可能出现空洞。2. 没有被完全覆盖，要考虑孩子区间，有效区间从孩子区间转移过来。

  • 但是在此题中，有可能出现被完全覆盖，但是也要考虑孩子区间的情况，即非叶节点cnt=1。此时要好好考虑怎么去转移。

AC代码：

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

const int N=1010;
typedef long long LL;

double y[N * 2];
int pos;
int find(double k) { return lower_bound(y, y + pos, k) - y; }

struct Seg{
	double x, y1, y2;
	int k;
	bool operator < (const Seg & a) const { return x < a.x; }
}seg[N * 2];

struct node{
	int l, r, cnt;
	double len1, len2;
}tr[N * 8];

void build(int u, int l, int r)
{
	if(l == r - 1) tr[u] = {l, r, 0, 0, 0};
	else{
		tr[u] = {l, r, 0, 0, 0};
		int mid = l + r >> 1;
		build(u << 1, l, mid); build(u << 1 | 1, mid, r);
	}
}
void pushup(int u)
{
	if(tr[u].cnt >= 2) tr[u].len2 = tr[u].len1 = y[tr[u].r] - y[tr[u].l];
	else if(tr[u].l == tr[u].r - 1)
	{
		if(tr[u].cnt) tr[u].len1 = y[tr[u].r] - y[tr[u].l];
		else tr[u].len1 = 0;
		tr[u].len2 = 0;
	}else
	{
		if(tr[u].cnt){
			tr[u].len1 = y[tr[u].r] - y[tr[u].l];
			tr[u].len2 = tr[u << 1].len1 + tr[u << 1 | 1].len1;
		}
		else{
			tr[u].len1 = tr[u << 1].len1 + tr[u << 1 | 1].len1;
			tr[u].len2 = tr[u << 1].len2 + tr[u << 1 | 1].len2;
		}
	}
}
void modify(int u, int l, int r, int k)
{
	if(tr[u].l >= l && tr[u].r <= r)
	{
		tr[u].cnt += k;
		pushup(u);
	}else{
		int mid = tr[u].l + tr[u].r >> 1;
		if(l < mid) modify(u << 1, l, r, k);
		if(r > mid) modify(u << 1 | 1, l, r, k);
		pushup(u);
	}
}

int main()
{
	int T; scanf("%d", &T);
	while(T--)
	{
		int n; scanf("%d", &n);
		double x1, x2, y1, y2;
		for(int i=0; i<n; i++)
		{
			scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);
			y[i << 1] = y1; y[i << 1 | 1] = y2;
			seg[i << 1] = {x1, y1, y2, 1}; seg[i << 1 | 1] = {x2, y1, y2, -1};
		}
		sort(y, y + 2 * n); sort(seg, seg + 2 * n);
		pos = unique(y, y + 2 * n) - y;
		build(1, 0, pos - 1);

		double ans = 0;
		for(int i=0; i<2 * n; i++)
		{
			if(i) ans += (seg[i].x - seg[i - 1].x) * tr[1].len2;
			modify(1, find(seg[i].y1), find(seg[i].y2), seg[i].k);
		}
		printf("%.2f\n", ans);
	}

	system("pause");
	return 0;
}

hdu-1828 Picture

思路：板子题，当区间变化时，变化的长度大小累加起来就是答案，横竖扫一遍。

注意有个坑，两个矩形有一条边重叠，这条边并入矩形并集。那么按以前的扫描线就会出问题。

解决：我们在对seg排序的时候特殊一点，横坐标相同的时候，把入区间排在前面，出区间排在后面，就可以避免先出后入造成的bug。

在这里插入图片描述

AC代码：

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

const int N=5010;
typedef long long LL;

int y[N * 2];
int pos;
int find(int k) { return lower_bound(y, y + pos, k) - y; }

struct Seg{
	int x, y1, y2;
	int k;
	bool operator < (const Seg & a) const{
		if(x != a.x) return x < a.x;
		return k > a.k;
	}
}seg[N * 2];

struct node{
	int l, r, cnt;
	int len;
}tr[N * 8];

void build(int u, int l, int r)
{
	if(l == r - 1) tr[u] = {l, r, 0, 0};
	else{
		tr[u] = {l, r, 0, 0};
		int mid = l + r >> 1;
		build(u << 1, l, mid); build(u << 1 | 1, mid, r);
	}
}
void pushup(int u)
{
	if(tr[u].cnt) tr[u].len = y[tr[u].r] - y[tr[u].l];
	else if(tr[u].l == tr[u].r - 1) tr[u].len = 0;
	else tr[u].len = tr[u << 1].len + tr[u << 1 | 1].len;
}
void modify(int u, int l, int r, int k)
{
	if(tr[u].l >= l && tr[u].r <= r)
	{
		tr[u].cnt += k;
		pushup(u);
	}else{
		int mid = tr[u].l + tr[u].r >> 1;
		if(l < mid) modify(u << 1, l, r, k);
		if(r > mid) modify(u << 1 | 1, l, r, k);
		pushup(u);
	}
}

pair<int, int>p1[N], p2[N];
int n;

LL sol()
{
	int x1, x2, y1, y2;
	for(int i=0; i<n; i++)
	{
		x1 = p1[i].first, y1 = p1[i].second; x2 = p2[i].first, y2 = p2[i].second;
		y[i << 1] = y1; y[i << 1 | 1] = y2;
		seg[i << 1] = {x1, y1, y2, 1}; seg[i << 1 | 1] = {x2, y1, y2, -1};
	}

	sort(y, y + 2 * n); sort(seg, seg + 2 * n);
	pos = unique(y, y + 2 * n) - y;
	build(1, 0, pos - 1);

	LL ans = 0, last = 0;
	for(int i=0; i<2 * n; i++)
	{
		modify(1, find(seg[i].y1), find(seg[i].y2), seg[i].k);
		ans += llabs(last - tr[1].len);
		last = tr[1].len;
		// cout<<"## "<<tr[1].len<<endl;
	}
	return ans;
}


int main()
{
	while(scanf("%d", &n)!=EOF)
	{
		if(!n) { cout<< 0 <<endl; continue; }

		for(int i=0; i<n; i++) scanf("%d %d %d %d", &p1[i].first, &p1[i].second, &p2[i].first, &p2[i].second);

		LL ans = sol();

		for(int i=0; i<n; i++) swap(p1[i].first, p1[i].second), swap(p2[i].first, p2[i].second);

		ans += sol();

		printf("%lld\n", ans);
	}

	system("pause");
	return 0;
}
/*hack
2
5 4 9 15
9 2 11 14

WA.out
58

AC.out
38
*/

P1502 窗口的星星

思路：洛谷题解大概都有了。每一个星星对应一个带权矩形，权值可累加，然后求平面上最大的点权。

对过去学习的思考：

为什么求矩形面积并不用pushdown呢：

  • 之前有写，普通pushdown一般不会用孩子区间更新此区间，但是矩形面积并写pushdown要使用孩子节点的信息，就会出现使用未更新的信息的情况。

为什么这道题要用pushdown呢？

  • 这道题要求的是区间最大点权，即信息属性为max，就不能利用矩形面积并的特殊属性——某区间被覆盖就不用考虑孩子区间。而要老老实实的写pushdown。

AC代码：

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

const int N=1e4 + 10;
typedef long long LL;

int y[N * 2];
int pos;
int find(int k) { return lower_bound(y, y + pos, k) - y; }

struct Seg{
	int x, y1, y2;
	LL k;
	bool operator < (const Seg & a) const{
		if(x != a.x) return x < a.x;
		return k > a.k;
	}
}seg[N * 2];

struct node{
	int l, r;
	LL v, add;
}tr[N * 8];

void build(int u, int l, int r)
{
	if(l == r) tr[u] = {l, r, 0, 0};
	else{
		tr[u] = {l, r, 0, 0};
		int mid = l + r >> 1;
		build(u << 1, l, mid); build(u << 1 | 1, mid + 1, r);
	}
}
void pushup(int u)
{
	tr[u].v = max(tr[u << 1].v, tr[u << 1 | 1].v);
}
void pushdown(int u)
{
	if(tr[u].add)
	{
		auto & a = tr[u], & b = tr[u << 1], & c = tr[u << 1 | 1];
		b.add += a.add; c.add += a.add;
		b.v += a.add; c.v += a.add;
		a.add = 0;
	}
}
void modify(int u, int l, int r, LL add)
{
	if(tr[u].l >= l && tr[u].r <= r)
	{
		tr[u].v += add;
		tr[u].add += add;
	}else{
		pushdown(u);
		int mid = tr[u].l + tr[u].r >> 1;
		if(l <= mid) modify(u << 1, l, r, add);
		if(r >= mid + 1) modify(u << 1 | 1, l, r, add);
		pushup(u);
	}
}


int main()
{
	int T; scanf("%d", &T);
	while(T--)
	{
		int n, W, H; scanf("%d %d %d", &n, &W, &H);
		if(W == 1 || H == 1) { printf("0\n"); continue; }
		int xx, yy, l;
		for(int i=0; i<n; i++)
		{
			scanf("%d %d %d", &xx, &yy, &l);
			y[i << 1] = yy, y[i << 1 | 1] = yy + H - 1;
			seg[i << 1] = {xx, yy, yy + H - 1, l}; seg[i << 1 | 1] = {xx + W - 1, yy, yy + H - 1, -l};
		}
		// for(int i=0; i<2 * n; i++) cout<<"## "<<y[i]<<endl;
		sort(y, y + 2 * n); sort(seg, seg + 2 * n);
		pos = unique(y, y + 2 * n) - y;

		build(1, 0, pos - 1);

		LL ans = -9e18;
		for(int i=0; i<2 * n; i++)
		{
			modify(1, find(seg[i].y1), find(seg[i].y2), seg[i].k);
			ans = max(ans, tr[1].v);
			// cout<<"# "<<tr[1].v<<" "<<tr[2].v<<" "<<tr[3].v<<endl;
		}
		printf("%lld\n", ans);
	}

	system("pause");
	return 0;
}

1559 车和矩形

又是一道不看题解做不出来的题。

题解：- 51nod 1559 车和矩形

ZhgDgE
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线段树的区间修改
m0_63729880的博客
09-28 739
线段树之区间修改
线段树+扫描线
最新发布
m0_73494480的博客
01-31 1982
其中，将这个图形进行分割的四条线我们就称为分割线，为了快速计算出截线段长度，可以将横边赋上不同的权值，具体为：对于一个矩形，其下边权值为1，上边权值为−1。那么问题就是实现这样的效果是十分困难，因为并不能很好的确定这条扫描线每次具体移动多远，但是，我们观察可以知道，并不是需要边扫边计算，只需要当扫描线遇到矩形的底边或顶边时，进行计算这段过程扫过的面积即可。表示这条扫描线是矩形的下面的一条边还是上面的一条边，由于题中会告诉我们矩形的左下角坐标和右上角坐标，因此很容易得到两条切割线，{
扫描线 二维数点
William_Wang_的博客
07-31 265
扫描线
线段树的区间修改操作poj3468
sunnyorrainy的博客
09-21 179
题意：给一个数组，进行区间修改和求和操作。 线段树区间修改，直接放线段树咬，但是很多的细节需要注意。 千万不能upate(L,mid,2*k,val);update(mid+1,R,2*k+1,val).会改变目标区间的值。 比如n=10，修改区间（3，6） 1，左边：目标区间变为（3，5），树的区间为（1，5） 右边：目标区间变为（6，6）树的区间变为（6，10） 2, 左边...
二维区域扫描线填充算法的实现
Alex的学习之路
07-12 1万+
                                                           二维区域扫描线填充算法的实现  这个程序从一放暑假就开始做，直做到今天，花了1个星期的时间，真是不应该啊，唉，谁让咱编程技术不太好呢，得，闲话少说。  关于区域填充，我们常用的算法有扫描线填充算法以及种子填充算法，我现在只完成了前一种，后一种等过两天实现之，扫描算法的理解不难，可是
线段树之扫描线
05-20
自己参考资料整理出来的ppt，讲解还算比较细致，如有不妥之处请批评指正
权值线段树及扫描线学习笔记
12-25
权值线段树及扫描线学习笔记
线段树矩形面积并讲解
02-09
ACM中对于矩形面积并用线段树+离散化+ 扫描线一类问题求解
线段树六题
06-06
著名的线段树六题 囊括线段树整个知识点， 十分实用 当年凭借此六题， NOIP+NOI秒杀线段树题
关于扫描线的学习研究代码
11-27
扫描线扫描线： 下面是来自soar转载的一篇博客。 这篇博客解决了我对算区间长度时的不理解。...线段树的典型扫描线用法. 首先假设有下图两个矩阵,我们如果用扫描线的方法如何计算它们的总面积呢?
线段树 扫描线
Black__wing的博客
08-15 1127
例题HDU-1542-Atlantis： 扫描线的题就是求在一个二维平面上，多个矩形的覆盖面积，那么这个面积如何用线段树来维护呢？ 下面解析请配合代码食用。 我们可以知道，线段树对于区间修改，求和上时间复杂度很低，因此，我们就用线段树来维护，x轴上我们需要的区间长度。 如图我们想要求的三个矩形的坐标 我们将它们画出来是这样的: 那么我们线段树维护的就是1-2,2-3,3-4,4...
线段树 + 扫描线加深详解
qq_18661257的专栏
08-14 4358
在线段树中的扫描线主要是解决矩形面积以及周长问题，比如下图 让你求解所有矩形覆盖的面积和，或者是周长和，如果用寻常的方法，非常之麻烦，而且效率也不高，这里就会用到线段树的扫描线 扫描线应对方案： 由于题目提供的矩形比较多，坐标也很大，所以坐标需要离散化，可以按照题目要求或者自己的喜好，离散横坐标或者纵坐标都可以，这里讲的都是离散横坐标，不离散纵坐标 假设
[线段树] (线段树 + 扫描线 + 离散化)
yyy_3y的博客
02-25 730
POJ 1151 &amp;&amp; HDU 1542 Atlantis 做模板 #include&lt;cstdio&gt; #include&lt;cstring&gt; #include&lt;algorithm&gt; #include&lt;vector&gt; #include&lt;queue&gt; #include&lt;cmath&gt; using namespa
线段树+扫描线（有关扫描线的理解）
热门推荐
20164225的博客
10-12 2万+
扫描线： 下面是来自soar转载的一篇博客。 这篇博客解决了我对算区间长度时的不理解。实际上这个线段树的叶子节点保存的是这个点x坐标到下一个x坐标（排序后的）的区间长度。 题意: 二维平面有n个平行于坐标轴的矩形,现在要求出这些矩形的总面积. 重叠部分只能算一次. 分析: 线段树的典型扫描线用法.        首先假设有下图两个矩阵,我们如果用扫描线的方法如何计算它们的总面积呢? ...
扫描线总结【线段树特殊性质，没有pushdown、query操作】
谁是凶手1703
10-13 262
扫描线 题意 多个矩阵求交集，线段树的特殊操作，非常特殊的情况，一堆证明之后，就没有pushdown操作。 没有pushdown操作，也没有query操作，直接tr[1].len. 亚特兰蒂斯 由于点可能有小数，先l、离散化为整数，这里的线段树存的是一个区间：【L，R），左闭右开的区间。 换句话：线段树存的是第几个小区间，那么操作(l,r)的话，对线段树操作：l–r-1就够了，（存的不是点，是小区间，小区间比点的数量少1） 另外，也不需要query（）函数，之间调用tr[1].len,返回线段长度 代码 #
线段树+扫描线（基本原理）
konghhhhh的博客
10-14 5877
这一部分是线段树的一个难点了，这写天做了这么多的这方面的题，一直是稀里糊涂的搞不太明白，但是又得理解，看到了一个别人转载的讲解，贴在这里以便回顾（侵删）。   扫描线法：       假想有一条扫描线，从左往右（从右往左），或者从下往上（从上往下）扫描过整个多边形（或者说畸形。。多个矩形叠加后的那个图形）。如果是竖直方向上扫描，则是离散化横坐标，如果是水平方向上扫描，则是离散化纵坐
Jzoj P4238 纪念碑___线段树+扫描线
生如夏花之绚烂
01-30 209
题目大意： 一个长为nnn,宽为mmm的矩形.它由n∗mn* mn∗m个1∗11*11∗1的正方形组成。 左下角的正方形的坐标为(1,1)(1,1)(1,1), 右上角的正方形的坐标为(n,m)(n, m)(n,m)。 有ppp片土地被用来修建建筑，,每一个建筑可以看做是一个左下角为(x1,y1)(x1,y1)(x1,y1),右上角为(x2,y2)(x2,y2)(x2,y2)的矩形。 问能在这个n...
离散化-线段树-扫描线小结
xbb0720的博客
09-25 536
昨天打了南宁赛区的网络赛，碰到一个求矩形并的面积的模板题，然而没A出来(不会啊)。以前也碰到过类似线段树+扫描线的题目，只能怪自己以前没补题吧哎~。 关于这个知识点，网上随便一搜就能搜到大堆，就说一下我在学习的过程中碰到的问题。 一：首先是离散化，定义就不说了(其实不知道2333)，我笼统地理解就是把大的数据范围缩小，同时又保证数据之间地关系不变，比如说坐标的大小，如果给你一些点，你需要的属性
线段树 扫描xian 万门
04-07
万门算法是一种基于线段树和扫描线的算法，用于解决多维度的区间查询问题。它的主要思想是将每个维度上的区间分别按照左端点和右端点排序，然后按照某一维度的顺序依次处理每个端点。在处理每个端点时，可以将与当前...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值