Perfect Rectangle(完美矩形)
我们有 N 个与坐标轴对齐的矩形, 其中 N > 0, 判断它们是否能精确地覆盖一个矩形区域。
每个矩形用左下角的点和右上角的点的坐标来表示。例如, 一个单位正方形可以表示为 [1,1,2,2]。 ( 左下角的点的坐标为 (1, 1) 以及右上角的点的坐标为 (2, 2) )。

示例 1:
rectangles = [
[1,1,3,3],
[3,1,4,2],
[3,2,4,4],
[1,3,2,4],
[2,3,3,4]
] 返回 true。5个矩形一起可以精确地覆盖一个矩形区域。

示例 2:
rectangles = [
[1,1,2,3],
[1,3,2,4],
[3,1,4,2],
[3,2,4,4]
] 返回 false。两个矩形之间有间隔,无法覆盖成一个矩形。

示例 3:
rectangles = [
[1,1,3,3],
[3,1,4,2],
[1,3,2,4],
[3,2,4,4]
] 返回 false。图形顶端留有间隔,无法覆盖成一个矩形。

示例 4:
rectangles = [
[1,1,3,3],
[3,1,4,2],
[1,3,2,4],
[2,2,4,4]
] 返回 false。因为中间有相交区域,虽然形成了矩形,但不是精确覆盖。 这道题我在写前两个解法的时候还没ac通过,但是已经忍不住要写了。思路还是很清晰的,遍历矩形,算有没有重合,面积累加,最后看看总面积是不是最大范围的覆盖的矩形的面积。
第一遍暴力解法:
class Solution {
public:
bool Cover(vector<int>& a, vector<int>&b)
{
if (min(a[], a[]) >= max(b[], b[]) || max(a[], a[]) <= min(b[], b[])
|| min(a[], a[]) >= max(b[], b[]) || max(a[], a[]) <= min(b[], b[]))
{
return false;
}
return true;
}
bool isRectangleCover(vector<vector<int>>& rectangles) {
int minx, miny, maxx, maxy;
minx = miny = INT_MAX;
maxx = maxy = INT_MIN;
long long int sum = ;
for (int i = ; i < rectangles.size();i++)
{
for (int r = ; r < i;r++)
{
if (Cover(rectangles[i], rectangles[r]))
{
return false;
}
}
minx = min(minx, min(rectangles[i][], rectangles[i][]));
miny = min(miny, min(rectangles[i][], rectangles[i][]));
maxx = max(maxx, max(rectangles[i][], rectangles[i][]));
maxy = max(maxy, max(rectangles[i][], rectangles[i][]));
sum += abs((rectangles[i][] - rectangles[i][])*(rectangles[i][] - rectangles[i][]));
}
return sum == (maxx - minx)*(maxy - miny);
}
};
果不其然挂了,测试最后两组都是3w+的数据量
第二遍:四叉树解法
class QuadNode
{
public:
enum{
quad_1,//四个象限
quad_2,
quad_3,
quad_4,
quad_count,
};
vector<vector<int>>* data;
QuadNode* Children[quad_count];//孩子指针,数组大小为8
QuadNode* Parent;//父节点指针
typedef std::list<int> RecList;
typedef std::list<int>::iterator RecListIter;
RecList rectlist;//携带的参数 实体列表
int quad;//在父节点中的象限
int deep;//自己所在的层索引
int minx,miny;
int maxx,maxy;
QuadNode(vector<vector<int>>* data, int x1, int x2, int y1, int y2, int dp, int qd)
{
minx = x1;
maxx = x2;
miny = y1;
maxy = y2;
deep = dp;
quad = qd;
Parent = NULL;
this->data = data;
memset(Children, , sizeof(Children));
}
~QuadNode()
{
for (int i = ; i < quad_count; i++)
{
if (Children[i])
{
delete Children[i];
Children[i] = NULL;
}
}
rectlist.clear();
}
QuadNode* GetDeepest(int index)
{
if (deep > )
{
//4个孩子都要创建
for (int r = ; r < QuadNode::quad_count; r++)
{
if (!Children[r])
{
int ix = r == QuadNode::quad_1 || r == QuadNode::quad_3 ? minx : (minx + maxx) / ;
int ax = r == QuadNode::quad_1 || r == QuadNode::quad_3 ? (minx + maxx) / : maxx; int iy = r == QuadNode::quad_1 || r == QuadNode::quad_2 ? miny : (miny + maxy) / ;
int ay = r == QuadNode::quad_1 || r == QuadNode::quad_2 ? (miny + maxy) / : maxy;
QuadNode *node = new QuadNode(data, ix, ax, iy, ay, deep - , r);
node->Parent = this;
Children[r] = node;
}
if (Children[r]->CheckInRange(index))
{
return Children[r]->GetDeepest(index);
}
}
}
return this;
}
bool CheckInRange(int index)
{
if ((*data)[index][] >= minx && (*data)[index][] <= maxx && (*data)[index][] >= miny && (*data)[index][] <= maxy)
{
return true;
}
return false;
}
bool CheckCover(int index)
{
QuadNode* n = GetDeepest(index);
QuadNode* parent = n->Parent;
while (parent)
{
if (parent->CheckWithTrianglelist(index))
{
return true;
}
parent = parent->Parent;
} if (n->CollisionCheck(index))
return true;
n->rectlist.push_back(index);
return false;
}
bool CollisionCheck(int index)
{
return CheckWithTrianglelist(index) || CheckWithSubSpace(index);
}
bool CheckWithTrianglelist(int index)
{
RecListIter itr = rectlist.begin();
while (itr != rectlist.end())
{
int id = *itr;
if (Cover((*data)[id], (*data)[index]))
{
return true;
}
itr++;
}
return false;
} bool CheckWithSubSpace(int index)
{
bool collision = false;
for (int i = ; i < quad_count && Children[i]; i++)
{
int vec[] = { minx, miny, maxx, maxy };
vector<int> para(vec, vec + );
if (Cover((*data)[index], para))
{
collision |= Children[i]->CollisionCheck(index);
}
if (collision)
{
return true;
}
}
return false;
} bool Cover(vector<int>& a, vector<int>&b)
{
if (min(a[], a[]) >= max(b[], b[]) || max(a[], a[]) <= min(b[], b[])
|| min(a[], a[]) >= max(b[], b[]) || max(a[], a[]) <= min(b[], b[]))
{
return false;
}
return true;
}
};
class Solution {
public:
int GetMax2Power(int xmax, int ymax, int& lg)
{
int max = xmax;
if (ymax > max)
max = ymax;
if ((max & (max - )) == )
{
double L = log(max*1.0) / log(2.0);
lg = (int)L + ;
return max;
}
else
{
double L = log(max*1.0) / log(2.0);
lg = (int)L + ;
return (int)pow( * 1.0, lg - 1.0);
}
}
bool isRectangleCover(vector<vector<int>>& rectangles) {
int minx, miny, maxx, maxy;
minx = miny = INT_MAX;
maxx = maxy = INT_MIN;
long long int sum = ;
for (int i = ; i < rectangles.size(); i++)
{
minx = min(minx, min(rectangles[i][], rectangles[i][]));
miny = min(miny, min(rectangles[i][], rectangles[i][]));
maxx = max(maxx, max(rectangles[i][], rectangles[i][]));
maxy = max(maxy, max(rectangles[i][], rectangles[i][]));
}
int mx = max(abs(maxx), abs(minx));
int my = max(abs(maxy), abs(miny));
int range, lg;
range = GetMax2Power(mx, my, lg);
//四叉树
QuadNode* root = new QuadNode(&rectangles, -range, range, -range, range, lg, ); for (int i = ; i < rectangles.size();i++)
{
if (root->CheckCover(i))
{
return false;
}
sum += abs((rectangles[i][] - rectangles[i][])*(rectangles[i][] - rectangles[i][]));
}
delete root;
return sum == (maxx - minx)*(maxy - miny);
}
};
以为没什么问题了,跑一下又超时了,真是恶心的一p啊。拿测试数据跑一跑发现,几乎95%的数据都在边界上,四叉树无法往下细化。写个四叉树容易吗???
只能硬着头皮继续想了,果然没有想到。参考了下别人的歪门邪道,感觉前面写的东西都白瞎了。有时候解决问题,还得靠技巧。
解法三:所有的矩形顶点,有且只有四个边角是只出现一次,剩下的顶点要么两次,要么四次
long long int getHash(int x, int y)
{
long long int t = << ;
return x*t + y;
}
bool isRectangleCover(vector<vector<int>>& rectangles) {
int minx, miny, maxx, maxy;
minx = miny = INT_MAX;
maxx = maxy = INT_MIN;
long long int sum = ;
unordered_set<long long int> st;
for (int i = ; i < rectangles.size(); i++)
{
minx = min(minx, min(rectangles[i][], rectangles[i][]));
miny = min(miny, min(rectangles[i][], rectangles[i][]));
maxx = max(maxx, max(rectangles[i][], rectangles[i][]));
maxy = max(maxy, max(rectangles[i][], rectangles[i][]));
sum += abs((rectangles[i][] - rectangles[i][])*(rectangles[i][] - rectangles[i][]));
long long int lu = getHash(rectangles[i][], rectangles[i][]);
long long int ld = getHash(rectangles[i][], rectangles[i][]);
long long int ru = getHash(rectangles[i][], rectangles[i][]);
long long int rd = getHash(rectangles[i][], rectangles[i][]);
if (st.count(lu) == ) st.insert(lu);
else st.erase(lu);
if (st.count(ld) == ) st.insert(ld);
else st.erase(ld);
if (st.count(ru) == ) st.insert(ru);
else st.erase(ru);
if (st.count(rd) == ) st.insert(rd);
else st.erase(rd);
} return sum == (maxx - minx)*(maxy - miny) && st.size() ==
&& st.count(getHash(minx, miny)) ==
&& st.count(getHash(minx, maxy)) ==
&& st.count(getHash(maxx, miny)) ==
&& st.count(getHash(maxx, maxy)) == ;
}
吐血!
Perfect Rectangle(完美矩形)的更多相关文章
- [LeetCode] Perfect Rectangle 完美矩形
Given N axis-aligned rectangles where N > 0, determine if they all together form an exact cover o ...
- 391 Perfect Rectangle 完美矩形
有 N 个与坐标轴对齐的矩形, 其中 N > 0, 判断它们是否能精确地覆盖一个矩形区域.每个矩形用左下角的点和右上角的点的坐标来表示.例如, 一个单位正方形可以表示为 [1,1,2,2]. ( ...
- Leetcode 391.完美矩形
完美矩形 我们有 N 个与坐标轴对齐的矩形, 其中 N > 0, 判断它们是否能精确地覆盖一个矩形区域. 每个矩形用左下角的点和右上角的点的坐标来表示.例如, 一个单位正方形可以表示为 [1,1 ...
- Java实现 LeetCode 391 完美矩形
391. 完美矩形 我们有 N 个与坐标轴对齐的矩形, 其中 N > 0, 判断它们是否能精确地覆盖一个矩形区域. 每个矩形用左下角的点和右上角的点的坐标来表示.例如, 一个单位正方形可以表示为 ...
- [Swift]LeetCode391. 完美矩形 | Perfect Rectangle
Given N axis-aligned rectangles where N > 0, determine if they all together form an exact cover o ...
- [LeetCode] Rectangle Area 矩形面积
Find the total area covered by two rectilinear rectangles in a2D plane. Each rectangle is defined by ...
- [LeetCode] Maximal Rectangle 最大矩形
Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and ...
- Perfect Scrollbar – 完美的 jQuery 滚动条插件
Perfect Scrollbar 是一个很小的,但完美的 jQuery 滚动插件.滚动条不会影响原来的设计布局,滚动条的设计是完全可定制的.你可以改变几乎所有的 CSS 样式的滚动条,滚动条设计对脚 ...
- Leetcode: Perfect Rectangle
Given N axis-aligned rectangles where N > 0, determine if they all together form an exact cover o ...
随机推荐
- 设置PATH 环境变量、pyw格式、命令行运行python程序与多重剪贴板
pyw格式简介: 与py类似,我认为他们俩卫衣的不同就是前者运行时候不显示终端窗口,后者显示 命令行运行python程序: 在我学习python的过程中我通常使用IDLE来运行程序,这一步骤太过繁琐( ...
- MVC设计模式与JavaWEB三层架构
一.MVC设计模式 MVC模式(Model-View-Controller)是软件工程中的一种软件架构模式,把软件系统分为三个基本部分:模型(Model).视图(View)和控制器(Controlle ...
- Action访问ServletAPI的三种方式
一.前言 Struts是一种基于MVC设计模式的web应用框架,主要担任C的角色,用于分离页面显示和业务逻辑处理,那其实在我们学习jsp的时候学过一个具有类似功能的东西——servlet.其实Stru ...
- 洛谷——P1886 滑动窗口|| POJ——T2823 Sliding Window
https://www.luogu.org/problem/show?pid=1886#sub || http://poj.org/problem?id=2823 题目描述 现在有一堆数字共N个数字( ...
- we标签
功能: · 辅助标签.配合其它标签使用,防止与标准html标签冲突 · 别名为test 使用方法: <we [name=key]>[value]</we& ...
- 蓝桥杯 - 带分数 (DFS)
历届试题 带分数 时间限制:1.0s 内存限制:256.0MB 问题描写叙述 100 能够表示为带分数的形式:100 = 3 + 69258 / 714. 还能够表示为:10 ...
- OSGi 和 C++
2011年 9月我参加了OSGi社区在达姆施塔特的会议,并且有机会与其他与会者探讨本机c++实现的OSGi规范的现状.在这一事件之前我也一直想写一篇博客,来描述关于当前实现OSGi规范的现状和努力—— ...
- ElasticSearch Shard——本质上是做分布式扩展,副本对于集群的稳定性有很强的影响
什么是一个Shard? Shard就是一个Lucene Index,参照文章(深入理解Shard和Lucene Index). Index需要多少个Shard? 回答这个问题,我们需要先谈谈节点,一个 ...
- ubuntu18.04中安装iNode
title: ubuntu18.04中安装iNode toc: false date: 2018-09-01 17:52:20 categories: methods tags: ubuntu iNo ...
- BZOJ 2190 欧拉函数
思路: 递推出来欧拉函数 搞个前缀和 sum[n-1]*2+3就是答案 假设仪仗队是从零开始的 视线能看见的地方就是gcd(x,y)=1的地方 倒过来一样 刨掉(1,1) 就是ans*2+1 再加一下 ...