HDU1255求矩形面積交（線段樹+掃描線）

 

分情況討論

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

剩下的情況就是cnt=1或cnt=0

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

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

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

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

 

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <map>
#include <vector>
#include <string.h>
#include <string>
#include <queue>
#include <set>
using namespace std;

typedef long long ll;
const int N = 1100;
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) {}

}e[N<<1];
bool cmp(Edge a, Edge b)
{
    return a.h < b.h;
}
struct Node {
    int l, r; //橫座標的區間，是橫座標的下標
    int s; //該節點被覆蓋的情況（是否完全被覆蓋）
    double len1; //該區間被覆蓋1次及以上的長度
    double len2; //該區間被覆蓋2次及以上的長度
}q[N<<3];//每個矩形有兩個橫座標所以需要2*4N的節點
#define ls i<<1
#define rs i<<1|1
#define m(i) ((q[i].l+q[i].r)>>1)
double x[N<<1];
void build(int i, int l, int r)
{
    q[i].r = r, q[i].l = l;
    q[i].s = q[i].len1 = q[i].len2 = 0;
    if(l == r) return;
    int mid = m(i);
    build(ls, l, mid);
    build(rs, mid+1, r);
}
void pushup(int i)
{
    if(q[i].s) //非零，已經被整段覆蓋
    {
        q[i].len1 = x[q[i].r+1] - x[q[i].l]; //左閉右開解決區間缺失問題
    }
    else if(q[i].l == q[i].r) //這是一個點不是線段
    {
        q[i].len1 = 0;
    }
    else
    {
        q[i].len1 = q[ls].len1 + q[rs].len1;
    }

    if(q[i].s>1) q[i].len2 = x[q[i].r+1] - x[q[i].l]; //該區間被覆蓋2次及以上
    else if(q[i].l == q[i].r) q[i].len2 = 0;
    else if(q[i].s == 1) q[i].len2 = q[ls].len1 + q[rs].len1;
    else q[i].len2 = q[ls].len2 + q[rs].len2;

}
void update(int i, int l, int r, int xx)
{
    if(q[i].l == l && q[i].r == r)
    {
        q[i].s += xx;
        pushup(i);
        return;
    }
    int mid = m(i);
    if(r <= mid) update(ls, l, r, xx);
    else if(l > mid) update(rs, l, r, xx);
    else
    {
        update(ls, l, mid, xx);
        update(rs, mid+1, r, xx);
    }
    pushup(i);
}
int main()
{
    int n, T;
    scanf("%d", &T);
    while(T--)
    {
        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,cmp);
        //離散化座標
        sort(x,x+tot);
        //去重
        int k = unique(x, x + tot) - x;
        build(1, 0, k-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(1, l, r, e[i].f);
            ans += (e[i+1].h - e[i].h)*q[1].len2;
        }
        printf("%.2f\n",ans);
    }
    return 0;
}