我对以下算法的运行时间计算有疑问 我不确定我的答案，我想检查一下正确的答案 Algorithm Unknown(G) Input: A weighted graph with n vertices, and m edges Output: ????? P ← create array of size n to to referenced by vertix id number (id[u]) Q ← create array of size n to to referenced

给定一个表示为邻接矩阵的图，如何在线性时间内进行拓扑排序？ 即使我做了一个预处理器来创建一个in度值数组，它的时间复杂度也将是O（| V | ^2）。 我知道，对于一个矩阵的拓扑排序，可以创建一个线性时间的算法，那么我缺少什么呢 正如dyukha在评论中提到的，“线性时间”是一个依赖于输入大小的术语。因此，例如，测试数字是否为素数的方法最多运行n^（0.5）次迭代，但输入大小为log（n），因此时间复杂度为2^（n/2） 在这种情况下，邻接矩阵需要O（k）=O（|V | ^2）空间，您可以应用并

我认为下面代码的时间复杂度是O（logn），但答案是O（N）。我想知道为什么： int count = 0; for (int i = N; i > 0; i /= 2) { for (int j = 0; j < i; j++) { count += 1; } } int count=0； 对于（int i=N；i>0；i/=2）{ 对于（int j=0；j

假设在解决一个递归问题时，我发现： T(n) = c*n*(1-n) = c*n - c*n^2 其中c为正常数，n为输入的大小 是否应该考虑此递归的渐近时间复杂度，O（n）为n^ 2项为负？< /P> 更新： 例如，假设我们有以下循环： T(n) = T(a*n) + O(n), where the factor a less than 1: => T(n) = c*n*(1 + a + a^2 + a^3 + ... for logan terms) => T(n) = c

如果存在一个图灵机可以在多项式时间内求解，那么问题就在p（=多边形时间）内。对于NP（=非确定性多时间）问题，存在一个见证，图灵机可利用该见证在多项式时间内解决问题（或决定其是否为语言的一部分）。 P=NP的问题仍然没有得到证实 我想知道你怎么能证明p不等于NP。我的想法是，如果你在NP中找到一个问题，然后证明没有算法可以在多时间内解决这个问题（没有见证），那么P不等于NP 例如，如果你看哈密顿路径问题（在NP中），证明它不能用确定性TM在多时间内求解，那么p不等于NP 我的思维过程是正确的还是

我当前学习的间隔树对于每个节点都有以下数据结构： 键：所有间隔端点的中值 左，右：指向左和右子树 间隔：包含包含键的间隔的间隔列表 更准确的信息可以在这里找到 我了解到使用区间树进行查询的时间复杂度是O（logn+k），其中n是区间数，k是报告结果数 我不太理解logn部分。假设v是区间树中的当前节点，Q是查询区间。算法如下所示： if v.key is in Q, add v.intervals into results search_on_left_subtree searc

我正在破解编码面试，我不确定时间复杂性的例子。它们提供以下代码来确定数字是否为素数： boolean isPrime(int n) { for (int x = 2; x * x <= n; x++) { if (n % x == 0) { return false; } } return true; } 布尔isPrime（int n）{ 对于（int x=2；x*x语句的关键部分在for循环内部。发生的一

我在研究一个问题，我们应该给出一个算法的例子，它的时间复杂度是O（n^2），但它的摊销时间复杂度小于这个。我的直接想法是嵌套循环，但我不能确切地确定这样一个例子的结果在哪里摊销。如有任何见解，将不胜感激 考虑向量（可调整大小的数组）数据结构上的Add方法。一旦超出阵列的当前容量，我们必须通过制作更大的阵列并复制内容来增加容量。通常，在这种情况下，您只需将容量增加一倍，从而产生最坏情况下的O（n）Add，但却是O（1）摊销Add。我们当然可以自由地通过平方增加容量，而不是加倍（前提是初始容量大于1

如果f（n）=Θ（n）和 g（n）=Θ（n^2） 那么f（n）*g（n）=Θ（n^3）？问题 从技术上讲，Θ（n）是一组函数，所以我们说f在Θ（n）中，而不是f（n）等于Θ（n） 因此，我们要调查的问题是： 让 h(n) = g(n) · f(n) (*) 是否f∈ ϴ（n）和g∈ ϴ（n^2）意味着h∈ ϴ（n^3） 准备工作 首先，让我们粗略地说明Big-ϴ符号的定义 f∈ ϴ（g（n）） ⇨ 对于某些正

为什么大O表示法（与另一种表示法或度量相反）如此常用于描述算法？为什么它比大ω或大θ符号使用得更频繁？老实说，我认为人们可能最熟悉这种符号。无论如何，附加符号并不总是必要的。例如，说线性搜索是O（n）和ω（1）并不比说线性搜索在最坏的情况下是O（n），在最好的情况下是O（1）更简洁。这个问题一点也不清楚。还有，为什么这个标签是[python]而不是[algorithm]，例如？我很困惑，“大多数时候人们使用符号”是什么意思？我们还会使用什么？根据定义，任何时候你写下的东西都是一种符号。非常感谢你

我知道n的嵌套循环的时间复杂度为^2。但是如果我有如下的嵌套循环 for(i=0;i<n/2;i++) for(j=0;j<n/2;j++) ... ... 如何计算此代码的时间复杂度。它也在^2上吗？如果是，怎么做 它也在^2上吗？如果是，怎么做 是的 您所要做的就是根据乘积规则计算迭代的总数，即n/2*n/2=n^2/4，并记住Big-O表示法忽略常量。渐近分析会删除常数，因为当n趋于无穷大时，它们并不重要。换句话说，fn=n和gn=2n都是线性函数，尽管g

如果女性可以有不止一次婚姻，而男性是求婚者，那么Gale-Shapley算法的时间复杂度会是多少？假设您可以在固定时间内找到首选项列表中的男性和女性等级。还是O（n^2）？欢迎来到堆栈溢出。请按照建议添加您的搜索/研究工作的简要说明。

如果我有一个需要4n^2+7n步才能完成的算法，它的O是什么？ O（4n^2）？ O（n^2） 我知道7n是截断的，但我不知道是否应该保留n^2系数 谢谢是O（n^2）。常数因子“移入O”。你只保留最大的指数，因为这是占主导地位的指数。您可以省略系数，因为在比较不同算法时，即使非常大的系数也会比指数大（n足够大）的系数产生更小的总数。系数与大O表示法无关，所以它只是O（n2）。： […]如果我们将系数与任何其他顺序的表达式进行比较，例如包含n3或n2项的表达式，则系数变得无关紧要 你应该去掉任何

我只是想知道你们是否可以给我一些增长清单的样本订单，如下所示： n^n>n!>2^n>n^2>nlogn>n>n^1/2>logn>constant 你还知道他们在哪里合适吗？有什么简单的方法可以找出由这些函数组成的新函数适合于什么地方吗？（例如，如果我有（2^n）/n？）。 这会有帮助的，看看上面的图片，它是大O符号的增长图。这里有无限多的可能性（n^n^n，n^n^n，n^n！，等等），因此，这可能不是一个好问题。我投票将这个问题作为离题结束

这段代码的执行时间增长率是多少 int maxValue = m[0][0]; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if ( m[i][j] > maxValue ) {

我不熟悉算法和大0。这个函数的增长顺序是什么 我做了一次打印，f10运行了15次。f20运行31次 在我看来像logN*N/2。那么它是对数的还是线性的 内循环j计数i次->最大值为n Outter循环计数从0到n，每次乘以2，所以是lgn次 所以total是onlgn运行时处于打开状态。要看到这一点，请注意，内部循环在第一次迭代中运行1次，在下一次迭代中运行2次，在下一次迭代中运行4次，通常在第2次迭代中运行2i次。外循环在lgn次迭代后停止，因为它保持翻倍，所以完成的总功是 1+2+4+8+

我目前正在学习TSP，希望将两个简单的启发式算法结合到一个算法中。它的工作原理是使用最近邻算法创建一个巡更，然后通过对每个组合使用2选项交换来改进巡更。我相信2opt技术的步骤数是n（n-1），所以O（n）=n^2。然而，我不知道如何计算最近邻算法的复杂度。我可能认为这将导致O（n^2），但我不确定实现这一点的过程。这取决于最近邻的实现：在O（n logn）中构建Vornoi图后，可以以O（logn）的速度进行……本文（）描述了我认为最耗时（但最容易理解）的内容神经网络算法的实现。你能解释一下（

这段代码的确切时间复杂度是多少 我知道它是指数的，但是什么样的指数像2^n，sqrt（n）^sqrt（n）等等 如果附上一些证据，那就太好了 类正方形{ //返回求和为n的最小平方数 静态整数getMinSquares（整数n） { //基本情况 如果（n该函数的递推关系为 T(n) = sum from i=1 to i=sqrt(n) of T(n - i*i) 其上以 T(n) = sqrt(n) * T(n-1) 因为上面总和中的每个项最多是T（n-1），有sqrt（n）。T（n

我想知道log（n！）是O（n！），还是n是O（log（n！））。我已经看到log（n！）是O（n log（n）），但对于我的特定问题，我找不到可用的信息。log（n！）比n增长快得多。 你可以从照片上看到。 例子： 当n=50时， O（n）将是50。 但是，O（log（n！））=64.48 更新： 我试着在同一张图上绘制n和log（n！） log（n！）=O（n）表示0

因为坦率地说，程序员并不重要。您正在为客户机设计代码，最终您将为他们编译代码。一旦编译成.jar或.exe，就不必再次编译。他们不在乎编译是否花了你四个小时，他们只看到运行时的效率。如果你只编译了一次，但是你运行了4000次代码，这将更加重要。运行时还是编译时 编译只发生一次。因此，在产品的整个生命周期内，其成本是恒定的。复杂性是衡量成本如何与投入成比例增长的指标。固定成本与投入不成比例增长。因此，它的贡献为零。编译时间可能会根据同一任务的程序大小而变化，但运行时间只会根据算法而变化，因此运行时

我很难看到这里的模式。 即使插入n的数字，然后绘制出每个基本操作。 提前谢谢 编辑：我想要最坏的情况。第一步是将n除以2。所以你得到了n/2。现在，用2再次除以它，如果n/2>1，则得到n/4。如果n/4>1你再做一次，你会得到n/8，或者最好写成n/（2^3）。。。现在如果n/（2^3）>1你再做一次，你会得到n/（2^4）。。。所以，如果你做了k次，你会得到n/（2^k）。如何计算kto，从而得到n/（2^k）≤ 1？简单： int count=0; do { count++;

我有一个只需要在O（N/2）时间内运行的算法（基本上它是一个只运行一半元素的for循环） 这在大O符号中是如何简化的？O（对数n）？大O表示法会降低因子O（N/2）=O（1/2*N）并简化为O（N） 如果你想知道为什么要删除因子，我会让你参考。大O符号会删除因子O（N/2）=O（1/2*N）并简化为O（N） 如果您想知道为什么要删除该因子，我会向您推荐。谢谢！这很有意义（该链接也非常有用），特别是当您将其转换为1/2*N形式时。我知道乘以一个常数或将一个常数加到O（N）会简化为O（N），但我不确

我正在学习时间复杂性，并注意到我看到的教程没有考虑本机函数的时间复杂性（本例中为Javascript） 下面的函数用于删除数组中的重复值并返回排序后的数组，其时间复杂度为O（n），而不是O（n+nlogn）。O（n）正确吗？在计算时间复杂度时，我们是否应该考虑本机函数的时间复杂度 function uniqueSort(arr) { const store = {}; const result = [arr[0]]; for(let i =0; i < arr.l

时间复杂度仅在可变大小数据集的上下文中才有意义；它描述了随着数据集大小的增加，程序的总执行时间将以多快的速度增加。例如，如果您有N个项目要处理，并且您的算法需要读取这些项目的固定次数，则您的算法ithm被认为是O（N） 在第一种情况下，如果我们假设您有一个当前大小为10000000的“数据集”，那么您的单个for循环将是O（N）——但请注意，由于for循环没有任何可观察的效果，优化编译器可能会完全忽略该循环，将其有效地减少为O（1） 在第二个（嵌套循环）示例中（假设变量集大小为10000），算法

这对我来说有点难以描述，但我很想知道如何计算迭代Fib（n）次的时间复杂度 我有下面的一段代码，它将遍历斐波那契数，并从给定的输入中减去该值。循环将运行n次，其中n是Fib（n）>input 代码的时间复杂度显然是Fib（n），但是如何用Big-O表示法来表示呢 我读过这篇文章，如果我理解正确的话，它说时间复杂度是O（n log phi）或者大约O（1.618n）。那么O（n） 但这感觉不对 我还发现了（斐波那契公式）的另一个资源[这一个似乎说它实际上是： i≈ log（N）+（log（5）/2

我很擅长解决运行时求和问题，但这个for循环让我很难堪 对于（j=i；i

如果明确给出n>>1000，O（1000n）能被认为是O（n）吗？？ 换句话说，如果我们要用O（n）来解决一个问题（也就是说n>>1000）&我的解决方案的复杂性是O（1000n），我的解决方案可以接受吗？是的，假设n远大于1000是的，假设n远大于1000你的解决方案是在多项式时间内的，所以当n任意大时，任何常数都无关紧要。是的，你的解是可以接受的。你的解是多项式时间的，所以当n任意大时，任何常数都无关紧要。因此，是的，您的解决方案是可以接受的。如果函数为O（1000n），那么它也会自动为O（

我很难理解时间复杂性不仅仅是大O。在本例中： f(n) = n^10 g g(n) = (2n)^10 fθ（g）是多少？我猜是θ（g），因为你可以找到一个常数c1和c2，使得c1*g（n）是f（n）的上界，c2*g（n）是下界 所以，f（n）>=（（1/4）^10）*（2n）^10大于g（n）。所以，对于一些c1=1/4的情况，f（n）>=c1*g（n） 同样地，f（n）你的猜测是正确的。你可以使用任何c1>=1，任何c2这类问题可能会在假设f（n）=n^10和g（n）=f（f（n））时找

近似因子与时间复杂度有何不同？例如，我听说过带指数因子的多项式算法，这是什么意思？这是否意味着它在技术上不是多项式时间的？没有足够的信誉点，因此作为答案发布 也许你在两种不同的意义上使用因子是造成混淆的原因。时间只是许多可能的复杂因素中的一个因素，例如存储、带宽等。指数因素在多项式算法的情况下，指的是数学方程中项的因素。它们并不一定意味着时间是一个因素，但它们也不排除时间。这取决于算法建模的内容 你在哪里听到这个词的？我不认为它在这种情况下有任何标准意义。我在基于晶格的加密技术的pdf中找到了它

如果我有一个算法，其中一部分具有复杂度big-O（nlogn），另一部分具有复杂度big-O（n）。算法的最终复杂度是多少？据我所知，这将是大O（nlogn）。你是对的，最坏的情况可能是什么重要， 在你的例子中o（nlog（n））。这取决于你所说的“它的一部分”是什么意思 假设有一个复杂度为O（n）的for循环和一个对O（logn）的二进制搜索 如果您的程序如下所示： for(int i=0; i < n; i++) { // O(n) /// some stuff here } bin

这不是家庭作业问题。我正在准备一个采访，并且已经做了很多关于这个链接的研究。我根据一个建议编写了一个解决方案，但我不同意提出的时间复杂性。我想知道我的断言是否正确 下面是一个吐出一组字谜的函数。它对每个输入单词进行排序，并将排序后的输入单词放入字典中。我自己根据帖子中的提示编写了代码，提示： 使用排序：我们可以对字符串数组进行排序，以便 走到一起。然后通过线性遍历 排序数组。该解的时间复杂度为O（mnLogn）（We） 将在排序中进行O（nLogn）比较，比较将 花点时间）。其中n是字符串的数量

构建平衡二叉搜索树的计算复杂度（时间和空间复杂度）是多少 使用n节点构建BST的时间复杂度为O（n*log（n）） 为什么?？您需要遍历每个n节点才能将其插入到树中。现在插入一个节点需要log（n）比较 因此，在二元搜索树中插入n节点的总体时间复杂度为O（n*log（n））将一个节点插入平衡的二元搜索树需要O（logn）时间，因此可以插入n个节点以在O（n logn）时间内构建一棵树 还有待证明的是，没有更好的方法来构建树——例如，将元素插入堆中也需要O（logn）时间，但有一种方法可以在O（n

确实，嵌套的for循环会进行O（n^2）迭代，因此，运行O（n^2）次的操作数量是恒定的，这使得它总体上O（n^2）*O（1）=O（n^2）

我根据算法2.2一书中使用的方法，推导了气泡排序在最佳情况下的时间复杂度。但是答案是O（n^2） 这是我的推导，希望任何人都能帮我找出哪里错了： public void bubbleSort(int arr[]) { for(int i = 0, len = arr.length; i < len - 1; i++) { for(int j = 0; j < len - i - 1; j++) { if(arr[j + 1] < arr[j])

我试图使用 最小优先级队列（使用斐波那契堆实现） 代码 分析： 我知道Fibonacci堆的insert是reduce/insert键是O（1），提取min是O（log（n）） 第1行到第3行：对于每个顶点，运行时间为O（V） 第4行中的循环取O（V），但ExtractMin取O（log（V））， 此外，对于每条边，从第6-7行开始的循环也是O（E） 有for，因为for循环在while循环中， 我要V（log（V）+E） 所以我会得到O（V+Vlog（V）+VE），它可以归结为O（Vlog（

我恳请您确认该周期独立性的复杂性： for (x=2; x<logn; x++) for（x=2；x当这个for循环完成时，logn-2迭代将完成 因此，复杂性实际上是Θ（logn）谢谢chrk，但是如果我有这样的东西，对于（z=2^j；j>1；j=j/2），复杂性仍然是logn？

用大O表示法描述函数只提供 函数增长率的上界这意味着 O（n）的函数在技术上也是O（n2），O（n3）等 O（n）怎么也可以是O（n^2）等 Big O是您使用的算法运行时间的上限，如果您查看nvsn^2的图表，您会发现（对于大于1的数字，n的行位于n^2的行下方。您可以说，运行时间O（n）的算法也有O（n^2）的上限，因为该算法属于n^2的行。该算法不需要花那么长的时间运行，您只是说它所需的时间比这要短，因此是一个上限。引号是可视化为O（n^2），还是读取为O（n2），而没有凸起的“2”？

这个算法的时间复杂度是多少。 还有输出语句执行了多少次 for(int i=0 ;i<n;i++) for(int j=0; j<i;j++) if(j%i==0) system.out.print(i+" "+j); 但我不确定这是否正确，因为我不知道唧唧很多次 执行if语句的主体。 抱歉，总和格式不太好。您试过运行它吗？当i==0，j==0，您计算j%i时会发生什么情况？答案引用了C标准（6.5.5

我需要学习求和吗？如果需要，还有什么书可以参考吗？ for(int i=1;i<=n;i++) for(int j=1;j<=n;j+=i) printf("*"); 对于（int i=1；i这个问题可以通过检查来解决： n = 16 i | j values | # terms 1 | 1, 2, ..., 16 | n 2 | 1, 3, 5, ..., 16 | n / 2 .. | ..

如果我有4个单元格，每个单元格可以包含1或2。因此，4^2是所有4个单元格中值的组合数。如果每个单元格可以包含1、2或3，则所有4个单元格中的值组合数为4^3。这是指数增长吗？如何用大o表示法来表示？答案，所以这个问题可以勾选出来。想尽一切办法找到一个复制品并敲打这个 序列4^2、4^3、4^4、4^5、（或16、64、256、1024、）是否呈指数增长 对 你可以把它写成O（c^n）@HighPerformanceMark是的，谢谢。

假设我有一个带有形式参数p的递归过程。这个程序 在Θ（1）（延迟）操作中包装递归调用 并在该调用之前执行Θ（g（k））操作 k取决于p的值。[1] 过程使用参数p/b调用自身，其中b是一个常量（假设它在1到0之间的某个点终止） 问题1。 如果n是过程初始调用中p的参数值，那么对于该过程生成的过程，空间的增长顺序和执行的步骤数（以n为单位）是多少 如果k=p？[2] 如果k=f（p）？[3] 脚注 [1] 也就是说，在参数的值传递到p时 [2] 即，嵌套操作的输入大小与我们的过程相同 [3]

我正在试图理解本页上big O的示例： （i=0；i

我有以下嵌套for循环： void function(int[] array) { for (int i = 0; i < array.length; i++) { for (int j = i + 1; j < array.length; j++) { System.out.println(array[i] + "," + array[j]); } } } void函数（int[]数组）{ for（int i=0；i

假设计算机以1GHz的速度运行，即每秒执行10^9条指令。对于以下每种时间复杂性，在1周内可以完全处理的最大输入大小n是多少 a) n² b) n³ c) 2^n 这是家庭作业。我不需要答案，我只是不知道如何开始这个问题。有人能告诉我如何解决第一个问题吗。然后我就可以找出剩下的。谢谢大家! 我的看法是，用10^9减去10²得到最大输入，但这似乎太容易了 一分钟60秒，一小时60分钟，一天24小时，一周7天。这是604800秒 如果每秒可以执行10^9条指令，那么每周可以执行604800*10^

我必须找到这个算法的时间复杂度，并找到它所属的类别。 所以我计算它将运行2n^2+6n+1，它的类别是O（n^2） 我想知道我是否正确，另一个问题是，根据维基百科上的定义，Ω也是n^2和Θ也是n^2 Big-Omicron O-函数在上面渐近有界（最多为常数因子） 你对O（n^2）的分析是正确的（尽管你对掉期的分析是错误的） 大ωΩ-函数在渐近下有界 您对Ω（n^2）的分析是正确的（尽管您对掉期的分析是错误的） 大θ-在g的上下均渐近有界 因为大Omnicron和大Omega是一样的，所以大θ和

要计算以下函数的BigO和常量： 我不知道如何进一步简化它。有什么建议吗？Thx T(n) = (n!n+n^3)(n^2+7logn) <= (n!n+n^3)(n^2 +7n) (since n>= log n) <= (n!n+n^3)(n^2 +7n) (n^3 >= 7n if n > 3) <= (n!n+n^3)(n^2 + n^3) <= (n!n+n^3)

我试图从课堂上理解斐波那契级数的复杂性。它说 T(n) = T(n-1)+T(n-2)+ theta(1) 直到上一部分，我才明白，我不明白的是它是如何变成这样的 T(n) >= Fn = theta pow n T(n) >= 2T(n-2) 任何解释都很好。1）表达式T（n）=T（n-1）+T（n-2）与斐波那契数的表达式F（n）=F（n-1）+F（n-2），因为T（n）有一个额外的非负分量theta（1）它肯定不小于F（n）。因此，T（n）>=F（n）2）T（n）=T（n-

我想知道，如果需要了解算法的复杂性，是否有任何通用或最佳实践技术 是标准的 虽然该符号是作为纯数学的一部分发展起来的，但现在也经常在算法分析中使用，以描述算法对计算资源的使用情况：算法的最坏情况或平均情况运行时间或内存使用情况通常使用大O符号表示为其输入长度的函数 这是标准的 虽然该符号是作为纯数学的一部分发展起来的，但现在也经常在算法分析中使用，以描述算法对计算资源的使用情况：算法的最坏情况或平均情况运行时间或内存使用情况通常使用大O符号表示为其输入长度的函数 O（1）表示执行一系列指令的次数

我的h.w.中有一个问题： 证明或反驳：（5n）=O（n！^5） 我不知道如何处理这个问题（当然我知道O符号的定义，但我不知道如何解决它）。。需要帮忙吗 我认为我们必须使用这里，这里给出了以下近似值： 因为众所周知： 我们有： 如果你需要更详细的证明，你确实可以使用，仍然是斯特林近似，来获得这个结果。我投票结束这个问题，因为它是关于数学的，而不是关于编程的。

注:∈/ 意思是不在，我不能在代码中输入它 这个问题可能与一些帖子重复 我读过它们，甚至读过Quora上的一些帖子，但仍然无法理解。我在伪代码中添加了一些注释，并试图解决它。我真的搞不懂为什么它是O（E log V）如果使用a，那么“具有最小d[V]的未访问顶点”实际上是O（1），并且在最小堆中插入是O（log V） 因此，对于其他循环，复杂性正如您正确提到的： Dijkstra((V, E)): S = {} //O(1) for each vertex v ∈ V: