O(n log n)时间内的线列边界框
O(n log n)时间内的线列边界框是一种用于计算机图形学和计算几何学中的算法。它用于计算给定一组线段的边界框，即能够包围住这些线段的最小矩形框。
线列边界框算法的时间复杂度为O(n log n)，其中n是线段的数量。这意味着随着线段数量的增加，算法的执行时间会以较快的速度增长。
线列边界框算法的主要步骤包括：
- 将所有线段按照其x坐标进行排序。
- 将排序后的线段分成两个子集，每个子集包含一半的线段。
- 对每个子集递归地应用线列边界框算法，直到每个子集中只有一个线段。
- 合并子集的边界框，得到整个线段集的边界框。
线列边界框算法的优势包括：
- 时间复杂度较低：O(n log n)的时间复杂度使得算法在处理大规模线段集时具有较高的效率。
- 空间效率高：算法只需要存储每个子集的边界框和排序后的线段，不需要额外的空间。
- 算法简单易实现：线列边界框算法的实现相对简单，只需要进行排序和递归操作。
线列边界框算法在计算机图形学和计算几何学中有广泛的应用场景，包括但不限于：
- 碰撞检测：用于检测线段之间是否存在碰撞或交叉。
- 区域选择：用于选择包含特定区域的线段。
- 可视化：用于生成线段集的边界框，以便在屏幕上显示或进行其他图形处理操作。
腾讯云提供了一系列与计算机图形学和计算几何学相关的产品和服务，例如云服务器、云数据库、云存储等。您可以访问腾讯云官方网站（https://cloud.tencent.com/）了解更多关于这些产品的详细信息。
相关·内容
1回答
我正在Android上做一个聊天室应用程序。在应用程序中，每5秒，它将发送一个请求，以切断连接用户的列表，并将它们作为Button放在面板上。如何有效地确定用户是否断开连接(如果应该从列表中删除)？
try1：
有2个列表，一个存储当前的在线列表间隔，两个存储下一个在线列表的间隔。那就比较..。O(n^2)比较和2n记忆；
try2：
有一个列表，每个间隔删除面板中的所有Button，并重新创建每个间隔。
他们俩看起来都是个丑陋的解决方案。有什么建议吗？
浏览 1提问于2012-11-20得票数 0
回答已采纳
2回答
我需要一个从O(n)中的点的Voronoi图计算一组点的凸包的算法。Voronoi图包含在边界框中，并以双连接边列表的形式存储。输入是原点在边界框上的半边。
我知道凸壳上的两个点是相邻的当它们共享一个无限长的voronoi边。
浏览 3提问于2010-11-23得票数 2
2回答
我想计算一个线条排列的边界框(没有平行线)。边界框应包含线条排列的所有交点。
我做了一些研究，多次发现计算边界框应该可以在O(n log n)时间内完成。不幸的是，我找不到这种说法的来源。
我试着想出一个算法，在O(n log n)时间内解决这个问题，但到目前为止还不能。我试图使用二元性来计算信封，但不幸的是，信封并不总是包含最低和最高的交集。
如果有人知道在哪里找到这样的算法或它是如何工作的，我将不胜感激。
浏览 8提问于2017-12-08得票数 5
回答已采纳
1回答
为了构建堆，人们经常错误地认为O(n log n)是严格的上限，但实际上它是O(n)。
我想说从堆中取出所有n元素是O( n)，但根据我对构建堆的复杂性的了解，我很犹豫，我认为可能是O(n)，原因与构建堆是O(n )的原因相同。
这是正确的吗？
每次弹出时，我们都需要找到一个新的根，heapify函数将花费O(h)时间，其中h是二叉树的高度。对于像堆使用的平衡二叉树，h= log_2(n)。但是每次pop的节点数量都会逐个减少，所以h应该会减少。
因此，如果我要计算复杂性，我会这样做
O(log_2(n) + log_2(n-1) + ... + log_2(1))
= O(log_2(n *
浏览 1提问于2020-10-01得票数 1
假设我有一个多边形，表示为CCW顺序中的顶点列表(不是DCEL)，而我有一个给定的多边形对角线列表。如何将所有这些对角线上的多边形拆分成一个n+1多边形列表？
我没有困难按一条对角线把名单分开。问题是快速确定剩下的两个多边形，我的其他对角线属于哪一个。从那里，我可以将对角线列表拆分成两个列表，并递归地操作两个拆分多边形。
最好，我想在O(n log(n))时间内这样做，而不是简单地绕两个分裂多项式来确定哪一个对角线在哪个子多边形上的明显算法。
浏览 0提问于2012-02-26得票数 0
我有一组m个非旋转的整数(像素)对齐的矩形，每个矩形可能重叠，也可能不重叠。矩形覆盖了数千个像素。我需要找到最小尺寸的边界框，它覆盖了m个矩形中n个覆盖的所有区域。
一种(脏的)方法是绘制一个覆盖所有目标区域的画布。这是O(mk)，其中m是矩形的数量，k是每个矩形的像素数。然而，由于k比m大得多，我认为有一个更好的解决方案。
这感觉就像是一个动态编程的problem...but，我搞不懂递归。
更好但仍然不是很好的解决方案：
对X方向上所有矩形的起点和终点进行排序O(mlogm)，迭代并找到可能在n个矩形上的x个位置，O(m)循环。对于每个可能有n个以上矩形的x位置，取该位置的矩形，并对该位置
浏览 0提问于2013-11-04得票数 3
设A，B，C为n个元素的3个数组。找到一个算法来确定在A中是否存在a，在B中是否存在b，在C中是否存在c，从而使a+b+c = k。
我尝试过以下算法，但它采用了O(n²)
对所有三个数组进行排序。- O(n log n)
临时数组h = k - (a+b) - O(n)
对于每一个h，在B中找到c'，这样c' = h - B[i] - O(n)
使用二进制搜索- O(log n)在C中搜索O(log n)
总is = O(n log n) + O(n) + O(n² log n)
我们能用O(n log n)解决这个问题吗？
浏览 9提问于2014-05-31得票数 1
1回答
动态加载骰子的数据结构？
、、、
假设我有一个有序的频率列表(如[1, 1, 2] )。我希望能够从这个列表中快速抽样，选择一个选项的概率与它的值成正比。
允许我们使用O(n)构造时间和O(1)查询时间来完成这个采样。我对这个问题的版本感兴趣，我们也支持这个列表的更新或插入。
以下是一些想法：
一个增广的BST可以使用O(log(n))的所有操作来完成这一任务。
您可以使用分层数据结构，其中有n/log(n)块的大小log(n)。每个块存储为增广的BST，顶层数据结构是别名方法。选择一个BST需要O(1)，在其中选择需要O(log(log(N)，所以您的查询时间是O(log(log(N)。每当更新发生时，您都需要完全重
浏览 3提问于2016-11-16得票数 0
回答已采纳
1回答
(O(n)，O(log n))方法是否足以解决这个问题- ？
(更新时间- O(n)，查询时间- O(log n))
我的解决方案-使用上述方法解决(使用段树)被Codechef法官判断为“TLE”提交。
我甚至尝试了一种(O(log )，O( n) )方法来解决这个问题(更新时间- O(log )，查询时间- O( n) )，但是即使这也被Codechef法官拒绝了，因为它超过了时间限制。从现在起我不知道从这里往哪里走。这是我第二次提交的链接--
任何已经解决了这个问题的人都被要求在这方面帮助我。我能做(O(lgn)-O(lgn))吗？多么?
提前谢谢。
浏览 3提问于2011-05-31得票数 0
假设我有一段代码，比如 for(int i = 0; i < n; i++){
randomFuntion(); // runtimes function is O(log n)
} 它的总体最坏运行时间是O(n)，还是仅仅是O(n log n)？
浏览 14提问于2020-10-13得票数 1
回答已采纳
2回答
FFT的澄清
、、
我知道下面的推理有问题，但我不知道它是什么。
FFT：
给出两个多项式
A = a_0 + a_1 x + a_2 x^2 + ... + a_n x^n
和
B = b_0 + b_1 x + b_2 x^2 + ... + b_n x^n
您可以计算乘积的系数。
AB = \sum _k = 0 ^ 2n ( \sum _ j = 0 ^ k (a_j b_{k-j}))x^k
在O(n log n )时间，给出了两个向量(a_0, ..., a_n)和(b_0, ..., b_n)，我们可以在O(n log n)时间内计算向量v_i = \sum j = 0 ^ k ( a_j b_{k
浏览 1提问于2009-11-12得票数 0
回答已采纳
我知道，类似的问题可能会问很多次，但它是不同的。
给定一个带有值的未排序整数数组，1 to N-1中有一个重复元素(N是数组的大小，最大值是N-1，因为有重复的元素)。找到重复元素的最佳方法是什么？如果可能的话，O(log n).`
我知道O(n)的解决方案，但是有没有办法在O(log n)时解决这个问题？
O(n)解：
1) Find sum of first N-1 natural numbers using N(N-1)/2, lets say it SUM1
2) Find sum of all the elements of the arrays, let say it SUM2
浏览 4提问于2012-06-13得票数 0
回答已采纳
在分析函数的时间复杂性时，我们是否考虑了具有相同运行时的多个操作实例？例如，假设我们有以下函数：
my_fake_function(int v) {
for(int i=0; i < v; i++;) { // O(V)
someDatastructure.insert("test"); // insert() is O(log(n))
someDatastructure.insert("test"); // insert() is O(log(n))
}
}
因此，我们知道此函数运行V次，并且对于每次迭代，都会调用in
浏览 0提问于2021-03-03得票数 0
1回答
数字基转换的时间复杂度
、、、、
的答案
8.3-4 (来自CLRS)显示了如何在0到n^2−1范围内按O(n)时间排序n个整数。
答案是：
首先，用O(n)时间将整数转换为2位数，基数为n.
它假定我们可以将0范围内的n整数转换为n^2-1，以便在O(n)时间内将n作为基值？
这怎么可能？
每个转换不是需要O(log(n))时间吗?因此，对于n个转换，时间应该是O(nlogn)而不是O(n)？
浏览 4提问于2015-09-20得票数 3
回答已采纳
1回答
线性时间最小轴平行包围盒
、、、
问题
在线性时间O(n)中，我必须计算一组二维点的直径。
为了做到这一点，我想使用最小轴-平行包围盒，可以用线性时间计算，旋转卡尺从凸多边形开始。
不幸的是，我没有凸多边形和计算它将需要O(nlogn)的时间，因为凸包。
我的想法是使用基排序，然后通过单调链算法(如果输入排序需要线性时间)计算凸包。
现在我的问题是：
我如何确定基排序将在线性时间内运行？
你有更好的想法来计算最小轴平行包围盒的线性时间吗？
提前谢谢你！
编辑
我特别需要最小包围盒，因为我必须为直径设计一个sqrt(2)近似算法，这是我所知道的证明这个近似的唯一方法。
浏览 0提问于2018-01-02得票数 1
回答已采纳
所以我在一次采访中被问到，如果可以检查树是否是avl树，可以是: T(n) = O(log(n))
我不知道答案，在谷歌上搜索后，我看到的最好的算法是O(n) ("")
是用O(log(n))做算法吗？
浏览 0提问于2018-04-30得票数 1
1回答
自然数n的立方根定义为最大自然数m，使得m^3≤n。计算n的立方根的复杂性(n用二进制表示法表示)是
(A) O(n)但不是O(n^0.5)
(B)任何常数k>0的O(n^0.5)而不是O((log n)^k)
(C)对于某些常数k> 0，O((log )^k)，而对于任何常数m>0，则不是O((log n)^m)。
(D)对于某些常数k> 0.5的O((log log n)^k)，而不是O((log log n)^0.5)
我没办法解决去年的问题，.Can有谁能帮我理解这个问题？
浏览 2提问于2013-12-24得票数 3
回答已采纳
我有一个关联NxN矩阵和一个包含所有列的向量： std::map<std::string,std::map<std::string,int>> A;
std::vector<std::string> columns; //this has size n 一个元素应该是这样的: A"abc“=2 我想删除O(n)中的行"abc“(所以基本上是A["abc"])和列"abc”(所以基本上是A[*]["abc"])。 A.erase("abc"); //this is O(log n)
f
浏览 28提问于2020-09-07得票数 2
回答已采纳
1回答
我想实现至少两种不同的解决方案，用O(N*log(N))的平均时间复杂度在大O表示法中找到N-最大元素，其中N是列表中的元素数？
对于O(N*log(N))，我应该在java程序中使用哪种搜索算法来查找n个最大元素？
浏览 4提问于2014-01-02得票数 0
回答已采纳
1回答
树排序性能
、、、
我有一个AVL树实现，其中插入方法的运行时间为O(log )，返回有序列表表示的方法的运行时间为O(n^2)。如果我有一个需要排序的列表。通过使用for循环，我可以遍历列表并将每个元素插入到AVL树中，该树的运行时间加起来为O(n log n)。那么整个排序算法(即遍历列表，插入每个元素，然后使用顺序遍历返回排序列表)的性能如何呢？
浏览 18提问于2021-05-07得票数 0
我正在设法用Octave编写Eratosthenes的筛子，以尽可能地向量化(即尽量减少在for-循环/while-循环/递归调用上的迭代次数)。
我发现在for-循环中只需要O(log(log(N)迭代，但是大的-O运行时间(以及空间)是O(n^(5/4)/log(n))，所以它可以说不是Eratosthenes的筛子。
现在我想我有一个具有正常运行时间O(nlog(log(N)的迭代，并且只有O(log(n))迭代，但是我想看看其他人是否想出了一个更好的解决方案。
浏览 0提问于2013-03-13得票数 0
回答已采纳
我正在实现MinHeap，我知道如何实现deleteMax()，但这需要O(n)时间，但我需要O(log(n))算法。
我搜索了，但没有找到一个方法来做到这一点，如果它存在的话，我是否可以在deleteMax()的O(log(n))时代？
浏览 3提问于2013-11-12得票数 0
回答已采纳
1回答
日安！
我有一个关于二进制搜索树插入方法的时间复杂度的问题。我读了一些关于这个问题的答案，但有些答案是不同的。二叉树插入方法的平均时间复杂度是O(log )，最坏情况是O(n)？或者对于平均情况是O(n log n)，对于最坏情况是O(n^2)？什么时候它在平均情况下变成O(n log n)，在最坏情况下变成O(n^2)？
浏览 1提问于2014-10-17得票数 3
5回答
检测直线是否与凸多边形相交的O(n)算法包括检查多边形的任何边是否与直线相交，并检查相交的数目是奇数还是偶数。
是否存在渐近更快的算法，例如O(log )算法？
浏览 5提问于2010-12-21得票数 21
回答已采纳
给定以下2d数组：
6 8 11 17
9 11 14 20
18 20 23 29
24 26 29 35
对每一行和每列进行排序，也对对角线进行排序(从左上角到右下角)。假设数组中有n个平方元素(本例中为n = 4)，那么使用O(n² log(n²)) = O(n² log(n))对2d数组进行排序是非常简单的。我的问题是，我们能在O(n²)中分类吗？
目标是使用给定的半排序2d数组，并提出一个聪明的解决方案。
目标产出是：
6 8 9 11
11 14 17 18
20 20 23 24
26 29 29 35
浏览 1提问于2020-05-26得票数 6
来自redis医生：
ZPOPMIN密钥计数可从5.0.0开始。
时间复杂度: O(log(N)*M)，N是排序集中的元素数，M是弹出的元素数。
移除并返回存储在键处的排序集中得分最低的成员。
所以，我的问题是，如果列表是排序的，为什么要取log，为什么不是O(1)？
浏览 0提问于2019-01-26得票数 0
回答已采纳
与遍历整个数组需要O(n)时间不同，寻找最大值的最佳数据结构是什么？例如，二叉树的平均情况为O(log )，但最坏情况为O(n)。有没有最坏情况是O(log )的？
浏览 1提问于2016-05-07得票数 0
我在C++中寻找一个索引容器，它具有以下属性：
获取O(log n)中k个位置的元素。
在O(log n)的k个位置插入一个元素
删除O(log n)中k个位置的元素。
我在想一个解决办法，用一个类似的地图，但我搞不懂。在Java中还有一个名为的容器，它表示属性。
浏览 3提问于2020-03-17得票数 1
回答已采纳
3回答
假设我们有两个序列x= {x_i :i 1，M}和y= {y_i :i 1，N}。是否有可能找到最小(如果有的话)对(i，j)，使x_i = y_j？
平凡的O(n^2)时间O(1)空间算法只是让你比较任意序列的每一个元素，同时跟踪从序列开始到距离的最小差。
O(n log )时间O(n)空间算法只对序列进行排序和比较，同时保持最小/最大元素的跟踪。
我想不出线性时间算法，我不知道这个问题会被称为什么。
浏览 1提问于2016-01-26得票数 1
回答已采纳
在线建设，如，得到的输入点一个一个，并找到船体给出的点，直到那个时候。
我可以用O(n * nlogn)或O(n^2 logn)中的格雷厄姆扫描来完成这个任务。但我正在寻找一个O(n^2)解决方案。
我读过梅克曼的O(n)算法。这是正确的道路吗？
浏览 0提问于2019-03-14得票数 0
回答已采纳
我想用耐心排序算法来解决Haskell中的问题。
我第一次使用列表，它在O(n^2)时间内起作用。
现在，我想创建一个在O(n log n)时间内求解它的算法。要做到这一点，我需要在插入每个值v时得到“第一次拟合”，换句话说，在n log n时间中找到最后一个元素大于v的第一堆。
data OrderedStruct = undefined -- ???
-- I need a method to remove elements in (n log n) time
popFirstBigger :: Ord a -> a -> OrderedStruct a -> (
浏览 2提问于2021-02-19得票数 0
回答已采纳
您将得到一个包含自然数的长度为A的数组N。问题是:给定一个索引i和一个自然数k，使子数组A[i,i+m]中的所有元素都大于或等于k的最大偏移量m是多少。
有一个简单的O(N)算法:从i开始，向右扫描数组，直到您用A[i+m] < k达到偏移为止。
我正在寻找的是一个算法和一个数据结构，这样：
数据结构最多可以在O(N log N)中从给定的数组中计算。
数据结构的大小最多为O(N)
该算法使用预先计算的数据结构来解决上述问题，在最多O(log )中。
有人能构造出这样的算法吗？还是有一个很好的论据，为什么这样的算法不存在？
我能想到的最好的事情是在O(N 2)和O(l
浏览 1提问于2015-02-20得票数 0
回答已采纳
2回答
链表的搜索算法是否有可能是O(Log N)？根据我的理解，链接列表可能有O(n)或O(1)，因为您可以选择从哪里开始，从链接列表开始到结束。知道了这一点，你能从中间开始寻找一个在O(Log)时间内运行的搜索算法吗？
浏览 4提问于2021-04-13得票数 2
回答已采纳
3回答
在C++中，如果我对两个位集执行逻辑OR (或AND)，例如：
bitset<1000000> b1, b2;
//some stuff
b1 |= b2;
这是在O(n)还是O(1)时间内发生的？为什么？
另外，是否可以在O(1)时间内使用布尔数组来完成此任务？
谢谢。
浏览 0提问于2012-03-05得票数 5
回答已采纳
1回答
清理堆的时间复杂度是多少？
、、、、
我搜索了很多网站，他们都说“清除堆的时间复杂性是O(n log N)”。原因是：
交换尾节点的根代价为O(1)。
将“新根”交换到合适的位置需要花费O(level) = O(log )。
因此，删除一个节点(根)需要花费O(log )。
因此，删除所有n个节点的代价是O(n log )。
在我看来，答案是对的，但不是“紧”的，因为：
在删除过程中堆(或其级别)变得更小。
因此，“将新的根交换到合适的位置”的成本变得更小。
"O(n log n)“的上述原因没有体现这种变化。
在上证明了创建堆的时间复杂性是O(n)。
我倾向于认为清除堆的时间
浏览 2提问于2020-05-16得票数 0
回答已采纳
1回答
根据罗恩·韦恩的说法，你可以在O(log(n))时间内分割和连接红黑树。见他的作品：
然而，我仍然不相信分割的运行时间真的是真的。
其思想是，split使用最坏情况的日志(N)连接。这些连接是快速完成的，因为我们可以从最后的级联中通过记住p来找到节点p。
问题是，级联启动了修复(平衡)算法，据我所知，该算法采用O(log )(参见伪代码中的级联步骤5)。这给我一个log(n)*log(n)的运行时间，因为拆分将导致最坏情况的log(n)连接。
罗恩·韦恩( Ron )在他的论证中没有考虑到修正算法。我在分析中遗漏了什么，或者算法是错误的？
浏览 9提问于2015-03-13得票数 1
回答已采纳
这是一个理论问题，因此假设比较array中的elements需要恒定的时间。
我们得到了一个array，它的前一半的elments比它的另一半小。没有排序的内容。它会在最坏的情况下对其进行排序吗?运行时O(n)还是没有办法？
我认为它不会起作用，因为对前半部分进行排序将需要O((n/2)*log(n/2))时间，对于另一半也是如此。总而言之，这将是O(n*log(n/2))，所以仍然是O(n*logn)？这是对还是错？如果可以的话请给我解释一下。
浏览 2提问于2016-06-09得票数 0
以下是来自CareerCup.com的谷歌面试部分的问题：
给定2d空间中的2*n +3个点，其中没有3个点共线，也没有4个点位于圆上，
设计一个算法，该算法将找到一个圆，其中包含n个点，n个点，3个点。
我可以想到一个O(n^4)的解决方案：
a)以C(2n+3,3)的方式选取任意3个点，并用这些点(O(n^3))画一个圆
b)现在，对于每个圆，检查其内部是否恰好有'n‘个点O(n)
既然这是幼稚的做法，我想问一问有没有更好的方法
来解决这个问题？即O(n log n)量级的东西
浏览 1提问于2013-09-11得票数 7
1回答
本文研究了二元搜索、三值搜索和n元k元搜索的时间复杂度，并给出了它们各自的渐近坏情况运行时。然而，我开始怀疑，如果我将N个元素划分为n个范围(也就是n个元素中的n元搜索)，会发生什么。这会不会是数组中的排序线性搜索，从而导致O(N)的运行时间？这有点让人困惑。请帮帮我!
浏览 5提问于2015-11-16得票数 2
1回答
创建堆需要O(n)时间，而插入堆(或优先级队列)则需要O(log(n))时间。
接收n个输入并将它们插入优先级队列中，操作的时间复杂度是多少？ O(n)或O(n*log(n))。
而且，同样的结果也适用于清空整个堆(即n个删除)，对吗？
浏览 4提问于2017-06-20得票数 42
回答已采纳
因此，这是同一个问题()，但对于一个priority_queue。我看到priority_queue.push是O(log(n))，但是推n元素是O(n)。那件事怎么可能？
浏览 1提问于2019-08-08得票数 0
回答已采纳
我需要编写一个程序，它决定给定的列表中是否有两个整数，a和b，比如a + b = c。输入将是一个列表和整数c。可能是a == b，但在这种情况下，a必须在列表中出现两次。运行时必须在O(n*log(n))中。
我尝试过实现二进制搜索，但是由于必须对列表进行排序，如果列表没有排序，它将无法工作，因为排序至少要花费O(n*log(n))时间。我试图实现合并排序，而不是在最后进行合并，只获得a和b，但我不知道它是否是死胡同。你会怎么开始呢？运行时不超过O(n*log(n))是非常重要的。
浏览 0提问于2018-12-18得票数 0
回答已采纳
稳定的排序算法比不稳定的排序慢。例如，使用O(n*log(n)*log(n))调用来交换元素。
如果我们的目标是保持元素的原始顺序，为什么不直接对所有元素进行编号(O(n))，然后使用原始索引执行不稳定排序(O(n*log(n)))来解决比较相等的实例。
这看起来更快。
即O(n) + O(n*log(n)) < O(n*log(n)*log(n))
这是正确的吗？有什么理由更喜欢稳定的类型吗？
浏览 3提问于2019-10-23得票数 2
我正试图解决Find the k-th smallest number in an array of distinct integers这个受欢迎的面试问题。我阅读了一些解决方案，发现堆数据结构非常适合这个问题。
因此，我尝试使用集合框架的PriorityQueue类实现解决方案，假设它在功能上与堆相同。
下面是我尝试过的代码：
public static int getKthMinimum(int[] input, int k){
PriorityQueue<Integer> heap = new PriorityQueue<Integer>();
浏览 0提问于2019-03-15得票数 1
回答已采纳
我试图确定这些代码片段的大O符号：
#1：
public static void printProducts (int n) {
int a = 0; // O(1)
int b = n; // O(1)
// O(n)?
while (a < b){
// O(?) This if is checked n times, but how many times is it ran?
if (a * b == n) {
System.out.println( a + "*" + b
浏览 2提问于2021-12-03得票数 1
回答已采纳
我看到了一个关于用矩阵幂求解O(log )时间递归的问题：
这个问题的递推关系是齐次的。
是否存在非齐次线性递推关系的矩阵？
我的复发是：
a(n) = a(n-1) + a(n-2) + 1，其中a(0) =1和(1) =1
“加一”使线性递推关系成为非齐次关系。
如果这种线性递推关系没有矩阵，那么如何在O(log n)时间内计算a(n)？
浏览 7提问于2014-10-02得票数 1
回答已采纳
2回答
假设你有两堆，每一堆都是由不同高度的N盒子组成的。你想要移除盒子，以获得两堆等高(如果可能的话)。你不能移除不在堆的顶部或底部的盒子！例如，人们可以看到，如果我们移除下面的红色盒子，我们就会得到两座高度相等的塔：
另一种表述这个问题的方法是:给定两个正数数组，是否有两个连续的子序列(每个数组中有一个)和相等？
这个问题看起来类似于，其中我们有一个大小为N的数组A和一个目标t，我们希望找到一个连续的A子序列，其和是t (等价地，我们有一堆盒子，我们希望删除顶部和底部的框，以获得一堆高度t)。这个问题可以在时间O(N)中得到解决。另一方面，上面提到的问题有一个平凡的O(N^2)解决方案(
浏览 3提问于2017-05-03得票数 7
3回答
设S是整数的动态集合。设n= |S|。描述S上的数据结构，以支持S上的以下操作，并提供所需的性能保证：
·在O(log )时间内向S插入一个新元素。
·在O(log )时间内从S中删除一个元素。
·对于满足1≤k≤n的任意k，报告S在O(k)时间内的k个最小元素。
您的结构必须始终占用O(n)空间。
我可以简单地构建一个AVL树，然后按顺序遍历打印出前3个元素吗？
浏览 0提问于2016-11-02得票数 0
1回答
我正在为面试复习一些“大O”符号，我遇到了这个问题。
for i = 1 to n do:
j = i
while j < n do:
j = 2 * j
很简单对吧？外部循环提供n个步骤。这些步骤中的每一步，我们只执行一步O(1)的赋值j=i，然后日志(n-j)或日志(n-i)，因为j = i步骤的时间循环。我以为时间复杂度是O(nlogn)，但答案是O(n)。
以下是答案：
运行时间大约为:从1到n的Σ1+ log(n/i)，即Θ(n)。
现在已经有一段时间了，所以我有点生疏了。log(n/i)从何而来？我知道log(n) - log(i) = log
浏览 1提问于2017-10-07得票数 3
1回答
限制为100.000 (10^5)个节点，每个节点有2个或更少的边。
如何在O(n)或O(n log n)时间内得到该图的最大独立集？否则，它就会准时出来。顺便说一下，我只需要知道积分集合的点的数量，而不一定是点本身的集合。
我知道在O(n)上工作的贪婪的近似，它是选择度最低的节点，将它们加到我们的集合中，然后删除它的所有邻居，重复这一点直到图是空的，这个近似在很多情况下都是有效的。问题是，有了这些限制，难道没有任何算法总是有效的吗？
浏览 2提问于2014-12-19得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
