扫描线算法

于 2025-06-14 13:06:27 发布
阅读量322 收藏 8
点赞数 4
CC 4.0 BY-SA版权
文章标签： 算法 开发语言 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2403_87663181/article/details/148651367

扫描线算法

14.油漆面积 - 蓝桥云课

扫描线算法：

扫描线算法可以解决多个矩形重合求卖面积或周长

在这里插入图片描述

如何求彩色部分的面积呢

1 > 暴力 ：

​ 模拟 n*n 的表格遍历每个格子，数据一多肯定是吃不消的

2 > 扫描线

​ 用一根假想的线扫过整个平面，遇到图形的边界就更新当前覆盖的区域，同时累加面积。

​ 大体步骤： 1>把每个矩形拆除左边界( +1 )，右边界( -1)。

​ 2>对x进行排序

​ 3>扫描

  • 从左到右移动扫描线，遇到“左边界”就把对应的区间标记为被覆盖，遇到“右边界”就取消覆盖。
  • 每次移动扫描线时，计算当前被覆盖的总长度 × 移动的距离，累加到总面积中。
  • 在这里插入图片描述

3 > 用线段树快速计算当前被覆盖的总高度。就类似与用线段树求解线段和

代码实现

线段树的实现

struct segNode {  // 线段树节点的类型
	int l, r;  // 垂直与 x 轴的左边界和右边界
	int len;   // 线段的长度
	int cnt;   // 线端被完全覆盖的数目
};
class SegmentTree {
private :
			
	void build(int u,int l,int r);   // 初始化线段树
	void push_up(int u) ;  // 向上更新节点 
public  :
	vector<segNode> nodes;      // 线段节点
	     
    SegmentTree(int N) {      // 构造函数 参数 N 是整个线段的(y轴)长度不是线段的个数
		nodes.resize(N << 2); // 线段树需要 4 倍的空间
		build(1,0,N);    // 以 nodes[1] 为头节点
	}
	void modify(int u,int l,int r,int d);       // 更新区间
};

build

void SegmentTree::build(int u,int l,int r)
{	
	nodes[u] = {l,r,0,0};   // 初始化节点数组
	if (l == r) {
		return;
	}
	int mid = (l + r) >> 1;   // 中点
	build(u << 1, l, mid);    // 递归更新左子树
	build(u << 1 | 1, mid + 1, r); // 更新右子树
}

modify

void SegmentTree::modify(int u, int l, int r, int d)
{
	if (l <= nodes[u].l && nodes[u].r <= r) {   // 区间完全包含在 (l,r) 中 
		nodes[u].cnt += d;     // d 是左边界和右边界的标志 左（1）右（-1）
		push_up(u);            // 向上更新
	}
	else {                        // 可能不包含也可能不完全包含
		int mid = (nodes[u].l + nodes[u].r) >> 1;
		if (mid >= l) {
			modify(u << 1, l, r, d);   // 更新左左子树
		}
		if (mid < r ) {     
			modify(u << 1 | 1, l, r, d);  // 更新右子树
		}
		push_up(u); 
	}
}

push_up

void SegmentTree::push_up(int u)
{
	if (nodes[u].cnt > 0) {    // 被完全覆盖
		nodes[u].len = nodes[u].r - nodes[u].l + 1;  // 这个区间的长度
	}
	else if(nodes[u].l == nodes[u].r) {     // 叶子节点不能 && cnt == 0
		nodes[u].len = 0;
	}
	else {           // 非叶子节点可能没有被完全覆盖
		nodes[u].len = nodes[u << 1].len + nodes[u << 1 | 1].len;   // 加上左右子树的长度
	}
}

整个算法的实现

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

struct segNode{  // 线段树节点的类型
	int l, r;  // 垂直与 x 轴的左边界和右边界
	int len;   // 线段的长度
	int cnt;   // 线端被完全覆盖的数目
};
class SegmentTree {
private :
			
	void build(int u,int l,int r);   // 初始化线段树
	void push_up(int u) ;  // 向上更新节点 
public  :
	vector<segNode> nodes;      // 线段节点

	SegmentTree(int N) {
		nodes.resize(N << 2); // 线段树需要 4 倍的空间
		build(1,0,N);    // 以 nodes[1] 为头节点
	}
	void modify(int u,int l,int r,int d);       // 更新区间
};

void SegmentTree::build(int u,int l,int r)
{	
	nodes[u] = {l,r,0,0};   // 初始化节点数组
	if (l == r) {
		return;
	}
	int mid = (l + r) >> 1;   // 中点
	build(u << 1, l, mid);    // 递归更新左子树
	build(u << 1 | 1, mid + 1, r); // 更新右子树
}

void SegmentTree::push_up(int u)
{
	if (nodes[u].cnt > 0) {    // 被完全覆盖
		nodes[u].len = nodes[u].r - nodes[u].l + 1;  // 这个区间的长度
	}
	else if(nodes[u].l == nodes[u].r) {     // 叶子节点不能 && cnt == 0
		nodes[u].len = 0;
	}
	else {           // 非叶子节点可能没有被完全覆盖
		nodes[u].len = nodes[u << 1].len + nodes[u << 1 | 1].len;   // 加上左右子树的长度
	}
}

void SegmentTree::modify(int u, int l, int r, int d)
{
	if (l <= nodes[u].l && nodes[u].r <= r) {   // 区间完全包含在 (l,r) 中 
		nodes[u].cnt += d;     // d 是左边界和右边界的标志 左（1）右（-1）
		push_up(u);            // 向上更新
	}
	else {                        // 可能不包含也可能不完全包含
		int mid = (nodes[u].l + nodes[u].r) >> 1;
		if (mid >= l) {
			modify(u << 1, l, r, d);   // 更新左左子树
		}
		if (mid < r ) {     
			modify(u << 1 | 1, l, r, d);  // 更新右子树
		}
		push_up(u); 
	}
}

constexpr int N = 1e4 + 5;
struct node {   // 用来储存线段
	int x, y1, y2;
	int w;   // 是左边界和右边界的标志 左（1）右（-1） 
};

int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);

	int n;
	cin >> n;
	vector<node>arr;
	arr.reserve(2 * n);          // 线段是正方形的 2 倍
	for (int i = 0; i < n; ++i) {
		int x1, y1, x2, y2;
		cin >> x1 >> y1 >> x2 >> y2;
		arr.push_back({x1,y1,y2-1,1});  //  左边界 在像素格中线段应该是 [y1,y2) 左闭右开
		arr.push_back({x2,y1,y2-1,-1});  // 右边界 
	}
	sort(arr.begin(), arr.end(), [](auto &a,auto &b) {
		return a.x < b.x;            // 按x的升序排列
		});
	SegmentTree seg(N);    // 初始化线段树
	seg.modify(1,arr[0].y1,arr[0].y2,arr[0].w);   // 初始化第一条边
	long long res = 0;
	for (int i = 1; i < 2 * n; ++i) {   // 枚举每一条边
		res += seg.nodes[1].len * (arr[i].x - arr[i-1].x);
		seg.modify(1,arr[i].y1,arr[i].y2 ,arr[i].w);
	}
	cout << res << endl;
	return 0;
}

如果线段长度为 1e9 会爆空间，可以用离散化优化

离散化优化

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

struct segNode {  // 线段树节点的类型
	int l, r;  // 垂直与 x 轴的左边界和右边界
	int len;   // 线段的长度
	int cnt;   // 线端被完全覆盖的数目
};
class SegmentTree {
private:
	void build(int u, int l, int r);   // 初始化线段树
	void push_up(int u);  // 向上更新节点 
public:
	vector<segNode> nodes;      // 线段节点
	vector<int> ys;             // 离散化数组 
	SegmentTree(int N) {
		nodes.resize(N << 2); // 线段树需要 4 倍的空间
		build(1, 0, N);    // 以 nodes[1] 为头节点
	}
	void modify(int u, int l, int r, int d);       // 更新区间
};

void SegmentTree::build(int u, int l, int r)
{
	nodes[u] = { l,r,0,0 };   // 初始化节点数组
	if (l == r) {
		return;
	}
	int mid = (l + r) >> 1;   // 中点
	build(u << 1, l, mid);    // 递归更新左子树
	build(u << 1 | 1, mid + 1, r); // 更新右子树
}

void SegmentTree::push_up(int u)
{
	if (nodes[u].cnt > 0) {    // 被完全覆盖
		nodes[u].len = ys[nodes[u].r + 1] - ys[nodes[u].l];  // 离散化后的索引区间[l, r]对应实际坐标中的区间[ys[l], ys[r+1])，其长度为ys[r+1] - ys[l]
	}
	else if (nodes[u].l == nodes[u].r) {     // 叶子节点不能 && cnt == 0
		nodes[u].len = 0;
	}
	else {           // 非叶子节点可能没有被完全覆盖
		nodes[u].len = nodes[u << 1].len + nodes[u << 1 | 1].len;   // 加上左右子树的长度
	}
}

void SegmentTree::modify(int u, int l, int r, int d)
{
	if (l <= nodes[u].l && nodes[u].r <= r) {   // 区间完全包含在 (l,r) 中 
		nodes[u].cnt += d;     // d 是左边界和右边界的标志 左（1）右（-1）
		push_up(u);            // 向上更新
	}
	else {                        // 可能不包含也可能不完全包含
		int mid = (nodes[u].l + nodes[u].r) >> 1;
		if (mid >= l) {
			modify(u << 1, l, r, d);   // 更新左左子树
		}
		if (mid < r) {
			modify(u << 1 | 1, l, r, d);  // 更新右子树
		}
		push_up(u);
	}
}

constexpr int N = 1e4 + 5;
struct node {   // 用来储存线段
	int x, y1, y2;
	int w;   // 是左边界和右边界的标志 左（1）右（-1） 
};


int main() {
	ios::sync_with_stdio(false);
	cin.tie(0);

	int n;
	cin >> n;
	// 离散化存 y
	vector<int>ys;
	vector<node>arr;
	arr.reserve(n << 1);          // 线段是正方形的 2 倍
	for (int i = 0; i < n; ++i) {
		int x1, y1, x2, y2;
		cin >> x1 >> y1 >> x2 >> y2;
		ys.emplace_back(y1);
		ys.emplace_back(y2);
		arr.push_back({ x1,y1,y2,1 });  //  左边界 在像素格中线段应该是 [y1,y2) 左闭右开
		arr.push_back({ x2,y1,y2,-1 });  // 右边界 
	}
	sort(ys.begin(), ys.end());
	ys.erase(unique(ys.begin(), ys.end()), ys.end());    // 去重

	// 建立映射
	auto find = [&](int y) {
		return lower_bound(ys.begin(), ys.end(), y) - ys.begin();
		};
	// arr 
	for (auto& no : arr) {
		no.y1 = find(no.y1);
		no.y2 = find(no.y2);
	}
	sort(arr.begin(), arr.end(), [](auto& a, auto& b) {
		return a.x < b.x;            // 按x的升序排列
		});
	SegmentTree seg(ys.size() - 1);     // 有 ys.size() 个点一共有 ys.size() - 1 条边
	seg.ys = ys;

	seg.modify(1, arr[0].y1, arr[0].y2 - 1, arr[0].w);   // 初始化第一条边
	long long res = 0;
	for (int i = 1; i < 2 * n; ++i) {   // 枚举每一条边
		res += seg.nodes[1].len * (arr[i].x - arr[i - 1].x);
		seg.modify(1, arr[i].y1, arr[i].y2 - 1, arr[i].w);          // 线段树维护的是完全覆盖的区间 [y1,y2)  
	}
	cout << res << endl;
	return 0;
}
Unlyrical
关注
C/C++ 扫描线算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-13 7766
扫描线算法是一种用于解决计算机图形学中的填充问题的常用算法。它的基本思想是通过扫描线的方式，从上到下逐行扫描像素点，根据扫描线与多边形边界的交点来确定填充像素的范围。根据这些相交点，判断填充像素的范围，将这些像素点填充为需要的颜色。首先，确定多边形的边界，可以通过多边形的顶点坐标来确定。对于每一条扫描线，找到与多边形边界相交的点，记录下来。然后，按照从上到下的顺序，逐行扫描像素点。
扫描线（一）——求矩形面积并
CXR的博客
09-09 1341
前言 扫描线应该是一个很有用的算法。 它有许多用途，比较经典的应该就是用来求矩形面积并。 什么是矩形面积并 或许你会问，什么是矩形面积并？ 在一个平面上，有若干个矩形，它们覆盖的总面积就是矩形面积并（重叠部分只算一次）。 要求矩形面积并，我们就可以用扫描线。 离散化 首先，我们要将这张图离散化预处理一下。 离散化的过程应该比较简单，将每个节点的坐标全部存在一个数组...
【算法】扫描线
Just__Do__IT__的博客
08-10 1030
目录扫描线算法的思想：应用：面积相交面积周长窗口的星星碎碎念： 扫描线算法的思想： 扫描线算法是一种求矩形的面积并和周长并等的好方法。其思想是由一条假想的线从图形的左方扫向右方（或者下方扫到上方，都可以），那么通过分析扫描线被图形截得的线段就能获得所要的结果。该过程可以用线段树进行加速，记录截得的线段长度。 感受一下 应用： 面积 【ACWing】247. 亚特兰蒂斯——扫描线求面积 相交面积 【hdu】1255 覆盖的面积——扫描线求重叠面积和 周长 【hdu】1828 Picture —— 扫描线求周
【算法】-扫描线
最新发布
knoci的博客
05-30 5410
在计算几何中，扫描线算法（scan line algorithm）一般用来解决几何图形的面积交并，周长交并问题，扫描线算法的核心思想是利用扫描线（通常是水平线或垂直线）在几何空间中“扫描”对象，以确定哪些对象与扫描线相交。下面我们就来通过求矩形的面积并来介绍扫描线算法。先来看看怎么求下面图形的面积并：传统算法是两个矩形面积相加减去重合的面积：但是这样算非常的耗费时间，因为每个矩形都需要两两配对，查看互相之间是否有交集。那么我们接下来就想着把矩形分成三部分：于是现在就变成了。
计算几何——扫描线算法
jiahonghao2002的博客
07-13 5287
计算几何——扫描线算法 面对一个几何图形，计算机通过向某一个方向进行单线扫描，进行图形处理的方式叫做扫描线算法。 事件和事件处理程序 扫除线算法中最重要的就是对事件（Event）的处理。一个事件定义为当扫除线碰到点、边界、线等产生的进入或退出事件。 例如下图： 当扫描线碰到某一个矩形的左边界时将会产生一个进入事件，之后处理程序将对这个进入事件进行处理。 又或者当扫描线碰到某一个矩形的右边界时将会产生一个退出事件，之后处理程序将对这个退出事件进行处理。 一般的，我们将整个事件列表中的事件进行按照扫除线的
JAVA实现扫描线算法(超详细)
08-25
JAVA实现扫描线算法的知识点总结 扫描线算法是计算机图形学中的一种常用算法，用于实现多边形的扫描线填充。下面是JAVA实现扫描线算法的知识点总结： 1. 扫描线算法的基本概念： 扫描线算法是从Ymin开始扫描，...
ScanFill_x扫描线算法_线扫描_
09-30
《X扫描线算法详解及其应用》 X扫描线算法，是一种在二维图形处理中用于填充多边形的有效方法。该算法的基本思想是沿着水平方向，即X轴，以一定的顺序扫描，通过计算每条扫描线与多边形边界的交点，确定在屏幕上...
C++实现基于EASYX库扫描线算法
08-25
基于EASYX库的C++扫描线算法实现 扫描线算法是一种常用的计算机图形学算法，主要用于解决计算机图形学中的各种问题。该算法的主要思想是将图形分解成多个小三角形，然后对每个三角形进行扫描线处理，从而获得图形的...
多边形扫描转换算法（扫描线算法）
05-01
实现任意一个非自交五边形的扫描转换（要求采用扫描线算法）
区间扫描线算法
02-09
z-buffer算法进阶是扫描线算法，再进一步就是区间扫描线算法，这是图形学基本算法。这里面是vs2015的项目，里面附赠了多个obj模型。先从obj模型读取开始，到最后的显示。
算法--扫描线
余的日常学习
05-09 1205
算法--扫描线 LintCode 391 数飞机 洛谷 P5490 【模板】扫描线 letcode 218. 天际线问题 [蓝桥杯 2020 国 A] 奇偶覆盖
扫描线算法实现区域填充技术解析
从提供的文件名称列表"082400_赵奇可_扫描线算法"可以推测，这是一个日期标识（082400），作者名（赵奇可），以及主题（扫描线算法）的组合。该文件可能包含了上述算法的实现代码、文档说明或作业报告。 以上就是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值