扫描线求矩形覆盖面积、体积--入坑总结

最新推荐文章于 2023-03-12 10:40:46 发布
最新推荐文章于 2023-03-12 10:40:46 发布
阅读量2.4k 收藏 2
点赞数 5
分类专栏： 线段树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43803508/article/details/103972736
版权

扫描线思想：扫描线算法

文章目录

被覆盖1次的区域面积

扫描线一个很经典的例题（HDU-1542-Atlantis）：在坐标轴上有若干个矩形，问他们覆盖的面积总和。
因为他们覆盖的面积有重复，于是就用到了神奇的扫描线算法。

扫描线一般就是平行于x轴或者y轴的直线。通过这些直线我们可以把这些矩形覆盖的区域分成若干个子区域分别求面积最后再求和，如下图的区域就被分成了5个子区域。（我是以x轴建的线段树）
在这里插入图片描述
要求得这些子区间的面积，重点就在于求每个子区间被覆盖的区间长度和。扫描线向上移动每遇到一条矩形的边，就意味着一段连续的区间会被这个矩形覆盖，或者这段连续的区间不再被这个矩形覆盖。这样就变成了一个区间修改的问题。遇到矩形的下边，这段区间的覆盖次数就加一；遇到矩形的上边，这段区间的覆盖次数就减一，每次统计整段区间上被覆盖过的区间长度。

还有一点是，因为题目中的横坐标值比较大，且是浮点数，所以需要离散化一下。

代码：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define mid ((l + r)>>1)
#define chl root<<1
#define chr root<<1|1
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int manx=510;
double tree[manx<<2],X[manx<<1];
int cover[manx];
//tree维护的是1-n中被覆盖的区间长度和
//X存的是所有矩形顶点的横坐标，最后要离散化
//cove维护每个区间被覆盖的次数
struct node
{
    double y,lx,rx;
    int val;
    friend bool operator<(node a,node b)
    {
        return a.y<b.y;
    }
    //node(double a=0,double b=0,double c=0,int d=0):y(a),lx(b),rx(c),val(d){}
}line[manx<<1];
//存矩形上下边的信息，每条边会对应一次区间修改
void init()
{
    memset(tree,0,sizeof(tree));
    memset(cover,0,sizeof(cover));
}
void eval(int root,int l,int r)
{
    if(cover[root])
        tree[root]=X[r+1]-X[l];
    else tree[root]=tree[chl]+tree[chr];
}
void change(int root,int l,int r,int ll,int rr,int val)
{
//这里有些地方写的是l>=ll&&r<=rr的判断条件，他们的区别就在于一个是分的要查询的区间，一个是分的被查询区间(即1-n的区间)
//我分的是要查询的区间(ll-rr)，仔细看会发现这两种写法在下面else中的change里的传参是不一样的
    if(l==ll&&r==rr)
    {
        cover[root]+=val;
        eval(root,l,r);
        return;
    }
    if(rr<=mid)
        change(chl,l,mid,ll,rr,val);
    else if(ll>mid)
        change(chr,mid+1,r,ll,rr,val);
    else
    {
        change(chl,l,mid,ll,mid,val);
        change(chr,mid+1,r,mid+1,rr,val);
    }
    eval(root,l,r);
}
int main()
{
    int n,Cas=0;
    double x1,y1,x2,y2;
    while(scanf("%d",&n),n)
    {
        double ans=0;
        init();
        for(int i=1;i<=n;i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            line[i*2]=node{y1,x1,x2,1};
            X[i*2]=x1;
            line[i*2-1]=node{y2,x1,x2,-1};
            X[i*2-1]=x2;
        }
        sort(X+1,X+2*n+1);
        sort(line+1,line+2*n+1);
        int cnt=unique(X+1,X+2*n+1)-X-1;
        for(int i=1;i<2*n;i++)
        {
            int l=lower_bound(X+1,X+cnt+1,line[i].lx)-X;
            int r=lower_bound(X+1,X+cnt+1,line[i].rx)-X-1;
            double dy=line[i+1].y-line[i].y;
            change(1,1,cnt,l,r,line[i].val);
            ans+=tree[1]*dy;
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n",++Cas,ans);
    }
    return 0;
}
被覆盖2次的区域面积

例题：HDU-1255-覆盖的面积

正解（维护被覆盖一次和两次的区间长度）：hdu 1255 覆盖的面积

做题的时候遇到的一些问题：

1、为什么不能push_down
比如说，当我们更新小区间的过程中，将大区间的标记下传了，那么到后面我们更新大区间时，代表这个大区间状态的结点的lazy就会变成负数。这时就只能再维护被覆盖一次、两次、三次、、、的区间长度，这样才能从它的两个儿子结点得到当前结点的正确状态，或者将区间修改变成单点修改，但这两种方式时间是不允许的。
2、只维护被覆盖两次的区间长度+lazy懒标记的思路为什么不对：最开始写了一个假的线段树+扫描线算法过了，但是看代码跑出来的时间有点长。最后发现我把它写成了一个暴力的单点修改：当时我只用了一个tree数组维护被覆盖了2次的区间长度，cover数组维护区间段上被覆盖的最少次数，还维了一个lazy数组。后面又改了半天发现这个思路好像实现不了（我觉得是实现不了）。因为cover>=2的时候好说，可以直接计算长度，但是=1的时候去不能像上面的例题一样通过左右子区间求解，因为区间修改中push_down只能操作到我们要找的那个区间，就算push_down lazy的值也可能会遗漏计算被覆盖两次上的区间，除非每次push_down到叶子结点（可能这就是7.63的答案总是测出7.50的结果的原因吧）

所以还是得再开一个tree数组维护被覆盖了1次的区间长度。

代码：

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define mid ((l + r)>>1)
#define chl root<<1
#define chr root<<1|1
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
const int manx=11000;
double tree[manx<<2],X[manx<<1],tree2[manx];//lazy[manx],
int cover[manx];
struct node
{
    double y,lx,rx;
    int val;
    friend bool operator<(node a,node b)
    {
        return a.y<b.y;
    }
    //node(double a=0,double b=0,double c=0,int d=0):y(a),lx(b),rx(c),val(d){}
}line[manx<<1];
void init()
{
    memset(tree,0,sizeof(tree));
    memset(cover,0,sizeof(cover));
    memset(tree2,0,sizeof(tree2));
}
void eval(int root,int l,int r)
{
    if(cover[root])
        tree[root]=X[r+1]-X[l];
    else if(l==r)
        tree[root]=0;
    else tree[root]=tree[chl]+tree[chr];
    if(cover[root]>=2)
        tree2[root]=X[r+1]-X[l];
    else if(l==r)
        tree2[root]=0;
    else if(cover[root]==1)
        tree2[root]=tree[chl]+tree[chr];
    else
        tree2[root]=tree2[chl]+tree2[chr];
}
void change(int root,int l,int r,int ll,int rr,int val)
{
    if(l==ll&&r==rr)
    {
        cover[root]+=val;
        eval(root,l,r);
        return;
    }
    if(rr<=mid)
        change(chl,l,mid,ll,rr,val);
    else if(ll>mid)
        change(chr,mid+1,r,ll,rr,val);
    else
    {
        change(chl,l,mid,ll,mid,val);
        change(chr,mid+1,r,mid+1,rr,val);
    }
    eval(root,l,r);
}
int main()
{
    int t,n;
    double x1,y1,x2,y2;
    while(scanf("%d",&t)!=EOF)
    {
        while(t--)
        {
            scanf("%d",&n);
            double ans=0;
            init();
            for(int i=1; i<=n; i++)
            {
                scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
                line[i*2]=node{y1,x1,x2,1};
                X[i*2]=x1;
                line[i*2-1]=node{y2,x1,x2,-1};
                X[i*2-1]=x2;
            }
            sort(X+1,X+2*n+1);
            sort(line+1,line+2*n+1);
            int cnt=unique(X+1,X+2*n+1)-X-1;
            //X[cnt+1]=X[cnt];
            for(int i=1; i<2*n; i++)
            {
                int l=lower_bound(X+1,X+cnt+1,line[i].lx)-X;
                int r=lower_bound(X+1,X+cnt+1,line[i].rx)-X-1;
                double dy=line[i+1].y-line[i].y;
                change(1,1,cnt,l,r,line[i].val);
                ans+=tree2[1]*dy;
            }
            printf("%.2f\n",ans);
        }
    }
    return 0;
}

之前还犯的一个数组越界的错，杭电上测出RE了，本来数组开的应该够大。。后面发现是eval函数里面最开始没有排除l== r的情况（即遍历到叶子节点时）导致继续访问叶子结点的“左右儿子”造成tree数组下标越界（因为看学长的模板时还感觉可以不用排除l==r的情况，就没有加）。但数组越界第一次在vj上测得的结果是wa，以前听学长说是因为有野指针。。。所以可能就给tree赋了一个随机数吧

立方体交

HDU-3642-Get The Treasury

和上面求被覆盖2次的区域面积的例题类似

我们可以枚举垂直于x轴的平面，用上面的方法求出这个平面上被覆盖了3次以上的面积，然后乘上x轴上的高度

#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<map>
#include<set>
using namespace std;
#define LL long long
//#define int long long
#define ull unsigned long long
#define pii pair<int,int>
#define mid ((l + r)>>1)
#define chl (root<<1)
#define chr (root<<1|1)
#define lowbit(x) ( x&(-x) )
const int manx = 2e3 + 10;
const int manx2 = 4e7 + 10;
const int INF = 2e9;
const int mod = 1e4+7;

int t,n,x1,y1,z1,x2,y2,z2,cou,len,Z[manx];//|z|<=500
LL sum[1010<<2][4];
int cover[1010<<2];
struct node
{
    int x,y1,z1,y2,z2;
    int val,pos;
    friend bool operator<(const node &a,const node &b){
//        if(a.x==b.x)return a.val>b.val;
        return a.x<b.x;
    }
}plane[manx],vs[manx];
struct LINE
{
    int y,lz,rz;
    int val;
    friend bool operator<(const LINE &a,const LINE &b){
        return a.y<b.y;
    }
}line[manx];
void init(int n)
{
    for(int i=1;i<=4*n;i++){
        cover[i]=0;
        for(int j=1;j<=3;j++)
            sum[i][j]=0;
    }
}
void eval(int root,int l,int r)
{
    sum[root][1]=sum[root][2]=sum[root][3]=0;
    if(l==r){
        for(int i=1;i<=cover[root];i++)
             sum[root][i]=Z[r+1]-Z[l];
        return;
    }
    if(cover[root]>=3)
        sum[root][1]=sum[root][2]=sum[root][3]=Z[r+1]-Z[l];
    else if(cover[root]==2){
        sum[root][3]=sum[chl][1]+sum[chr][1];
        sum[root][1]=sum[root][2]=Z[r+1]-Z[l];
    }
    else if(cover[root]==1){
        sum[root][3]=sum[chl][2]+sum[chr][2];
        sum[root][2]=sum[chl][1]+sum[chr][1];
        sum[root][1]=Z[r+1]-Z[l];
    }
    else{
        for(int i=1;i<=3;i++)
            sum[root][i]=sum[chl][i]+sum[chr][i];
    }
}
void change(int root,int l,int r,int ll,int rr,int val)
{
    if(l==ll&&r==rr){
        cover[root]+=val;
        eval(root,l,r);
        return;
    }
    if(rr<=mid)
        change(chl,l,mid,ll,rr,val);
    else if(ll>mid)
        change(chr,mid+1,r,ll,rr,val);
    else{
        change(chl,l,mid,ll,mid,val);
        change(chr,mid+1,r,mid+1,rr,val);
    }
    eval(root,l,r);
}
int main()
{
    int Cas=0;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        len=0;
        for(int i=1;i<=n;i++){
            scanf("%d%d%d%d%d%d",&x1,&y1,&z1,&x2,&y2,&z2);
            plane[i*2-1]=node{x1,y1,z1,y2,z2,1,i};
            plane[i*2]=node{x2,y1,z1,y2,z2,-1,i};
            vs[i]=node{-1,y1,z1,y2,z2,0,-1};
        }
        sort(plane+1,plane+2*n+1);
        LL ans=0,temp;
        for(int i=1;i<2*n;i++){
            temp=0;
            vs[plane[i].pos].val+=plane[i].val;
            cou=0;
            for(int j=1;j<=n;j++){
                if(vs[j].val){
                    line[++cou]=LINE{vs[j].y1,vs[j].z1,vs[j].z2,1};
                    Z[cou]=vs[j].z1;
                    line[++cou]=LINE{vs[j].y2,vs[j].z1,vs[j].z2,-1};
                    Z[cou]=vs[j].z2;
                }
            }
            sort(line+1,line+cou+1);
            sort(Z+1,Z+cou+1);
            len=unique(Z+1,Z+cou+1)-Z-1;
            for(int j=1;j<cou;j++){
                int l=lower_bound(Z+1,Z+len+1,line[j].lz)-Z;
                int r=lower_bound(Z+1,Z+len+1,line[j].rz)-Z-1;
                change(1,1,len,l,r,line[j].val);
                LL dy=line[j+1].y-line[j].y;
                temp+=dy*sum[1][3];
            }
            LL dx=plane[i+1].x-plane[i].x;
            ans+=dx*temp;
            init(len);
        }
        printf("Case %d: %lld\n",++Cas,ans);
    }
    return 0;
}
/*

6
0 0 0 5 5 5
3 3 3 5 5 5
3 3 3 5 5 5
0 0 0 5 5 5
3 3 3 5 5 5
3 3 3 5 5 5
*/
小鱼yn
关注
  • 5
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CVE-2019-0708扫描工具.rar
11-14
CVE-2019-0708扫描工具亲测可用
电脑周边简介-扫描仪.pdf
11-16
电脑周边简介-扫描仪.pdf
扫描线（线段树）
Cauchy的博客
05-18 1772
文章目录扫描线扫描线求重叠矩形面积思路算法流程性质经典例题247. 亚特兰蒂斯 扫描线 线段树的一大应用是扫描线。 扫描线一个很经典的例题：在坐标轴上有若干个矩形，问他们覆盖的面积总和。 扫描线求重叠矩形面积 思路 使用一条垂直于X轴的直线，从左到右来扫描这个图形，明显，只有在碰到矩形的左边界或者右边界的时候，这个线段所扫描到的情况才会改变。 所以把所有矩形的入边，出边按 X 值排序。然后根据 X 值从小到大去处理。 用线段树来维护扫描到的情况，即每条线段映射到 Y 轴上进行区间维护。 算法流程
扫描线——一种巧妙的技巧求面积（离散化做法和动态开点）
dazha6157的博客
06-28 279
请在学习之前有一定的线段树基础 在一些题中，它总会给你一些矩形，之后让你求总覆盖面积。 它的难点在于，有重叠面积，如果只是罗列情况，那么只会一事无成。 所以说，这里就引进了扫描线做法； 其实它的原理很简单，只是底*高而已，只是分段求解； 而问题大概的图就是这样 根据我刚刚说的分段求解和底*高，那么我们就可以推测出扫描线是什么了 它是由矩形的上边和下边构成，并记录其左右端...
矩形覆盖
weixin_30660027的博客
01-19 139
题目描述 在平面上有 n 个点（n <= 50），每个点用一对整数坐标表示。 这些点可以用 k 个矩形（1<=k<=4）全部覆盖，矩形的边平行于坐标轴。问题是当 n 个点坐标和 k 给出后，怎样才能使得覆盖所有点的 k 个矩形的面积之和为最小呢。约定：覆盖一个点的矩形面积为 0；覆盖平行于坐标轴直线上点的矩形面积也为0。各个矩形必须完全分开（...
扫描线+离散化 计算矩形面积
qq_43533956的博客
09-17 323
我们给出了一个（轴对齐的）二维矩形列表 rectangles。对于 rectangle[i] = [x1, y1, x2, y2]，其中（x1，y1）是矩形 i 左下角的坐标， (xi1, yi1) 是该矩形 左下角 的坐标， (xi2, yi2) 是该矩形 右上角 的坐标。计算平面中所有 rectangles 所覆盖的 总面积。任何被两个或多个矩形覆盖的区域应只计算 一次。返回 总面积。因为答案可能太大，返回 10^9 + 7 的 模。i。
新大陆NLS-MT66扫描PAD示例
05-25
新大陆NLS-MT66扫描PAD示例 uni-app示例 uni-appdemo 新大陆NLS-MT66扫描PAD示例 新大陆NLS-MT66扫描PAD示例
基恩士SZ-V系列安全扫描仪 用户手册.pdf
05-26
基恩士SZ-V系列安全扫描仪 用户手册
行业分类-设备装置-多线激光条码扫描平台.zip
08-25
行业分类-设备装置-多线激光条码扫描平台.zip
综合扫描器X-Scan
05-21
X-Scan是国内最著名的综合扫描器之一，它完全免费，是不需要安装的绿色软件、界面支持中文和英文两种语言、包括图形界面和命令行方式。主要由国内著名的民间黑客组织“安全焦点”完成，从2000年的内部测试版X-Scan V...
区间扫描线算法
02-09
z-buffer算法进阶是扫描线算法，再进一步就是区间扫描线算法，这是图形学基本算法。这里面是vs2015的项目，里面附赠了多个obj模型。先从obj模型读取开始，到最后的显示。
松下高速扫描仪KV-S5046H维修手册.pdf
07-28
松下高速扫描仪KV-S5046H维修手册.pdf
端口扫描nmap-7.91-setup.rar
05-28
端口扫描nmap-7.91-setup.rar
Uni-APP 广播扫描示例.zip
09-08
采用uni-app的方式，在PDA手持设备上开发广播扫码的功能
391. 完美矩形 扫描线
yu_duan_hun的博客
09-17 343
扫描线，完美矩形
c++进制转换+扫描线算法(二维区间合并面积和)
violet的博客
03-12 544
转换
HDU 1542+HDU 1255（进阶） 线段树扫描线法解决矩形覆盖求面积
c___c18的博客
12-05 331
There are several ancient Greek texts that contain descriptions of the fabled island Atlantis. Some of these texts even include maps of parts of the island. But unfortunately, these maps describe diff...
平面内有多个矩形，求矩形重叠数最多的区域包含的矩形数量？
懒人闲得慌
03-28 2811
import java.util.*; /**  * 平面内有多个矩形，求矩形重叠数最多的区域包含的矩形数量？  * 输入：  * 3  * 0 1 1  * 0 1 1  * 2 3 4  * 2 3 4  * 解释：  * 3：矩形个数  * (0,0)矩形1左下端点，(2,2)矩形1右上端点  * (1,1)矩形2左下端点，(3,3)矩形2右上端点  * (1,1)矩形3左下端点，(4,...
矩形覆盖扫描线matlab
最新发布
09-10
矩形覆盖扫描线是一种在MATLAB中常用的图像处理技术。该技术主要用于检测和标记图像中的矩形区域。具体而言，矩形覆盖扫描线算法通过扫描图像的每一行，检测连续的像素点，将其标记为矩形的一部分，并计算矩形的位置...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值