poj 1151 Atlantis（多矩形面积） + poj 1177Picture（多矩形周长） 线段树进阶

题意：平面内有很多矩形，求它们组成的图形的总面积；

题解：

先将清楚一个东西，我用的扫描线是一根平行y轴的线，从左到右扫描（你也可以用一根横向的扫描线从下到上扫描），离散化就是把这跟线上的点hash一下；

1： 什么是离散化，其实很简单不要被这三个陌生的字给吓到了，这题我用的是将在y轴的点线离散化 ；

比如有y轴上有4个坐标分别是1， 30， 1000， 100000；按照一般的建树要从 1~100000；

离散化意思就是将于他们hash一下1还是1，30看成是2，1000看成3， 100000看成4，然后建树就变成了1~4；

巨大的节省了时间和空间；

poj  1151求面积这题有坐标是小数，你只能离散化建树；

下面再来看看扫描线：http://www.cnblogs.com/Booble/archive/2010/10/10/1847163.html（很详细，是求的周长）；

不想讲了，其实会求周长了，就肯定会求面积了；

先看下这个：

struct TreeLines {
    int nLines;//这个区间里包括的线段的数量
    int lLines;//这个区间左端点是否被覆盖；
    int rLines;//右端点是否被覆盖；
    //上面两个没其他用，就是辅助对nLines的计算的，先别想太多；
    int cover;//当前区间被覆盖的次数，其实也是用来辅助计算的
    int m;//测度（意思就是这个区间里被覆盖线段的总和）
} tree[8*MAXN];

注意：还有一个建树问题，别那样建，要这样建，哈哈哈！

还有就是当要插入或删除的线段x值相等时，要先插入再删除；因为如果两个矩形相邻，重合的那条边是不计入总周长的；

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
#define lson k<<1, l, mid, ff
#define rson k<<1|1, mid, r, ff
const int MAXN = 5002;
//要插入或删除的线段；
struct Lines {
    int x, y1, y2, flag;//flag=1表示要插入的线段，-1表示要删除的；
    Lines(int a, int b, int c, int d):x(a),y1(b),y2(c),flag(d){}
    Lines(){}
} lines[2*MAXN];
//扫描线（线段树）
struct TreeLines {
    int lLines, rLines, cover, m, nLines;
} tree[8*MAXN];

int yID[2*MAXN];//hash
//更新m
void updataM(int k, int l, int r) {
    if (tree[k].cover > 0)
        tree[k].m = yID[r]-yID[l];
    else {
        if (r-l == 1) tree[k].m = 0;
        else tree[k].m = tree[k<<1].m + tree[k<<1|1].m;
    }
}
//更新nLines，实际上是3个变量一起更新
void updataN(int k, int l, int r) {
    if (tree[k].cover > 0)
        tree[k].lLines = tree[k].nLines = tree[k].rLines = 1;
    else {
        if (r-l == 1)
            tree[k].lLines = tree[k].nLines = tree[k].rLines = 0;
        else {
            int ll = k<<1, rr = k<<1|1;
            tree[k].lLines = tree[ll].lLines;
            tree[k].rLines = tree[rr].rLines;
            tree[k].nLines = tree[ll].nLines+tree[rr].nLines-(tree[ll].rLines&tree[rr].lLines);
        }
    }
}

void query(int li, int ri, int k, int l, int r, int ff) {
    if (li <= yID[l] && ri >= yID[r]) {
        tree[k].cover += ff;
    }
    else if (r-l > 1){//我说是这样建树
        int mid = (l+r)/2;
        if (li < yID[mid]) query(li, ri, lson);
        if (ri > yID[mid]) query(li, ri, rson);
    }
    //这里比较重要是回归的时候更新值；（第一次做这样的）
    updataM(k, l, r);
    updataN(k, l, r);
}

int cmp(Lines aa, Lines bb) {
    if (aa.x == bb.x)
        return aa.flag > bb.flag;//这里注意，先要插入，在删除
    else return aa.x < bb.x;
}

int main() {
    int x1, x2, y1, y2, j = 1, T;
    scanf("%d", &T);
    memset(tree, 0, sizeof(tree));
    while (T--) {
        scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
        lines[j] = Lines(x1, y1, y2, 1);
        yID[j++] = y1;
        lines[j] = Lines(x2, y1, y2, -1);
        yID[j++] = y2;
    }
    sort(yID+1, yID+j);
    int k = 1;
    for(int i = 1; i < j; i++) {//删除重复节点
        yID[k++] = yID[i];
        while (yID[i] == yID[i+1]) i++;
    }
    sort(lines+1, lines+j, cmp);
    int res = 0, preN, preM = 0;
    for(int i = 1; i < j; i++) {//一个区间，一个区间的求；
        query(lines[i].y1, lines[i].y2, 1, 1, k-1, lines[i].flag);
        if (i > 1) res += preN*2*(lines[i].x-lines[i-1].x);
        res += abs(preM-tree[1].m);
        preM = tree[1].m;
        preN = tree[1].nLines;
    }
    printf("%d\n", res);
    return 0;
}

求面积的话，就只要更新测度m了；

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
using namespace std;
#define lson k<<1, l, mid, ff
#define rson k<<1|1, mid, r, ff
const int MAXN = 102;

struct Lines {
    float x, y1, y2;
    int flag;
    Lines(float a, float b, float c, int d):x(a),y1(b),y2(c),flag(d){}
    Lines(){}
} lines[2*MAXN];

struct TreeLines {
    int cover;
    float m;
} tree[8*MAXN];

float yID[2*MAXN];

void updataM(int k, int l, int r) {
    if (tree[k].cover > 0)
        tree[k].m = yID[r]-yID[l];
    else {
        if (r-l == 1) tree[k].m = 0;
        else tree[k].m = tree[k<<1].m + tree[k<<1|1].m;
    }
}

void query(float li, float ri, int k, int l, int r, int ff) {
    if (li <= yID[l] && ri >= yID[r]) {
        tree[k].cover += ff;
    }
    else if (r-l > 1){
        int mid = (l+r)/2;
        if (li < yID[mid]) query(li, ri, lson);
        if (ri > yID[mid]) query(li, ri, rson);
    }
    updataM(k, l, r);
}

int cmp(Lines aa, Lines bb) {
    if (aa.x == bb.x)
        return aa.flag > bb.flag;
    else return aa.x < bb.x;
}

int main() {
    float x1, x2, y1, y2;
    int j, T, tt = 1;
    while(scanf("%d", &T) && T) {
        memset(tree, 0, sizeof(tree));
        j = 1;
        while (T--) {
            scanf("%f%f%f%f", &x1, &y1, &x2, &y2);
            lines[j] = Lines(x1, y1, y2, 1);
            yID[j++] = y1;
            lines[j] = Lines(x2, y1, y2, -1);
            yID[j++] = y2;
        }
        sort(yID+1, yID+j);
        int k = 1;
        for(int i = 1; i < j; i++) {
            yID[k++] = yID[i];
            while (yID[i] == yID[i+1]) i++;
        }
        sort(lines+1, lines+j, cmp);
        float preM = 0;
        double res = 0;
        for(int i = 1; i < j; i++) {
            query(lines[i].y1, lines[i].y2, 1, 1, k-1, lines[i].flag);
            if (i > 1) res +=  preM*(lines[i].x-lines[i-1].x);
            preM = tree[1].m;
        }
        printf("Test case #%d\nTotal explored area: %.2f\n\n", tt++, res);
    }
    return 0;
}