UVA ~ 12171 ~ Sculpture （离散化 + floodfill）

最新推荐文章于 2021-03-15 22:46:43 发布

张松超

最新推荐文章于 2021-03-15 22:46:43 发布

阅读量488

点赞数

分类专栏：【递归/搜索】

本文链接：https://blog.csdn.net/ZscDst/article/details/80381186

版权

【递归/搜索】专栏收录该内容

58 篇文章 0 订阅

订阅专栏

题意：某雕塑由n（n≤50）个边平行于坐标轴的长方体组成。每个长方体由六个整数x0，y0，z0，x，y，z表示（均为1~500的整数），其中x0为长方体的顶点中x坐标的最小值，x表示长方体在x方向的总长度。其他4个值类似定义。你的任务是统计这个雕像的体积和表面积，注意雕塑内部可能会有密闭的空间，其体积硬计算在总体积中，但从“外部”看不见的面不应计入表面积，雕塑可能会由多个联通块组成。

【分析】

设想有一个三维坐标范围均为1~500个三维网格，如果一开始就把输入的n个长方体“画”到网格里，接下来就可以抛开那些长方体，只在网格中进行统计了。

还记得floodfill吗？它不仅能求出连通块的个数，还能准确地找出每个连通块各由哪些方格组成。虽然本题的研究对象是三维空间中的长方体，但丝毫不影响floodfill的作用，唯一的分别就是每个格子的的相邻格子从二维情形的4个增加到了三维情形的6个。

本题麻烦之处在于雕塑中间可能有封闭区域，甚至还有可能相互嵌套，看上去很复杂。但其实可以从方面思考：不考虑雕塑本身，而考虑“空气”。在网格周围加一圈“空气”（目的是为了让所有空气格子连通），然后做一次floodfill，就可以得到空气的“内表面积”和体积。这个表面积就是雕塑的外表面积，而雕塑的体积等于总体积减去空气体积。

但还有一个大问题：空间占用。坐标为1~500的整数，一共需要500^3 = 1.25*(10^8)个单元。在第5章的例题“城市正视图”中介绍了离散化法，在这里它再次派上用场：每个维度最多有2n≤100个不同的坐标，因此可以把500*500*500的网格离散化为100*100*100的，单元格数目降为原来的1/125。在floodfill时直接使用离散化后的新网格，但在统计表面积和体积时则需要使用原始坐标。

以上内容来自《算法竞赛入门经典》

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 55;
const int MAXC = 1000 + 5;
// original data   原始数据
int n, X0[MAXN], Y0[MAXN], Z0[MAXN], X1[MAXN], Y1[MAXN], Z1[MAXN];
// discretization related   离散化相关
int nx, ny, nz;
int xs[MAXN*2], ys[MAXN*2], zs[MAXN*2];
//floodfill related   种子填充相关
const int dx[] = {1, -1,  0,  0,  0,  0};
const int dy[] = {0,  0,  1, -1,  0,  0};
const int dz[] = {0,  0,  0,  0,  1, -1};
int color[MAXN*2][MAXN*2][MAXN*2];

struct Cell
{
    int x, y, z;
    Cell(int x = 0, int y = 0, int z = 0): x(x), y(y), z(z) {}
    //不越界
    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;
    }
    //能否被访问过
    bool getVis() const
    {
        return color[x][y][z] == 2;
    }
    //设置为被访问过
    void setVis() const
    {
        color[x][y][z] = 2;
    }
    //dir方向的邻居
    Cell neighbor(int dir) const
    {
        return Cell(x+dx[dir], y+dy[dir], z+dz[dir]);
    }
    //返回体积
    int volume()  const
    {
        return (xs[x+1]-xs[x])*(ys[y+1]-ys[y])*(zs[z+1]-zs[z]);
    }
    //返回面积
    int area(int dir) const
    {
        if (dx[dir] != 0) return (ys[y+1]-ys[y])*(zs[z+1]-zs[z]);
        else if (dy[dir] != 0) return (xs[x+1]-xs[x])*(zs[z+1]-zs[z]);
        return (xs[x+1]-xs[x])*(ys[y+1]-ys[y]);
    }
};
void discretization(int* x, int& n)//离散化
{
    sort(x, x+n);
    n = unique(x, x+n) - x;
}
//获得在离散化后数组中的位置
int ID(int* x, int n, int k)
{
    return lower_bound(x, x + n, k) - x;
}
//对空气进行floodfill
void floodfill(int& s, int& v)
{
    Cell c(0, 0, 0);
    c.setVis();
    queue<Cell> Q;
    Q.push(c);
    while (!Q.empty())
    {
        c = Q.front(); Q.pop();
        v += c.volume();//加上空气体积
        for (int i = 0; i < 6; i++)
        {
            Cell c2 = c.neighbor(i);
            if (!c2.valid()) continue;//越界
            if (c2.solid()) s += c.area(i);//固体
            else if (!c2.getVis())//空气且没有被访问过
            {
                c2.setVis();
                Q.push(c2);
            }
        }
    }
    v = MAXC*MAXC*MAXC - v;
}
int main()
{
    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%d%d%d", &X0[i], &Y0[i], &Z0[i], &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];
        }
        discretization(xs, nx);
        discretization(ys, ny);
        discretization(zs, nz);
        // paint
        memset(color, 0, sizeof(color));
        for(int i = 0; i < n; i++)
        {
            int sx = ID(xs, nx, X0[i]), ex = ID(xs, nx, X1[i]);
            int sy = ID(ys, ny, Y0[i]), ey = ID(ys, ny, Y1[i]);
            int sz = ID(zs, nz, Z0[i]), ez = ID(zs, nz, Z1[i]);
            for(int X = sx; X < ex; X++)
                for(int Y = sy; Y < ey; Y++)
                    for(int Z = sz; Z < ez; Z++)
                        color[X][Y][Z] = 1;
        }
        int s = 0, v = 0;
        floodfill(s, v);
        printf("%d %d\n", s, v);
    }
    return 0;
}
/*
2
2
1 2 3 3 4 5
6 2 3 3 4 5
7
1 1 1 5 5 1
1 1 10 5 5 1
1 1 2 1 4 8
2 1 2 4 1 8
5 2 2 1 4 8
1 5 2 4 1 8
3 3 4 1 1 1
*/