SOJ 1071. Floors

题目大意：一块由t(1<=t<=100)块瓦片组成的地板，允许我们对地板进行切割，每一刀必须沿着瓦片的边缘且保证每个瓦片必须完整将地板一分为二，直到不能对地板进行切割，求不能再切割的地板的最大面积。
解题思路：分治递归。如果地板能够切割，则将地板一分为二再分别切割。判断地板能不能被切割：对每个瓦片的左上角顶点和右下角顶点所在的横纵坐标进行判断，判断水平和竖直方向上是否有其他瓦片会被切开，若无且该切法能使得原地板一分为二，则可以进行切割。若地板不能被切割，则计算面积，比较获取最大面积。

代码如下：

#include <cstdio>
#include <vector>
using namespace std;

struct Point {
    int x, y;
    //Point(const Point &other) : x(other.x) , y(other.y) {}
    bool operator<(const Point &other) const {
        return x < other.x || (x == other.x && y < other.y);
    }
    bool operator==(const Point &other) const {
        return x == other.x && y == other.y;
    }
    bool operator!=(const Point &other) const {
        return !(*this == other);
    }
};
struct Tile {
    Point leftTop, rightBottom;
    //Tile(const Point &lt, const Point &rb) : leftTop(lt), rightBottom(rb) {}
};

bool canHorizonalCut(const Point &point, const vector<Tile> &tiles) {
    for (int i = 0; i < tiles.size(); ++i) {
        const Point &leftTop = tiles[i].leftTop;
        const Point &rightBottom = tiles[i].rightBottom;
        if (leftTop.x < point.x && point.x < rightBottom.x) return false;
    }
    return true;
}

bool canVerticalCut(const Point &point, const vector<Tile> &tiles) {
    for (int i = 0; i < tiles.size(); ++i) {
        const Point &leftTop = tiles[i].leftTop;
        const Point &rightBottom = tiles[i].rightBottom;
        if (leftTop.y < point.y && point.y < rightBottom.y) return false;
    }
    return true;
}

void cutFloor(const vector<Tile> &tiles, int &area_max) {
    Point mostLeftTop = tiles[0].leftTop, mostRightBottom = tiles[0].rightBottom;
    for (int i = 1; i < tiles.size(); ++i) {
        mostLeftTop = tiles[i].leftTop < mostLeftTop ? tiles[i].leftTop : mostLeftTop;
        mostRightBottom = mostRightBottom < tiles[i].rightBottom ? tiles[i].rightBottom : mostRightBottom;
    }
    for (int i = 0; i < tiles.size(); ++i) {
        Point point = tiles[i].leftTop;
        if (point.x != mostLeftTop.x && point.x != mostRightBottom.x && canHorizonalCut(point, tiles)) {
            vector<Tile> upHalf, downHalf;
            for (int i = 0; i < tiles.size(); ++i) {
                const Point &rightBottom = tiles[i].rightBottom;
                if (rightBottom.x <= point.x) upHalf.push_back(tiles[i]);
                else downHalf.push_back(tiles[i]);
            }
            if (upHalf.empty() || downHalf.empty()) {
                while (true);
            }
            cutFloor(upHalf, area_max);
            cutFloor(downHalf, area_max);
            return;
        } else if (point.y != mostLeftTop.y && point.y != mostRightBottom.y && canVerticalCut(point, tiles)) {
            vector<Tile> leftHalf, rightHalf;
            for (int i = 0; i < tiles.size(); ++i) {
                const Point &rightBottom = tiles[i].rightBottom;
                if (rightBottom.y <= point.y) leftHalf.push_back(tiles[i]);
                else rightHalf.push_back(tiles[i]);;
            }
            if (leftHalf.empty() || rightHalf.empty()) {
                while (true);
            }
            cutFloor(leftHalf, area_max);
            cutFloor(rightHalf, area_max);
            return;
        }
        point = tiles[i].rightBottom;
        if (point.x != mostLeftTop.x && point.x != mostRightBottom.x && canHorizonalCut(point, tiles)) {
            vector<Tile> upHalf, downHalf;
            for (int i = 0; i < tiles.size(); ++i) {
                const Point &rightBottom = tiles[i].rightBottom;
                if (rightBottom.x <= point.x) upHalf.push_back(tiles[i]);
                else downHalf.push_back(tiles[i]);
            }
            if (upHalf.empty() || downHalf.empty()) {
                while (true);
            }
            cutFloor(upHalf, area_max);
            cutFloor(downHalf, area_max);
            return;
        } else if (point.y != mostLeftTop.y && point.y != mostRightBottom.y && canVerticalCut(point, tiles)) {
            vector<Tile> leftHalf, rightHalf;
            for (int i = 0; i < tiles.size(); ++i) {
                const Point &rightBottom = tiles[i].rightBottom;
                if (rightBottom.y <= point.y) leftHalf.push_back(tiles[i]);
                else rightHalf.push_back(tiles[i]);;
            }
            if (leftHalf.empty() || rightHalf.empty()) {
                while (true);
            }
            cutFloor(leftHalf, area_max);
            cutFloor(rightHalf, area_max);
            return;
        }
    }

    int area = (mostRightBottom.y - mostLeftTop.y) * (mostRightBottom.x - mostLeftTop.x);
    area_max = area_max > area ? area_max : area;
}

int main() {
    int t;
    scanf("%d", &t);
    while (t--) {
        int x_max, y_max;
        scanf("%d%d", &x_max, &y_max);
        int n;
        scanf("%d", &n);
        vector<Tile> tiles(n);
        for (int i = 0; i < n; ++i) {
            scanf("%d%d%d%d", &tiles[i].leftTop.x, &tiles[i].leftTop.y, &tiles[i].rightBottom.x, &tiles[i].rightBottom.y);
        }
        int area_max = 0;
        cutFloor(tiles, area_max);
        printf("%d
", area_max);
    }
    return 0;
}