根据： 陈述：f（n）+o（f（n））=θ（f（n））似乎是真的 式中：o=小-o，θ=大θ 这对我来说没有直观的意义。我们知道o（f（n））的渐近增长速度比f（n）快。那么，它怎么可能是f（n）的上界，正如大θ所暗示的那样 下面是一个反例： let f(n) = n, o(f(n)) = n^2. n + n^2 is NOT in theta(n) 在我看来，先前链接的stackexchange答案中的答案是错误的。具体来说，下面的陈述似乎是海报混淆了little-o和little om

如果有人能够证明一个NP完全问题的指数下界，那会证明p≠ NP？是的，这将证明p不等于NP。所有多项式从上到下都有任何指数函数的界，因此任何NP问题的指数下界都将证明该问题不在P中，从而证明P不等于NP 希望这有帮助 你完全正确。 如果你证明了A的指数下界，你已经证明了A不能位于P中。如果A确实位于P中，它在多项式时间内是可判定的，这比你刚刚证明的下界要快——我们有一个矛盾 但是，您不必选择NP完全问题。你可以选择NP中的任何语言。通过证明A不在P中，你也证明了P不等于NP。为什么？因为如果P等

通过循环，您可以得出在每次调用此函数期间，时间复杂度将为：T（n）=2T（n/2）+O（1） 递归树的高度为log2（n），其中是调用的总数（即树中的节点） 讲师说这个函数的时间复杂度为O（n），但我不明白为什么 此外，当你将O（n）代入时间复杂度方程时，会有奇怪的结果。比如说, 你的指导老师是正确的。这是的一个应用程序 你不能像在时间复杂度方程中那样替换O（n），正确的替换应该是一个多项式形式，如a+b，因为O（n）只显示最高有效度（可以有较低阶的常数） 若要扩展答案，请正确识别以下形式的时

这里的大多数问题似乎都涉及将特定CFG转换为CNF。但是我在网上找，找不到这个问题的时间复杂性的答案。将任何给定CFG转换为Chomsky范式的运行时复杂性是多少？是多项式时间吗

我正在为面试复习一些大O符号，我遇到了这个问题 for i = 1 to n do: j = i while j < n do: j = 2 * j 对于i=1到n do： j=i 而j

如果while循环中有嵌套的for循环，如下所示： while(condition) for(i=0; i<size; i++) while（条件） for（i=0；i如果每次执行for循环时，您的意思是每次while（condition）触发新的for循环运行时，则时间复杂度为 也就是说，如果你在内部for循环中增加一个计数器，它将被增加=n选择2倍。但是因为在大O表示法中省略了常量因子和低阶项，我们可以直接写 用于说明，请考虑此Python 2.7实现（我将外部转换为循环+大小

问题6：找出以下程序的复杂性： void function(int n) {     int i = 1, s =1;     while (s <= n)     {         i++;         s += i;         printf("*");     } } void函数（int n） { int i=1，s=1； 而（snsok=O(√n） 上述函数的时间复杂度O(√n） 发件人： 一遍又一遍地看 显然，他们说时间复杂性是O(√n）

我有一个关于大ω和大O符号的一般性问题。但我必须解决以下任务： Prove : n³ + 2n^2 - 5n - 10 ∈ O(n³) and n³ + 2n^2 - 5n^2 - 10 ∈ Ω (n³). With the Big O notation I came to the following result: n³ + 2n^2 - 5n - 10 <= c* n³ => n³ + 2n^2 - 5n - 10 <= n³ + 2n³ - 5n³ - 10n³ =

这个问题是对的还是错的。声明是“当n远大于2m时，以下程序的时间复杂度为O（nm）”。对还是错 问题中的时间复杂度是指最坏情况下的时间复杂度。这就是我到目前为止所做的： 内循环运行m次，m值每次减少1。然后，内部循环的总迭代次数为：m+m-1+m-2+m-3+…+3+2+1 我们可以认为这是一个算术序列。 然后，内部循环的总迭代次数为：m（m+1）/2=（m2+m）/2 在m达到0后，由于n远大于2*m，外部循环将在O（1）时间内继续运行n-m次 因此，时间复杂度为：（m2+m）/2+n-m=O

我刚开始学习散列字典。目前，我们正在使用由链（链表）组成的单独存储桶实现一个哈希字典。这本书提出了这个问题，我很难弄明白。想象一下，我们的初始表大小为10个桶。如果我们想知道n次插入和一次查找的时间复杂度，我们该如何计算？（假设指针访问是一个时间单位） 它提出了三种情况： 一个不调整大小的哈希字典，n次插入和1次查找的时间复杂度是多少 当加载因子超过0.8时，哈希字典的大小将调整为1，n次插入和1次查找的时间复杂度是多少 当加载因子超过0.8时，通过将表大小加倍来调整大小的哈希字典，n次插入和1

是O2^n-1还是在*2^n-1上？ 我对上述两种复杂性感到困惑。有人能提供一些关于复杂性的信息吗？它的程序是用迭代法计算排列的 它的时间复杂性将继续增加∗2^N 有关更多详细信息，请参阅此代码说明 你的名字是什么？瓦尔的长度？在这段特定的代码中，因为n是已知的，所以空间和时间都是O1。。。 val = [5,6,7,8] possible_combinations = [[]] while val: person = val.pop() new_combinations = [

下面是我使用Prim算法将连通图转换为MST的伪代码。然而，我得到的复杂性是n^3，而不是n^2。请帮我找出不需要的步骤。我有一个邻接矩阵a来存储图边的权重，还有一个2D矩阵检查来存储树中已存在顶点的1和剩余顶点的0 还请注意，这也可以在nlogn中完成，但我不想引用任何现有的伪代码，而是想自己尝试。我希望得到一个优化我自己方法的答案 Initialize check. //check[0][1]==1 while(--no_of_vertices) { minimum_outer =

以下代码片段的时间复杂度是多少？ 我们有3个嵌套循环 void function(int n) { int i, j,k, count 0; for (i= n / 3; i <= n; i++) for (j =1; j <= n/2; j= 2 *j) for (k= 1; k*k<= n; k++) count ++; } void函数（int n） { int i，j，k，计数0； 因为你应该自己做作业。读我的

我只是想知道这段代码的大O执行增长率的分解，我试图计算它，但是我得到了错误的for循环。所以我现在完全被困在这个问题上了 void doInter(int setA[], int setB[], int sizeA, int sizeB) { const int MAX = 10; int sizeR; int results [MAX]; // validate sizeA and sizeB if ((sizeA == 0) ||

我知道如果每次代码都将s减半，则为O（logn），但我不确定if-even/else语句如何更改任何内容。谢谢尝试各种数字。例如，使用111。你会惊讶于这个算法的速度有多快。我不能给你O符号，但基本上它会使算法每运行两次就减半一次。@Compass是的，我在发布问题之前运行了代码。我可以用简单的语言来解释，我只是不知道如何给出一个正式的运行时间 s = n while (s>1) if (s is even) s = s/2 else s = s+1

给定一个数组 a[4]={2,5,8,9}; 每个元素的绝对差异为 (3,6,7,3,4,1) abs(2-5)=3 abs(2-8)=6 abs(2-9)=7 abs(5-8)=3 abs(5-9)=4 abs(8-9)=1 有可能在线性时间内找到这个吗？如果是，怎么做？如果n是元素数，则必须执行（n-1）+（n-2）+…+1比较，很明显你可以这样做，所以它看起来像θ（n^2）比较。如果可以在线性时间内完成，那么冒泡排序将是线性的（它是n^2）。是否必须列出所有差异，或者只是将它们相加或其

我需要计算以下代码的复杂性： function(a) n=length(a) i=1 while i<=n for j=n to i+1 print(a) i = i+5 while循环运行了n/5次，但是我被for循环弄糊涂了。 它也是n/5吗 任何指导都将不胜感激。 谢谢通常嵌套循环被视为On*m，其中n是第一个循环的迭代次数，m是第二个循环的迭代次数 当然，这过于简化了，因为没有考虑到n按5缩放，m从i开始，

比较两个不同列表的复杂性是什么 For(object a: Array List) { For (object b: Array List) { If a==b then do something } } 我知道当它是同一个列表时，它是O（n^2），但当它不同时，它的复杂性是什么 谢谢你让我们从基础开始： 遍历大小为N的单个列表的复杂性是O（N）-每个人都知道这一点 遍历单个大小为M的列表的复杂性是O（M）-我想在这里指出的一点是，O（…）中的字母并不重要 现在

我最近被问到一个关于测试数独板有效性的采访问题。一个基本的答案是for循环。基本上： for(int x = 0; x != 9; ++x) for(int y = 0; y != 9; ++y) // ... 执行嵌套的for循环以检查行。再次执行此操作以检查列。对子方块再做一个，但那个更时髦，因为我们把suoku板分成子板，所以我们最终得到两个以上的嵌套循环，可能是三个或四个 后来有人问我这个代码的复杂性。坦白地说，就我而言，董事会的所有单元都被访问了整整三

如果我们计算程序的乘法次数，复杂性将是n*log2（n） 你做n乘以内环（i以n缩放），只要j计算迭代次数，内循环就会重复。内循环独立于i，每次迭代都执行j=j*2和j++。在纸上尝试一下，你会发现这大约在sqrt（n）步骤中达到n（1,3,7,15,31,63，）因此，每个外循环都会生成O（sqrt（n））许多内部迭代。外循环运行n次。因此，你有O（n*sqrt（n））即O（n^（3/2））。j++有点令人讨厌，但这并没有改变数量级仍然是O（sqrt（n））的事实这才是最重要的。它实际上是lo

给定一个实数大小为n的数组。它由n/logn组成 序列（大小logn的每个序列） 证明不可能按时间复杂度对数组进行排序 o（nlogn）（小国）在最坏情况下 假设它可能与较低的价格相矛盾 界定理 我需要帮助来理解这个问题。正如我得出的结论，他们要求证明我们不能得到任何小于O（nlogn）的排序算法？在假设该数组由n/logn排序序列组成的情况下，您需要证明不可能在比nlogn更好的时间对整个数组进行排序。@e.ad我可以使用特定的排序算法来证明吗（合并，堆）并显示它并不比nlogn好？据我所知，

在while（i>=1）{（…）}循环中时，i大于1（除了最后一次迭代），因此在j=i之后，j大于1（除了最后一次迭代） 因此，您的代码或多或少相当于： i=n; while(i>=1){ j=i; while(j<=n){ thetha(1) j=j*2; } i=i/2; } 整体复杂度是while循环的复杂度，它是log（n）。是的，你是正确的，外部循环是log（n），内部循环是log（n），这会产生（l

以下函数以大O表示法的增长率是多少 f (n) = Comb(1000,n) for n = 0,1,2,… int Comb(int m, int n) { int pracResult = 1; int i; if (m > n/2) m = n-m; for (i=1; i<= m; i++) { pracResult *= n-m+i; pracResult /= i; pract

在合并排序的最后一个步骤中，我们有两个排序列表，并试图将它们合并到一个排序列表中，逻辑将如何进行 这就是我天真的想法： 取列表#1中的每个元素，并将其与列表#2中的每个元素进行比较，找出其在列表#2中的位置。基本上类似于插入排序 但很明显，事情不是这样的，因为这给了我O（n^2）的复杂性。 但是合并排序是O（nlogn）。那么最后一步是如何进行的呢？它使用合并排序。合并排序没有单独的排序算法，它是一种排序算法 原来的列表已经排序，所以最小的元素总是在开头。比较A和B。取两者中较小的一个，并将其添

NP中的任何问题都可以在确定指数时间内解决， 或者我们可以这样说 NP中的任何语言都可以由时间为2^O（n^k）的算法决定 i、 e.，NP⊆ 经验 非正式地说，我们只是尝试每一种可能的解决方案，然后决定它 然而，有一个简单的例子，我无法找出我的想法有什么问题 给你 旅行商问题：给定一个无向图G=（V，E）V=| n| 这是一个众所周知的NP完全问题，因此，确实属于NP 我试着分析运行时间，如下所示： 我只是列出了所有可能的解决方案，有（n-1）！可能的总行程 然后我检查每一个，每一次可能的旅行

我已经通过应用蛮力技术创建了递归调用树，但是当我给这个算法100个值时，它需要万亿年的时间来计算 你们建议我做的是，它通过给出100个值来快速运行 以下是我迄今为止所做的工作 function fib(n) { if (n =< 1) { return n; } else { return fib(n - 1) + fib(n - 2); } } 函数fib（n）{ 如果（n=

我正在研究这个问题。以下是背景资料： 你在一家位于n层摩天大楼的公司工作，管理层想知道，如果iPhone被扔出很高的窗户，它的性能会如何。这个想法是，在某个特定的楼层F以下，iPhone根本不受此影响。当从F以下的任何楼层跌落时，它们不会断裂；当从F层及以上抛下时，它们会断裂 我需要制定一个策略来确定F下限，在k>=3部iPhone的情况下，需要进行O（kn^（1/k））试验 放下第i部手机（1

确定问题的时间复杂性（例如，较低的 （或上限） 输入：图形 如果图形包含大小为100的团，则输出：“是”。 否则输出“否” 确定此问题的较低时间复杂度界限 我认为时间复杂度是O（1）常数，因为集团的规模是固定的 另外，如果有人能帮我找到一个关于确定决策问题时间复杂性的好资源，我将不胜感激您的问题中有一些问题需要解决。我在这里的回答必然是简短和非正式的。要真正理解和理解计算复杂性，你必须研究材料。是一本标准书：可能是一本轻松的入门读物 计算复杂性通常根据输入的大小来衡量。对于K-团问题（“输入图是

如何计算这样一个稍微复杂的递归算法的复杂度 在这种情况下，（0，n）的复杂性是什么 void某物（intb，inte）{ 如果（b>=e）返回； int a=0； for（int i=b；i

您能帮我找出以下函数的复杂性吗： proc (int n) { for (i=0 ; i<n ; i++) { x = g(n)+f(n) ; for (j=0 ; j<n ; j++) { y=h(j)*g(j) ; } } return x+y ; } proc（int n） { 对于（i=0；x=O的ibigo（n^2） y的大O=O（n对数（n）） 现在要计算整个算法的大O，我们必须看最里面的循环，在这种情况下，最里面的循环

下面函数的时间复杂度是多少？n>0 Function fun(n){ Let count = 0; For( I = 0; I < n; I++){ For(j = 0; j < n; j /= 2) { For(h = 0; h < n; h /= 2) { Count = count + 1; } } } Return co

对于那些大O专家来说。。。我试图通过两次递归调用来推断函数的时间复杂度，每次调用的输入都会减半： 函数myFunc（n）{ 如果（n>1）{ 让某物=0 for（设i=0；i

我有SVG abirtrary路径，我需要在给定的矩形内尽可能高效地打包这些路径（尽可能减少空间浪费）。经过一些研究，我发现了装箱算法，它似乎是处理盒子而不是弯曲的随机形状（我的SVG形状非常复杂，包括贝塞尔等） 顺便说一句，没有确定的算法来实际包装抽象形状 我希望在这里被证明是错误的，这将是理想的（有一个数学确定性的方法来包装它们）。如果我是对的，但事实并非如此，那么解决这个问题的最佳方法是什么 主题名称为 在形状嵌套中，没有单一/统一的算法或数学方法来嵌套形状并获得尽可能少的空间浪费 第一

我需要实现一个Minkowski和函数，它可以返回2个圆、2个凸多边形或一个圆和一个凸多边形的Minkowski和。我找到了解释如何对凸多边形执行此操作的线程，但我不确定如何对圆和多边形执行此操作。还有，我怎么能代表答案？！我希望算法在O（n）时间内运行，但乞丐不能选择。圆很简单——只需添加中心点，然后添加半径。Circle+ConvexPoly几乎同样简单：按圆半径垂直向外移动每个线段，并使用以原始多边形顶点为中心的圆弧连接相邻线段。通过圆心点平移整个圆 至于你如何表达答案：好吧，这取决于你想

我知道答案是绿色的，但我不知道如何计算 如果有人能给我解释一下，或者只给我一个我能理解的链接，我将不胜感激 谢谢。对于一般情况（其中n>1），递归是n+T（n/2）+T（n/2）。 这可以简化为2T（n/2）+n 通过求解递归的主方法，设a=2，b=2，f（n）=O（n） 根据这个定理，a的对数（基b）是2的对数（基2），显然是1。所以O（n^（a的log（base b））是O（n^（1））是O（n） 主定理的案例2说，如果f（n）的复杂度等于O（n^（a的log（base b）），那么整个递归

假设一个算法在 [5n^3+8n^2（lg（n））^4] 哪个是一阶项？它是带多边形对数的还是多项式的？对于每两个常数a>0，b>0，log（n）^a位于o（n^b）（注意这里的小o符号） 证明这一说法的一种方法是研究当我们在两边应用一个单原子递增函数时会发生什么：对数函数 log(log(n)^a)) = a* log(log(n)) log(n^b) = b * log(n) 因为我们知道，当涉及到渐近符号时，我们可以忽略常数，所以我们可以看到“哪个更大”log（n）^a或n^b，答案与“

我不得不说这三种算法的时间复杂度。 有没有可能有人能看出他们是否正确 我也不确定如何找到θ 我知道θ是大O和ω的平均值。但我觉得在分析代码并用big-O表示法编写代码时，基本上是一样的。第一个似乎是正确的，解释如下，Θ表示法的定义如下 Θ(g(n)) = {f(n) : there exists c1,c2,n0 such that 0 <= c1*g(n) <= f(n) <= c2*g(n) given c1,c2,n0 > 0}

这里sort（S）以时间复杂度O（n^2）对给定整数进行排序。我如何发现上述问题的复杂性。我们需要更高阶的数学来解决这个问题吗？让我们通过考虑最坏情况来简化伪代码 sort(S); for i=0 to n-2 do a = S[i]; start = i+1; end = n-1; while (start < end) do b = S[start] c = S[end]; if (a+b+c == 0) t

时间复杂度检查 intn； int b=1000； 对于（int i=b；i对我来说是正确的，尽管看到int n；这样声明有点奇怪——似乎它应该是一个参数。如前所述，这是一个未定义的行为。哈哈，是的，对不起，我的意思是n比bIf高一些。如果它是在函数中定义的，那么它将是常数时间，所以我认为它必须是一个参数或其他ise runtime定义的时间复杂度是有意义的。它的实际运行时值无论如何不会改变算法的时间复杂度，因此即使在运行时低于b，算法仍然具有相同的复杂度。（int j=3*i；joh是的，它是

这个算法是O（logn）还是O（n）的大Oh表示法？如果优化器真的很好，它就是O（1）。该代码相当于简单地返回m 假设它是给定的，我们可以忽略if（n

我在做一些练习题，我被这个问题弄糊涂了。O（n^2.5）来自哪里？它们是不是以某种方式乘以了大θ？我迷路了。这样想：（x*y）*（x/y）是x^2，对吗？而sqrt（x）是x^0.5。所以把指数加在一起就得到了x^2.5 在第一种情况下，logn可以简化，因为它是乘和除。小心，这是“大θ”，不是“大O”哦，谢谢！这不是更适合数学吗？对不起，我还是不明白他们是怎么得出最终答案的。我是否将红色部分视为（n log（n））*（sqrt（n））*（n/log（n））？那么简化呢？@user239435将

我在寻找下面算法的时间复杂度时遇到了一些问题。虽然乍一看很容易。。。每次输入的结果都不同 for(int i=2; i<=n; i++){ for(int j=2; j*j<=i;j++){ if(i%j==0){ k++; break; } } } for（inti=2；i简短回答：是O（nlogn） for（int i=2；i n = 2, iterations = 0, n*ln

时间复杂度O（n*m）估计为 for i ← 0 to n do for j ← 0 to m do STATEMENT1; end for end for 那么，关于这个算法呢 for i ← 0 to n do for j ← 0 to l do STATEMENT1; end for for k ← 0 to m-l do STATEMENT2; end for end for 因为处理语句1和语

是否有可能在恒定时间内获得数组的切片。如果是的话，方法是什么？最好是python 让数组的大小为n。构建一个只占n一小部分的切片需要O（n）时间。在python中，解释了表示法。你也可以看一下。所以答案通常是否定的，只有对于一个恒定大小的切片，它可以是恒定的时间。这是可能的，我不知道为什么人们会有不同的说法。您只需编写自己的类即可，并且要注意易变性。基本上，您需要实现与列表相同的接口，但请注意如何处理切片 您可以创建一个名为SliceList的类，该类是可编辑的，并在内部将一个列表和两个偏移量存

我听说map函数的计算量是O（1）。 但是我不明白原因。如果我正确理解你的问题，O（1）是接受一个项目的复杂性。JS中的Array.map（）将当前值传递给函数并遍历所有值，然后获取函数的返回值并将其插入到新数组中 因此，函数循环遍历数组中的每个对象，复杂性为O（n） 例如： [1, 2, 3].map(function (item) { return item + 1; }); 所述函数一次获取一项，访问数组n次（3次） 编辑：看来我误解了你的问题，我的错。O（1）的可能副本是一个数组列表，

我需要帮助来确定代码段的时间复杂度 我试图理解如何把所有的东西加起来，但我不确定它是否正确。根据我的理解，第一个循环和第二个循环是对数的，最后一个是线性的，至少我是这么认为的。但我不明白如何最终解决问题并提供时间复杂性 sum = 0; count = 0; for (int i = 1; i < N; i = i*2){ sum = sum + 1; for (int j = i; j < N*N; j = j*2){ count++; }

我试图了解lg*（n）[log*（n）base 2]与lg（n）相比的时间复杂度，我想知道哪一个更快……有人能解释一下吗？提前感谢。我以前从未见过lg*（n）符号，但我假设您指的是log base 2 vs log base 10。结果是，log2（N）==log10（N）*3.32192809489…，这是一个常数因子差，我们在分析算法复杂性时去掉常数因子。因此，所有的对数都被认为是相等的，我们不需要麻烦地指定算法复杂度的基数 在研究实际运行时，log10（N）比log2（N）快，但开发人员很

给定以下函数，我需要确定排列和组合的算法复杂性。函数分别计算任意两个给定数字的可能排列和组合数（n，r） 我认为O（n！）对于Permutations函数可能是O（n！），但我想知道它是否变得更像O（logn！），因为在返回语句中我将n由（n-r） def阶乘（x）： 如果xn： 返回0 elif n==0： 返回0 其他： 返回整数（阶乘（n）/阶乘（n-r）） def组合（n，r）： 如果r>n： 返回0 elif n==0： 返回0 其他： 返回int（（阶乘（n）/阶乘（n-r））/阶乘

这个循环的时间复杂度是多少 for(int i = 0; i < n*n; i *= 2) { //Something with O(1) complexity here } for（int i=0；i=n2时终止，使其运行O（logn2）次迭代 但是，请注意O（logn2）=O（2logn）=O（logn） EDIT：但是，正如Zilog80所指出的，这段代码将i初始化为0，这将导致循环无限运行，因为0*2=0。但是，如果您将其初始化为某个正数（常数），那么您的计算是正确的。是

使用合并算法合并前两个序列，然后使用 新的等等 这个算法的时间和空间复杂度是多少 知道合并算法是O（n），我们必须循环它（n/logn）-1次，所以时间复杂度是O（n*（n/logn）-1）） 对于空间复杂度，每次我们使用大小为k*logn循环（n/logn）-1）倍的临时数组，那么空间复杂度是O（（n/logn）-1）logn