SOJ 1071. Floors

  1 #include <cstdio>
  2 #include <vector>
  3 using namespace std;
  4 
  5 struct Point {
  6     int x, y;
  7     //Point(const Point &other) : x(other.x) , y(other.y) {}
  8     bool operator<(const Point &other) const {
  9         return x < other.x || (x == other.x && y < other.y);
 10     }
 11     bool operator==(const Point &other) const {
 12         return x == other.x && y == other.y;
 13     }
 14     bool operator!=(const Point &other) const {
 15         return !(*this == other);
 16     }
 17 };
 18 struct Tile {
 19     Point leftTop, rightBottom;
 20     //Tile(const Point &lt, const Point &rb) : leftTop(lt), rightBottom(rb) {}
 21 };
 22 
 23 bool canHorizonalCut(const Point &point, const vector<Tile> &tiles) {
 24     for (int i = 0; i < tiles.size(); ++i) {
 25         const Point &leftTop = tiles[i].leftTop;
 26         const Point &rightBottom = tiles[i].rightBottom;
 27         if (leftTop.x < point.x && point.x < rightBottom.x) return false;
 28     }
 29     return true;
 30 }
 31 
 32 bool canVerticalCut(const Point &point, const vector<Tile> &tiles) {
 33     for (int i = 0; i < tiles.size(); ++i) {
 34         const Point &leftTop = tiles[i].leftTop;
 35         const Point &rightBottom = tiles[i].rightBottom;
 36         if (leftTop.y < point.y && point.y < rightBottom.y) return false;
 37     }
 38     return true;
 39 }
 40 
 41 void cutFloor(const vector<Tile> &tiles, int &area_max) {
 42     Point mostLeftTop = tiles[0].leftTop, mostRightBottom = tiles[0].rightBottom;
 43     for (int i = 1; i < tiles.size(); ++i) {
 44         mostLeftTop = tiles[i].leftTop < mostLeftTop ? tiles[i].leftTop : mostLeftTop;
 45         mostRightBottom = mostRightBottom < tiles[i].rightBottom ? tiles[i].rightBottom : mostRightBottom;
 46     }
 47     for (int i = 0; i < tiles.size(); ++i) {
 48         Point point = tiles[i].leftTop;
 49         if (point.x != mostLeftTop.x && point.x != mostRightBottom.x && canHorizonalCut(point, tiles)) {
 50             vector<Tile> upHalf, downHalf;
 51             for (int i = 0; i < tiles.size(); ++i) {
 52                 const Point &rightBottom = tiles[i].rightBottom;
 53                 if (rightBottom.x <= point.x) upHalf.push_back(tiles[i]);
 54                 else downHalf.push_back(tiles[i]);
 55             }
 56             if (upHalf.empty() || downHalf.empty()) {
 57                 while (true);
 58             }
 59             cutFloor(upHalf, area_max);
 60             cutFloor(downHalf, area_max);
 61             return;
 62         } else if (point.y != mostLeftTop.y && point.y != mostRightBottom.y && canVerticalCut(point, tiles)) {
 63             vector<Tile> leftHalf, rightHalf;
 64             for (int i = 0; i < tiles.size(); ++i) {
 65                 const Point &rightBottom = tiles[i].rightBottom;
 66                 if (rightBottom.y <= point.y) leftHalf.push_back(tiles[i]);
 67                 else rightHalf.push_back(tiles[i]);;
 68             }
 69             if (leftHalf.empty() || rightHalf.empty()) {
 70                 while (true);
 71             }
 72             cutFloor(leftHalf, area_max);
 73             cutFloor(rightHalf, area_max);
 74             return;
 75         }
 76         point = tiles[i].rightBottom;
 77         if (point.x != mostLeftTop.x && point.x != mostRightBottom.x && canHorizonalCut(point, tiles)) {
 78             vector<Tile> upHalf, downHalf;
 79             for (int i = 0; i < tiles.size(); ++i) {
 80                 const Point &rightBottom = tiles[i].rightBottom;
 81                 if (rightBottom.x <= point.x) upHalf.push_back(tiles[i]);
 82                 else downHalf.push_back(tiles[i]);
 83             }
 84             if (upHalf.empty() || downHalf.empty()) {
 85                 while (true);
 86             }
 87             cutFloor(upHalf, area_max);
 88             cutFloor(downHalf, area_max);
 89             return;
 90         } else if (point.y != mostLeftTop.y && point.y != mostRightBottom.y && canVerticalCut(point, tiles)) {
 91             vector<Tile> leftHalf, rightHalf;
 92             for (int i = 0; i < tiles.size(); ++i) {
 93                 const Point &rightBottom = tiles[i].rightBottom;
 94                 if (rightBottom.y <= point.y) leftHalf.push_back(tiles[i]);
 95                 else rightHalf.push_back(tiles[i]);;
 96             }
 97             if (leftHalf.empty() || rightHalf.empty()) {
 98                 while (true);
 99             }
100             cutFloor(leftHalf, area_max);
101             cutFloor(rightHalf, area_max);
102             return;
103         }
104     }
105 
106     int area = (mostRightBottom.y - mostLeftTop.y) * (mostRightBottom.x - mostLeftTop.x);
107     area_max = area_max > area ? area_max : area;
108 }
109 
110 int main() {
111     int t;
112     scanf("%d", &t);
113     while (t--) {
114         int x_max, y_max;
115         scanf("%d%d", &x_max, &y_max);
116         int n;
117         scanf("%d", &n);
118         vector<Tile> tiles(n);
119         for (int i = 0; i < n; ++i) {
120             scanf("%d%d%d%d", &tiles[i].leftTop.x, &tiles[i].leftTop.y, &tiles[i].rightBottom.x, &tiles[i].rightBottom.y);
121         }
122         int area_max = 0;
123         cutFloor(tiles, area_max);
124         printf("%d\n", area_max);
125     }
126     return 0;
127 }