UVA - 12171 Sculpture(离散化+bfs)

点击打开题目链接
由n个方块组成雕塑，方块直接可以重叠和嵌套，已知每个方块最小顶点坐标值和长宽高，求形成雕塑的体积和表面积。
首先离散化坐标，将1001 * 1001 * 1001的密闭空间分成100 * 100 * 100个小方块。然后对空气块种子填充，求出空气块体积及内表面积。
代码:

#include<bits/stdc++.h>

using namespace std;
const int maxn = 50 + 5;

struct Box {
    int x, y, z, w, d, h;
    bool operator < (const Box& rhs) const {
        return x < rhs.x || (x == rhs.x && y < rhs.y) || (x == rhs.x && y == rhs.y && z < rhs.h);
    }
} b[maxn];

struct Point {
    int x, y, z;
    Point(int x = 0, int y = 0, int z = 0) :x(x), y(y), z(z) {};
};

int d[6][3] = {{1, 0, 0}, {-1, 0, 0}, {0, 1, 0}, {0, -1, 0}, {0, 0, 1}, {0, 0, -1} };
int x[maxn * 2], y[maxn * 2], z[maxn * 2];
int vis[maxn * 2][maxn * 2][maxn * 2];
int nx, ny, nz;
int T, n;
int c, v;

void init() {
    c = v = 0;
    memset(b, 0, sizeof(b));
    memset(vis, 0, sizeof(vis));
    memset(x, 0, sizeof(x));
    memset(y, 0, sizeof(y));
    memset(z, 0, sizeof(z));
    return;
}

void read_input() {
    cin >> n;
    for(int i = 0; i < n; i++) {
        cin >> b[i].x >> b[i].y >> b[i].z >> b[i].w >> b[i].d >> b[i].h;
        x[2 * i] = b[i].x, x[2 * i + 1] = b[i].x + b[i].w;
        y[2 * i] = b[i].y, y[2 * i + 1] = b[i].y + b[i].d;
        z[2 * i] = b[i].z, z[2 * i + 1] = b[i].z + b[i].h;
    }
    x[2 * n] = 0, x[2 * n + 1] = 1001;
    y[2 * n] = 0, y[2 * n + 1] = 1001;
    z[2 * n] = 0, z[2 * n + 1] = 1001;
    return;
}

int cover(double mx, double my, double mz) {
    for(int i = 0; i < n; i++) {
        if(b[i].x <= mx && b[i].x + b[i].w >= mx && b[i].y <= my && b[i].y + b[i].d >= my && b[i].z <= mz && b[i].z + b[i].h >= mz) return 1;
    }
    return 0;
}

int area(int mx, int my, int mz, int i) {
    if(i < 2) return (y[my + 1] - y[my]) * (z[mz + 1] - z[mz]);
    if(i < 4) return (x[mx + 1] - x[mx]) * (z[mz + 1] - z[mz]);
    else return (x[mx + 1] - x[mx]) * (y[my + 1] - y[my]);
}

void bfs() {
    queue<Point> que;
    que.push(Point(0, 0, 0));
    vis[0][0][0] = 1;
    while(!que.empty()) {
        Point p = que.front(); que.pop();
        v += (x[p.x + 1] - x[p.x]) * (y[p.y + 1] - y[p.y]) * (z[p.z + 1] - z[p.z]);
        for(int i = 0; i < 6; ++i){  
            int dx = p.x + d[i][0], dy = p.y + d[i][1], dz = p.z + d[i][2];
            if(dx < 0 || dx >= nx - 1 || dy < 0 || dy >= ny - 1 || dz < 0 || dz >= nz - 1) continue;
            if(vis[dx][dy][dz]) continue;
            if(cover(((double)x[dx + 1] + (double)x[dx]) / 2.0, ((double)y[dy + 1] + (double)y[dy]) / 2.0, ((double)z[dz + 1] + (double)z[dz]) / 2.0)) c += area(dx, dy, dz, i);
            else {
                vis[dx][dy][dz] = 1;
                que.push(Point(dx,dy,dz));
            }
            
        }  
    }
    v = 1001 * 1001 * 1001 - v;
}

void solve() {
    sort(b, b + n);
    sort(x, x + 2 * (n + 1));
    sort(y, y + 2 * (n + 1));
    sort(z, z + 2 * (n + 1));
    nx = unique(x, x + 2 * (n + 1)) - x;
    ny = unique(y, y + 2 * (n + 1)) - y;
    nz = unique(z, z + 2 * (n + 1)) - z;
    bfs();
    cout <<c << ' ' << v << endl;
    return;
}

int main() {
    //ios::sync_with_stdio(false);
    //freopen("D:\\input.txt", "r", stdin);
    //freopen("D:\\output.txt", "w", stdout);
    cin >> T;
    while(T--) {
        init();
        read_input();
        solve();
    }
    return 0;
}