HDU 1255 线段树+扫描线+离散化求覆盖的面积

最新推荐文章于 2020-07-09 12:46:59 发布

风吹落最后一片叶.

最新推荐文章于 2020-07-09 12:46:59 发布

阅读量235

点赞数

CC 4.0 BY-SA版权

分类专栏：线段树

本文链接：https://blog.youkuaiyun.com/an94460061/article/details/91474680

线段树专栏收录该内容

2 篇文章

订阅专栏

本文分享了一道关于使用线段树求解矩阵覆盖两次或以上面积的题目解析，通过一篇详细的题解文章，深入探讨了如何利用pushup函数计算覆盖次数及长度，特别强调了坐标系统的理解和应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

最近刚开始学线段树，也是似懂非懂的感觉这是做扫描线的第二道题。求矩阵覆盖两次或以上面积。

看到的一篇题解：链接1 讲的真的不能再清楚了。

这篇题解格式跟我写的非常像让我更好的理解了一下这道题。

最重要的部分是pushup()函数中的代码：

void pushup(int k)
{
    //计算覆盖一次或以上的长度
    if(t[k].cover)
        t[k].len1=x[t[k].r+1]-x[t[k].l];
    else if(t[k].r==t[k].l)
        t[k].len1=0;
    else
        t[k].len1=t[2*k].len1+t[2*k+1].len1;
    //计算覆盖两次或以上的长度
    if(t[k].cover>1)
        t[k].len2=x[t[k].r+1]-x[t[k].l];
    else if(t[k].l==t[k].r)
        t[k].len2=0;
    else if(t[k].cover==1)
        t[k].len2=t[2*k].len1+t[2*k+1].len1;
    else
        t[k].len2=t[2*k].len2+t[2*k+1].len2;
}

反思：

还有一点让我出错的地方就是每次遇到有坐标点的这种问题时，我总是分不清坐标原点是从左下角开始还是从左上角开始。

这题就是这么出错了。我画图的时候其实是按照原点在左下角理解的，但是我自己写代码的时候缺把上下边的标记写反了。

导致输出一直都是零没有正确答案。下次再遇到有坐标点的问题一定要留个心眼，留心坐标到底应该怎么建。

#include<iostream>
#include<stdio.h>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn=1010;
struct edge
{
    double l,r,h;
    int f;
    edge(){}
    edge(double ll,double rr,double hh,int ff):l(ll),r(rr),h(hh),f(ff){}
    bool operator <(const edge &t1) const{
        return h<t1.h;
    }
};
struct node
{
    int l,r;
    double len1;//表示区间被覆盖一次或以上的长度
    double len2;//表示区间被覆盖两次或以上的长度
    int cover;
};
double x[maxn*2];
edge e[maxn*2];
node t[maxn*8];
void build(int l,int r,int k)
{
    t[k].l=l;t[k].r=r;
    t[k].len1=t[k].len2=0;
    t[k].cover=0;
    if(l==r)
        return;
    int mid=(l+r)/2;
    build(l,mid,2*k);
    build(mid+1,r,2*k+1);
}
void pushup(int k)
{
    //计算覆盖一次或以上的长度
    if(t[k].cover)
        t[k].len1=x[t[k].r+1]-x[t[k].l];
    else if(t[k].r==t[k].l)
        t[k].len1=0;
    else
        t[k].len1=t[2*k].len1+t[2*k+1].len1;
    //计算覆盖两次或以上的长度
    if(t[k].cover>1)
        t[k].len2=x[t[k].r+1]-x[t[k].l];
    else if(t[k].l==t[k].r)
        t[k].len2=0;
    else if(t[k].cover==1)
        t[k].len2=t[2*k].len1+t[2*k+1].len1;
    else
        t[k].len2=t[2*k].len2+t[2*k+1].len2;
}
void update(int l,int r,int k,int cover)
{
    if(t[k].l>=l&&t[k].r<=r)
    {
        t[k].cover+=cover;
        pushup(k);
        return;
    }
    int mid=(t[k].l+t[k].r)/2;///!!!
    if(l<=mid) update(l,r,2*k,cover);
    if(r>mid) update(l,r,2*k+1,cover);
    pushup(k);
}
int main()
{
//    freopen("in.txt","r",stdin);
    int T;
    scanf("%d",&T);
    while(T--)
    {
        memset(x,0,sizeof(x));
        memset(e,0,sizeof(struct edge)*maxn*2);
        memset(t,0,sizeof(struct node)*maxn*8);
        int n;
        scanf("%d",&n);
        double x1,y1,x2,y2;
        int kase=0;
        for(int i=0;i<n;i++)
        {
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            e[kase]=edge(x1,x2,y1,1);//上边
            e[kase+1]=edge(x1,x2,y2,-1);//下边
            x[kase]=x1;
            x[kase+1]=x2;
            kase+=2;
        }
        sort(x,x+kase);
        sort(e,e+kase);
        int m=unique(x,x+kase)-x;//x[]数组长度
        build(0,m-1,1);
        double ans=0;
        for(int i=0;i<kase;i++)
        {
            int l=lower_bound(x,x+m,e[i].l)-x;
            int r=lower_bound(x,x+m,e[i].r)-x-1;
            update(l,r,1,e[i].f);
            ans+=t[1].len2*(e[i+1].h-e[i].h);
        }
        printf("%.2lf\n",ans);

    }
    return 0;
}