Given N axis-aligned rectangles where N > 0, determine if they all together form an exact cover of a rectangular region.
Each rectangle is represented as a bottom-left point and a top-right point. For example, a unit square is represented as [1,1,2,2]. (coordinate of bottom-left point is (1, 1) and top-right point is (2, 2)).
The meaning of the question is to give N rectangles, whether they can just form a large rectangle R.
My idea:
Condition of formation: The area of N rectangles is equal to the area of the large rectangle R, and there is no overlap between the N rectangles.
It is easy to check that the areas are equal, but how to judge whether there is overlap between N rectangles. Each rectangle consists of several 1X1 unit rectangles, represented by the lower left point of the unit rectangle. If there is an overlapping part, it will inevitably appear more than twice, in this case, return false.
However, the complexity of the above approach is the area sum of N rectangles, TLE.
This question is quite tricky~
In fact, there are only three types of rectangular points, as shown in the following figure:
When N rectangles just form a large rectangle R, the number of blue points must be 4 and the area is equal.
There are two ways to count the number of blue dots:
1. Bit operation
Use four binary bits to record the position of each dot (lower left, upper left, lower right, upper right), and finally count the number of 0001, 0010, 0100, 1000 number. You can directly return false to prune when there are duplicate points, but the actual effect is not obvious.
2. The
green point can be seen as a combination of two blue points, and the red point can be seen as a combination of four blue points. Use a set directly. For any vertex traversed, if it already exists in the set, delete the point, if not, add it, so that the green and red points will be filtered out, and the rest will be Blue dots, we just need to see if the number of blue dots is four.
//方法一
class Solution {
public:
bool isRectangleCover(vector<vector<int>>& rectangles) {
unordered_map<string, int> m;
int min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN, area = 0, cnt = 0;
for (auto rect : rectangles) {
min_x = min(min_x, rect[0]);
min_y = min(min_y, rect[1]);
max_x = max(max_x, rect[2]);
max_y = max(max_y, rect[3]);
area += (rect[2] - rect[0]) * (rect[3] - rect[1]);
if (!isValid(m, to_string(rect[0]) + "_" + to_string(rect[1]), 1)) return false; // bottom-left
if (!isValid(m, to_string(rect[0]) + "_" + to_string(rect[3]), 2)) return false; // top-left
if (!isValid(m, to_string(rect[2]) + "_" + to_string(rect[3]), 4)) return false; // top-right
if (!isValid(m, to_string(rect[2]) + "_" + to_string(rect[1]), 8)) return false; // bottom-right
}
for (auto it = m.begin(); it != m.end(); ++it) {
int t = it->second;
if (t != 15 && t != 12 && t != 10 && t != 9 && t != 6 && t != 5 && t!= 3) {
++cnt;
}
}
return cnt == 4 && area == (max_x - min_x) * (max_y - min_y);
}
bool isValid(unordered_map<string, int>& m, string corner, int type) {
int& val = m[corner];
if (val & type) return false;
val |= type;
return true;
}
};//方法二
class Solution {
public:
bool isRectangleCover(vector<vector<int>>& rectangles) {
unordered_set<string> st;
int min_x = INT_MAX, min_y = INT_MAX, max_x = INT_MIN, max_y = INT_MIN, area = 0;
for (auto rect : rectangles) {
min_x = min(min_x, rect[0]);
min_y = min(min_y, rect[1]);
max_x = max(max_x, rect[2]);
max_y = max(max_y, rect[3]);
area += (rect[2] - rect[0]) * (rect[3] - rect[1]);
string s1 = to_string(rect[0]) + "_" + to_string(rect[1]); // bottom-left
string s2 = to_string(rect[0]) + "_" + to_string(rect[3]); // top-left
string s3 = to_string(rect[2]) + "_" + to_string(rect[3]); // top-right
string s4 = to_string(rect[2]) + "_" + to_string(rect[1]); // bottom-right
if (st.count(s1)) st.erase(s1);
else st.insert(s1);
if (st.count(s2)) st.erase(s2);
else st.insert(s2);
if (st.count(s3)) st.erase(s3);
else st.insert(s3);
if (st.count(s4)) st.erase(s4);
else st.insert(s4);
}
string t1 = to_string(min_x) + "_" + to_string(min_y);
string t2 = to_string(min_x) + "_" + to_string(max_y);
string t3 = to_string(max_x) + "_" + to_string(max_y);
string t4 = to_string(max_x) + "_" + to_string(min_y);
if (!st.count(t1) || !st.count(t2) || !st.count(t3) || !st.count(t4) || st.size() != 4) return false;
return area == (max_x - min_x) * (max_y - min_y);
}
};