线段树 + 扫描线 + 离散化：亚特兰蒂斯

最新推荐文章于 2022-05-18 06:00:00 发布

啦啦啦32421

最新推荐文章于 2022-05-18 06:00:00 发布

阅读量197

点赞数

分类专栏：基础算法文章标签：数据结构

本文链接：https://blog.csdn.net/qq_49120553/article/details/119427277

版权

基础算法专栏收录该内容

111 篇文章 0 订阅

订阅专栏

题目链接：https://www.acwing.com/problem/content/description/249/

题目：

有几个古希腊书籍中包含了对传说中的亚特兰蒂斯岛的描述。

其中一些甚至包括岛屿部分地图。

但不幸的是，这些地图描述了亚特兰蒂斯的不同区域。

您的朋友 Bill 必须知道地图的总面积。

你自告奋勇写了一个计算这个总面积的程序。

输入格式

输入包含多组测试用例。

对于每组测试用例，第一行包含整数 nn，表示总的地图数量。

接下来 nn 行，描绘了每张地图，每行包含四个数字 x1,y1,x2,y2x1,y1,x2,y2（不一定是整数），(x1,y1)(x1,y1) 和 (x2,y2)(x2,y2) 分别是地图的左上角位置和右下角位置。

注意，坐标轴 xx 轴从上向下延伸，yy 轴从左向右延伸。

当输入用例 n=0n=0 时，表示输入终止，该用例无需处理。

输出格式

每组测试用例输出两行。

第一行输出 Test case #k，其中 kk 是测试用例的编号，从 11 开始。

第二行输出 Total explored area: a，其中 aa 是总地图面积（即此测试用例中所有矩形的面积并，注意如果一片区域被多个地图包含，则在计算总面积时只计算一次），精确到小数点后两位数。

在每个测试用例后输出一个空行。

数据范围

1≤n≤100001≤n≤10000,
0≤x1<x2≤1000000≤x1<x2≤100000,
0≤y1<y2≤1000000≤y1<y2≤100000
注意，本题 nn 的范围上限加强至 1000010000。

输入样例：
2
10 10 20 20
15 15 25 25.5
0
输出样例：
Test case #1
Total explored area: 180.00 
样例解释

样例所示地图覆盖区域如下图所示，两个矩形区域所覆盖的总面积，即为样例的解。

分析：

1.离散化：

由于题目中要求的y是小数，虽然y的范围为 100000，实际上可以取的值有很多，而最多用到的y就2 * n个，所以需要离散化

2.扫描线：

使用扫描线的方式，将给定的多个矩形（蓝色部分）分成若干个区间，其中xi - x i -1是可以很容易求出来的。对x进行排序即可。此扫描线的切割方式，是按照我们给定的矩形的x进行切割成多个不同的矩形区域。

然后我们只需要求出每个区域的对应的y的长度即可。

3.线段树：

线段树维护的是一个区间，

如 1 ,2 , 5 ,7 维护的就是每一个段出现了多少次，1~2这个段出现了多少次，2~5这个段出现了多少次,5~7这个段出现了多少次。而不在像前面的统计某个点出现了多少次。实际上是一样的。

用1表示1~2这一段，用2表示2~5这一段，用3表示5~7这一段，而当我们对y进行离散化之后，就更是如此般的理解即可。

线段树节点的结构：

struct Node // 线段树的节点
{
int l,r; // l,r为区间的范围
int cnt; // cnt代表对应的区间当前被覆盖了几次
double len; // 总长度
}edgs[8 * N]; // 为什么是8 * N 呢？因为，总的区间个数为2 * N , 开其4倍

如何对线段树进行操作：

统计cnt的值。比如上面那张图中，x1~x2的区间，对应y轴的两个区间，所以这两个区间对应的线段树的部分会cnt ++. 然后到了x2~x3的区间，这个时候呢？由于前面的x1~x2的区间的长度还没有过，所以cnt在这两个区间没有发生改变。但是现在x2~x3的区间又新增加了一个区间，于是对应的线段树的那部分区间的cnt部分也会再次进行更新。 x3~x4区间的时候，原来的x1~x2的区间遇到了-1.所以这部分的cnt变为了0，由 + 1然后进行了-1操作.

2.无需使用pushdown操作。

这是由于扫描线的一个特性，直接访问根节点的值。所以在query()函数中

按照之前的写法

int query()

{

if(根节点)

        {

一系列操作

return

        }

else

        {

pushdown()

        }

}

而现在我们只会访问根节点，也就是每次只会访问if()直接rutuen不会进入到pushdown操作。

所以查询操作中不需要pushdown()。

那么另一个modify()操作呢？

首先，如果是k == -1的情况，也就是遇到了矩形的右边界，-1的情况。

（由于成对存在，所以cnt不会为负值，最小为0，加了1后又减1）

那么如果现在减去1了。那么cnt可能依旧为正值，如果依旧为正值的话，那么直接返回对应的结果。

如果变为了0，那么就通过子节点的len值去更新父结点的len值。并且如果cnt == 0了，pushdown操作也不会执行下去。

同样如果为k == 1的情况，加1. 那么也是如此。所以无需使用pushdown()操作。

此题，只需要使用pushup操作，build()操作，modify操作。

pushup操作，如果cnt > 0 的话，直接返回对应的区间值，应为这个区间有被覆盖，不管cnt为几都可以直接返回区间值。

如果cnt == 0，如果不是叶子节点，则通过子节点更新父结点的值。

如果cmt == 0 且是叶子节点，则更新len值为0.

build()操作与之前一样。

modify()操作：

如果在l,r的区间内，直接修改k，并进行pushup(),因为我们只会访问根节点，

如果不在l,r的区间内，则和之前一样。

代码实现：

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

const int N = 10010;

struct qujian
{
    double x;  // x代表它横坐标的位置
    double y1; // y1代表它当前第一个纵坐标的位置
    double y2; // y2代表它当前第二个纵坐标的位置
    int k; // k 代表它的值（1或者是 -1）
}qujian[2  * N ];  // 因为一个矩形就会有两条这样的线，x1,x2不同，但是y1,y2相同，k一个为1 一个为-1

vector<double> lisan; // 进行离散化的vector<>

bool cmp(struct qujian a , struct qujian b) // 后面会对qujian关于x从小到大进行排序
{
    return a.x < b.x;
}

struct Node  // 线段树的节点
{
    int l,r;  // l,r为区间的范围
    int cnt; // cnt代表对应的区间当前被覆盖了几次
    double len; // 总长度
}edgs[8 * N];  // 为什么是8 * N 呢？因为，总的区间个数为2 * N , 开其4倍

int find(double y) // 找到当前y值对应的离散化后的下标
{
    int l = 0,r = lisan.size() - 1;
    while(l < r)
    {
        int mid = (l + r) / 2;
        if(lisan[mid] >= y)
        {
            r = mid;
        }
        else
        {
            l = mid + 1;
        }
    }
    return l;
}

void pushup(int u)
{
    if(edgs[u].cnt) // 如果edgs[u].cnt > 0 的话
    {
        edgs[u].len = lisan[edgs[u].r + 1] - lisan[ edgs[u].l ];
    }
    else if(edgs[u].l != edgs[u].r) // 非叶子节点
    {
        edgs[u].len = edgs[2 * u].len + edgs[2 * u + 1].len;
    }
    else
    {
        edgs[u].len = 0;
    }
}

void build(int u , int l , int r)
{
    edgs[u].l = l , edgs[u].r = r;
    if(l == r)
    {
        edgs[u].cnt = 0;
        edgs[u].len = 0;
        return;
    }
    else
    {
        int mid = (edgs[u].l + edgs[u].r) / 2;
        build(2 * u , l , mid);
        build(2 * u + 1 , mid + 1 , r);
        pushup(u); // 这道题可写可不写
    }
}

void modify(int u , int l , int r , int k) //给离散化后的l~r加一个k值，1或者-1
{
    if(edgs[u].l >= l && edgs[u].r <= r)
    {
        edgs[u].cnt += k;
        pushup(u);
        return;
    }
    else
    {
        int mid = ( edgs[u].l + edgs[u].r ) / 2;
        if(l <= mid)
        {
            modify(2 * u , l , r , k);
        }
        if(r > mid)
        {
            modify(2 * u + 1 , l , r , k);
        }
        pushup(u);
    }
}

int n;

int main()
{
    int t = 1;
    while(scanf("%d",&n),n)
    {
         lisan.clear();
        
        for(int i = 1 , j = 0; i <= n ; i++)
        {
            double x1,y1,x2,y2;
            scanf("%lf %lf %lf %lf",&x1,&y1,&x2,&y2);
            qujian[j++] = {x1,y1,y2,1};
            qujian[j++] = {x2,y1,y2,-1};
            lisan.push_back(y1);
            lisan.push_back(y2);
        }
        
        sort(lisan.begin(),lisan.end());
        lisan.erase(unique(lisan.begin(),lisan.end()),lisan.end());
        
        //建立线段树
        build(1,0,lisan.size() - 2); // 为什么是0~lisan.size() - 2呢？ 这是因为我们线段树中维护的是 线段区间， 比如y1~y2  实际上用的是y1进行表示。同样的我们现在离散化了之后，变为了0,1,2,..lisan.size() - 1。 那么0~1变为了0, 1~2变为了1, lisan.size() - 2 ~ lisan.size() - 1变为了lisan.size() -2
        
        
        //将区间关于x进行排序好,对y1~y2的长度进行计算统计
        
        sort(qujian , qujian + 2 * n ,cmp);
        
        
        double ans = 0;
        //开始进行计算
        for(int i = 0 ; i < 2 * n ; i++)
        {
            if(i > 0)ans += edgs[1].len * (qujian[i].x - qujian[i - 1].x);
            modify(1,find(qujian[i].y1),find(qujian[i].y2) - 1,qujian[i].k); //范围为y1~y2，如2 ~ 4则结果就变为了，
        }
        printf("Test case #%d\n",t++);
        printf("Total explored area: %.2lf\n\n",ans);
    }
    return 0;
}