線段樹（掃描線）（hdu1542 hdu1255）

一個連接，還不錯：https://www.cnblogs.com/scau20110726/archive/2013/04/12/3016765.html

 

hdu1542：http://acm.hdu.edu.cn/showproblem.php?pid=1542

題意：給你每個長方形的左下點的座標和右上點的座標，求他們的面積和。

hdu 1255：http://acm.hdu.edu.cn/showproblem.php?pid=1255

題意：給你每個長方形的左下點的座標和右上點的座標，求出被這些矩形覆蓋過至少兩次的區域的面積

與上一題議題差別在第一題求總的面積，第二題求覆蓋兩次以上的面積。就len2表示下。

 

1.q[rt].s>1 : 說明該區間被覆蓋兩次或以上，那麼長度就可以直接計算，就是該區間的長度

剩下的情況就是q[rt].s=1或q[rt].s=0

2.先看葉子節點，因爲是葉子沒有孩子了，所以被覆蓋兩次貨以上的長度就是0（無論q[rt].s=1或q[rt].s=0都是0，因爲是葉子。。。）

3.不是葉子節點 ，且q[rt].s=1.注意這裏，q[rt].s=1確切的意義是什麼，應該是，可以確定，這個區間被完全覆蓋了1次，而有沒有被完全覆蓋兩次或以上則不知道無法確定，那麼怎麼怎麼辦了，只要加上q[ls].len1+q[rs].len1  即，看看左右孩子區間被覆蓋了一次或以上的長度，那麼疊加在雙親上就是雙親被覆蓋兩次或以上的長度

3.不是葉子節點，且q[rt].s=0，確切的意義應該是不完全不知道被覆蓋的情況（不知道有沒有被覆蓋，被覆蓋了幾次，長度是多少都不知道），這種情況，只能由其左右孩子的信息所得

q[ls].len2+q[rs].len2  , 即直接將左右孩子給覆蓋了兩次或以上的長度加起來，這樣才能做到不重不漏

#include <cstdio>
#include <queue>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <map>
#include <set>
#include <bitset>
#include <stack>
#define ull unsigned long long
#define ls rt<<1
#define rs rt<<1|1
#define mems(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long ll;
const ll mod=1000000007;
const int N=2210;
const double pi=acos(-1);
const int inf=0x3f3f3f3f;
const int M=50000+5;

struct edge
{
    double l,r;//這條線的左右端點的橫座標
    double h;//線段縱座標
    int f;//矩形的上邊 1 ，下邊 -1
    edge() {}
    edge(double l,double r,double h,int f):l(l),r(r),h(h),f(f) {}
    bool operator <(const edge &a) const
    {
        return h<a.h;
    }
} e[N<<1];
bool cmp(edge a,edge b)
{
    return a.h<b.h;
}
struct node
{
    int l,r;//橫座標區間
    int s;//該節點被覆蓋的情況
    double len1;//區間被覆蓋一次以上的長度
    double len2;//區間被覆蓋兩次的長度
} q[N<<3];//每個矩形有兩個橫座標，所以是2*4N的節點
//double sum[N<<2];
//int cnt[n<<2];
double x[N<<2];
int binary(double c,int low,int top)//二分查找該點的離散值
{
    while(low<=top)
    {
        int mid=(low+top)>>1;
        if(x[mid]==c)     return mid;
        else if(x[mid]>c) top=mid;
        else low=mid+1;
    }
    return -1;
}

void build(int l,int r,int rt)
{
    q[rt].l=l;
    q[rt].r=r;
    q[rt].s=q[rt].len1=q[rt].len2=0;
    if(l==r)
        return;
    int mid=(l+r)>>1;
    build(l,mid,ls);
    build(mid+1,r,rs);
}
void pushup(int rt)
{
    if(q[rt].s)//非零，已經被整段覆蓋
    {
        q[rt].len1=x[q[rt].r+1]-x[q[rt].l];
    }
    else if(q[rt].l==q[rt].r)//這是一個點
    {
        q[rt].len1=0;
    }
    else
    {
        q[rt].len1=q[ls].len1+q[rs].len1;
    }

//    if(q[rt].s>1)//該區間被覆蓋兩次以上
//        q[rt].len2=x[q[rt].r+1]-x[q[rt].l];
//    else if(q[rt].l==q[rt].r)
//        q[rt].len2=0;
//    else if(q[rt].s==1)
//        q[rt].len2=q[ls].len1+q[rs].len1;
//    else
//        q[rt].len2=q[ls].len2+q[rs].len2;
}
void update(int l,int r,int c,int rt)
{
    if(q[rt].l==l&&r==q[rt].r)
    {
        q[rt].s+=c;
        pushup(rt);
        return;
    }
    int mid=(q[rt].l+q[rt].r)>>1;
    if(r<=mid)
        update(l,r,c,ls);
    else if(l>mid)
        update(l,r,c,rs);
    else
    {
        update(l,mid,c,ls);
        update(mid+1,r,c,rs);
    }
    pushup(rt);
}
int main()
{
    int n;
    int p=1;
    while(scanf("%d",&n))
    {
        int tot=0;
        for(int i=0; i<n; i++)
        {
            double x1,x2,y1,y2;
            scanf("%lf%lf%lf%lf",&x1,&y1,&x2,&y2);
            e[tot]=edge(x1,x2,y1,1);
            e[tot+1]=edge(x1,x2,y2,-1);
            x[tot]=x1;
            x[tot+1]=x2;
            tot+=2;
        }
        sort(e,e+tot);
        //離散化座標
        sort(x,x+tot);
        int k=unique(x,x+tot)-x;//去重
        build(0,k-1,1);
        double ans=0.0;
        for(int i=0;i<tot;i++)
        {
            int l=lower_bound(x,x+k,e[i].l)-x;
            int r=lower_bound(x,x+k,e[i].r)-x-1;
            update(l,r,e[i].f,1);
            ans+=(e[i+1].h-e[i].h)*q[1].len1;
        }
        printf("Test case #%d\n",p++);
        printf("Total explored area: %.2f\n\n",ans);
    }
    return 0;
}