hdu 2771(uva 12171) Sculpture bfs+离散化

题意：

给出一些边平行于坐标轴的长方体，这些长方体可能相交。也可能相互嵌套。这些长方体形成了一个雕塑，求这个雕塑的整体积和表面积。

题解：

最easy想到直接进行bfs或者dfs统计，但此题的麻烦之处在于求整个雕塑的外表面积和雕塑内部可能出现四个长方体所搭成的空心。空心不能计算到表面积中，可是计算整体积却要计入，于是直接bfs或者dfs不优点理。于是，能够想到直接统计整个雕塑外围的全部小方块。就可以非常方便地求出雕塑地表面积和体积(雕塑地整体积＝＝整个空间地体积－外围想方块的体积），另一点就是因为坐标范围达到1-1000，
整个空间的大小达到了1000*1000*1000 ＝ 1e9, 直接bfs明显会超时，因为长方体的个数最大仅仅有50个，于是能够对原坐标进行离散化，把每一维的坐标离散化后，整个空间的大小缩小到了100＊100＊100 ＝ 1e6，于是这个问题就攻克了。

（具体參考代码。凝视地非常具体）。

代码：（參考了标程。非常美丽地代码）

#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
const int maxn = 50 + 5;
const int maxc = 1000 + 1;

int n;
int x0[maxn], y0[maxn], z0[maxn], x1[maxn], y1[maxn], z1[maxn];
int xs[maxn*2], ys[maxn*2], zs[maxn*2], nx, ny, nz;
int color[maxn*2][maxn*2][maxn*2];
int dx[] = {0, 0, 0, 0, -1, 1};
int dy[] = {0, 0, -1, 1, 0, 0};
int dz[] = {-1, 1, 0, 0, 0, 0};

struct Cell
{
    int x, y, z;
    Cell(int x = 0, int y = 0, int z = 0) : x(x), y(y), z(z) {}
    void setVis() const {
        color[x][y][z] = 2;
    }
    int volume() const {
        return (xs[x+1]-xs[x])*(ys[y+1]-ys[y])*(zs[z+1]-zs[z]);
    }
    Cell neighbor(int i) const {
        return Cell(x+dx[i], y+dy[i], z+dz[i]);
    }
    bool valid() const {
        return x>=0 && x<nx-1 && y>=0 && y<ny-1 && z>=0 && z<nz-1;
    }
    bool solid() const {
        return color[x][y][z] == 1;
    }
    int area(int i) const {
        if (dx[i] != 0) return (ys[y+1]-ys[y])*(zs[z+1]-zs[z]);
        else if(dy[i] != 0) return (xs[x+1]-xs[x])*(zs[z+1]-zs[z]);
        else return (xs[x+1]-xs[x])*(ys[y+1]-ys[y]);
    }
    bool getVis() const {
        return color[x][y][z] == 2;
    }
};

void discretize(int* x, int& n)     //对每一维进行离散化
{
    sort(x, x + n);
    n = (int)(unique(x, x+n) - x);
}
int ID(int* x, int n, int x0)   //找到原坐标离散化后的新坐标
{
    return (int)(lower_bound(x, x+n, x0) - x);
}
void floodfill(int& s, int& v)  //bfs 统计
{
    s = v = 0;
    Cell c; c.setVis();
    queue<Cell> Q; Q.push(c);

    while (!Q.empty())
    {
        Cell now = Q.front(); Q.pop();
        v += now.volume();      //统计雕塑外围的整体积
        for (int i = 0; i < 6; i++)
        {
            Cell nxt = now.neighbor(i);
            if (!nxt.valid()) continue;     //越界
            if (nxt.solid()) s += now.area(i);      //统计雕塑外围表面积
            else if(!nxt.getVis())
            {
                nxt.setVis();
                Q.push(nxt);
            }
        }
    }
    v = maxc*maxc*maxc - v;     //雕塑体积 ＝＝ 整个空间的体积－雕塑外围体积
}
int main()
{
//    freopen("/Users/apple/Desktop/in.txt", "r", stdin);

    int t; scanf("%d", &t);

    while (t--)
    {
        scanf("%d", &n);
        nx = ny = nz = 2;
        xs[0] = ys[0] = zs[0] = 0;
        xs[1] = ys[1] = zs[1] = maxc;   //存入边界坐标
        for (int i = 0; i < n; i++)
        {
            scanf("%d%d%d", &x0[i], &y0[i], &z0[i]);
            scanf("%d%d%d", &x1[i], &y1[i], &z1[i]);
            x1[i] += x0[i], y1[i] += y0[i], z1[i] += z0[i];
            xs[nx++] = x0[i], xs[nx++] = x1[i];
            ys[ny++] = y0[i], ys[ny++] = y1[i];
            zs[nz++] = z0[i], zs[nz++] = z1[i];
        }
        discretize(xs, nx), discretize(ys, ny), discretize(zs, nz);
        memset(color, 0, sizeof(color));    //染色
        for (int i = 0; i < n; i++)
        {
            int X1 = ID(xs, nx, x0[i]), X2 = ID(xs, nx, x1[i]);
            int Y1 = ID(ys, ny, y0[i]), Y2 = ID(ys, ny, y1[i]);
            int Z1 = ID(zs, nz, z0[i]), Z2 = ID(zs, nz, z1[i]);
            for (int X = X1; X < X2; X++)       //对离散化后的坐标依次染色
            {
                for (int Y = Y1; Y < Y2; Y++)
                {
                    for (int Z = Z1; Z < Z2; Z++)
                    {
                        color[X][Y][Z] = 1;
                    }
                }
            }
        }
        int s, v;
        floodfill(s, v);
        printf("%d %d\n", s, v);
    }

    return 0;
}