HDU3642 Get The Treasury —— 求矩形交体积 线段树 + 扫描线 + 离散化

题目链接：https://vjudge.net/problem/HDU-3642

 

Jack knows that there is a great underground treasury in a secret region. And he has a special device that can be used to detect treasury under the surface of the earth. One day he got outside with the device to ascertain the treasury. He chose many different locations on the surface of the earth near the secret region. And at each spot he used the device to detect treasury and got some data from it representing a region, which may contain treasury below the surface. The data from the device at each spot is six integers x ₁, y ₁, z ₁, x ₂, y ₂ and z ₂ (x ₁<x ₂, y ₁<y ₂, z ₁<z ₂). According to the instruction of the device they represent the range of x, y and z coordinates of the region. That is to say, the x coordinate of the region, which may contain treasury, ranges from x ₁ to x ₂. So do y and z coordinates. The origin of the coordinates is a fixed point under the ground. 
Jack can’t get the total volume of the treasury because these regions don’t always contain treasury. Through years of experience, he discovers that if a region is detected that may have treasury at more than two different spots, the region really exist treasure. And now Jack only wants to know the minimum volume of the treasury. 
Now Jack entrusts the problem to you. 

InputThe first line of the input file contains a single integer t, the number of test cases, followed by the input data for each test case. 
 Each test case is given in some lines. In the first line there is an integer n (1 ≤ n ≤ 1000), the number of spots on the surface of the earth that he had detected. Then n lines follow, every line contains six integers x ₁, y ₁, z ₁, x ₂, y ₂ and z₂, separated by a space. The absolute value of x and y coordinates of the vertices is no more than 10 ⁶, and that of z coordinate is no more than 500. 

OutputFor each test case, you should output “Case a: b” in a single line. a is the case number, and b is the minimum volume of treasury. The case number is counted from one. 
Sample Input

2
1
0 0 0 5 6 4
3
0 0 0 5 5 5
3 3 3 9 10 11
3 3 3 13 20 45

Sample Output

Case 1: 0
Case 2: 8

 

 

 

代码如下：

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <string>
#include <set>
using namespace std;
typedef long long LL;
const double EPS = 1e-8;
const int INF = 2e9;
const LL LNF = 2e18;
const int MAXN = 1e3+10;

int times[MAXN<<3]; //times为该区间被覆盖的次数
int one[MAXN<<3], two[MAXN<<3], more[MAXN<<3];
int Z[MAXN<<1], X[MAXN<<1]; //Z、X分别用于离散化Z坐标和X坐标

struct Cube
{
    int x1, y1, z1,x2, y2, z2;
}cube[MAXN];

struct Line
{
    int le, ri, h, id;
    bool operator<(const Line &a)const{
        return h<a.h;
    }

}line[MAXN<<1];

void push_up(int u, int l, int r)
{
    if(times[u]>=3) //该区间被覆盖三次
    {
        more[u] = X[r] - X[l];
        two[u] = X[r] - X[l];
        one[u] = X[r] - X[l];
    }
    else if(times[u]==2)    //两次
    {
        more[u] = (l+1==r)?0:(one[u*2]+one[u*2+1]);
        two[u] = X[r] - X[l];
        one[u] = X[r] - X[l];
    }
    else if(times[u]==1)    //一次
    {
        more[u] = (l+1==r)?0:(two[u*2]+two[u*2+1]);
        two[u] = (l+1==r)?0:(one[u*2]+one[u*2+1]);
        one[u] = X[r] - X[l];
    }
    else    //没有被覆盖
    {
        more[u] = (l+1==r)?0:(more[u*2]+more[u*2+1]);
        two[u] = (l+1==r)?0:(two[u*2]+two[u*2+1]);
        one[u] = (l+1==r)?0:(one[u*2]+one[u*2+1]);
    }
}

//此种线段树的操作对象为连续型，即最小的元素为长度为1的区间[l,r],其中l和r只代表端点(r-l>=1)，用于确定
//区间的位置和长度，l和r本身没有特别的含义。而以往做的什么单点更新之类的，都属于离散型，在l处和r处是有含义的
void add(int u, int l, int r, int x, int y, int v)
{
    if(x<=l && r<=y)
    {
        times[u] += v;
        push_up(u, l, r);
        return;
    }

    int mid = (l+r)>>1;
    if(x<=mid-1) add(u*2, l, mid, x, y, v);
    if(y>=mid+1) add(u*2+1, mid, r, x, y, v);
    push_up(u, l, r);
}

int main()
{
    int T, n;
    scanf("%d", &T);
    for(int kase = 1; kase<=T; kase++)
    {
        scanf("%d", &n);
        int numZ = 0;
        for(int i = 1; i<=n; i++)
        {
            scanf("%d%d%d", &cube[i].x1,&cube[i].y1,&cube[i].z1);
            scanf("%d%d%d", &cube[i].x2,&cube[i].y2,&cube[i].z2);
            Z[++numZ] = cube[i].z1; Z[++numZ] = cube[i].z2;
        }

        sort(Z+1, Z+1+numZ);    //离散化Z坐标
        numZ = unique(Z+1, Z+1+numZ) - (Z+1);

        LL volume = 0;
        for(int i = 1; i<numZ; i++) //枚举每一个平面（平面垂直于Z轴）
        {
            int numLine = 0, numX = 0;
            for(int j = 1; j<=n; j++)
            if(cube[j].z1<=Z[i] && Z[i+1]<=cube[j].z2)  //获得在此平面有效的长方体，然后保存他们在此平面的上下边。
            {
                line[++numLine].le = cube[j].x1; line[numLine].ri = cube[j].x2;
                line[numLine].h = cube[j].y1; line[numLine].id = 1;
                line[++numLine].le = cube[j].x1; line[numLine].ri = cube[j].x2;
                line[numLine].h = cube[j].y2; line[numLine].id = -1;
                X[++numX] = cube[j].x1; X[++numX] = cube[j].x2;
            }

            sort(line+1, line+1+numLine);   //在此平面中，根据高度（即y坐标）对线段进行排序
            sort(X+1, X+1+numX);
            numX = unique(X+1, X+1+numX) - (X+1);   //离散化X坐标

            memset(times, 0, sizeof(times));
            memset(more, 0, sizeof(more));
            memset(two, 0, sizeof(two));
            memset(one, 0, sizeof(one));

            LL area = 0;
            for(int j = 1; j<numLine; j++)  //计算此平面的有效面积
            {
                int l = upper_bound(X+1, X+1+numX, line[j].le) - (X+1);
                int r = upper_bound(X+1, X+1+numX, line[j].ri) - (X+1);
                add(1, 1, numX, l, r, line[j].id);
                area += 1LL*more[1]*(line[j+1].h-line[j].h);
            }
            volume += 1LL*area*(Z[i+1]-Z[i]);   //计算两个平面之间的体积，然后再累加
        }
        printf("Case %d: %lld\n", kase, volume);
    }
}