我了解minimax和alpha-beta修剪的基础知识。在所有文献中，他们讨论了最佳情况下的时间复杂度是O（b^（d/2）），其中b=分支因子，d=树的深度，基本情况是首先展开所有首选节点 在我的“最佳情况”示例中，我有一个4级的二叉树，因此在16个终端节点中，我最多需要扩展7个节点。这与O（b^（d/2））有何关系 我不明白他们怎么会变成O（b^（d/2）） O（b^（d/2））对应于α-β修剪的最佳情况时间复杂度： （平均或常数）分支因子为b，搜索 d层的深度，计算的叶节点位置的最大数量

如何计算以下函数的时间复杂度 int Compute (int n) { int j = 0; int i = 0; while (i<=n) { i = 2*j + i + 1; j++; } return j-1; } int计算（int n） { int j=0； int i=0； 而（i如果你在几次迭代中观察i和j的值： i=1 j=1 i=4 j=2 i=9 j=3 i=16 j=4 依此类推。通过数学归纳

假设do_某物是O（1），我如何计算这个函数的时间复杂度 function run(n) { for(var i = 1; i <= n; i++) { var counter = 1; while(counter <= n) { for (var j = counter; j >= 1; j--) { do_something(); } counter = counter * 2;

虽然我不知道从这里该怎么走。我应该从I=0到n计算n/I之和吗？在这种情况下，当存在变量（n）时，如何计算总和 我知道如果我找到L，我会找到需要的迭代次数。当它在L=N/L后终止时，我不能用N来计算L 我对此感到非常困惑。任何洞察都将不胜感激。外部循环有N次迭代。内部循环有平方根（N）迭代。将这两者相乘得出答案 for (k = 1; k <= n; k++) for (i = 1; i*i <= n; i++) // some O(1) operations`

我想检测由2个嵌套循环组成的这段代码的时间复杂度： function(x) { for (var i = 4; i <= x; i++) { for (var k = 0; k <= ((x * x) / 2); k++) { // data processing } } } 函数（x）{ 对于（var i=4；i这里的时间复杂度是O（n^2）。像这样的循环，将i和k的值增加1，其复杂度是O（n），因为有两个嵌

我试图为下面的上界找到最紧的上界。然而，我无法得到正确的答案。算法如下： publicstaticintrecursiveloopy（intn）{ 对于（int i=0；i

有人能给我举一个时间复杂度为平方根（n）的算法的例子吗。平方根时间复杂性到底意味着什么？有很多情况。 这些是可以在根（n）复杂性中解决的少数问题[也可能更好] 找出一个数是否为素数 Grover的算法：允许（在量子上下文中）在与输入大小平方根成比例的时间内搜索未排序的输入 数字的因式分解 您将面临许多问题，需要使用sqrt（n）复杂度算法 作为对第二部分的答复： sqrt（n）复杂度意味着如果算法的输入大小为n，则大约有sqrt（n）基本操作（如排序时的**比较**）。那么我们可以说该算法具

我理解大O符号，但我不知道如何计算许多函数的大O符号。特别是，我一直在试图找出斐波那契序列的原始版本的计算复杂性： int Fibonacci(int n) { if (n <= 1) return n; else return Fibonacci(n - 1) + Fibonacci(n - 2); } intfibonacci（intn） { 如果（n只需问问自己需要执行多少语句才能完成F（n） 对于F（1），答案是1（条件的第一部分）

我写了一个算法，给定一个单词列表，必须检查该单词列表中四个单词的每个唯一组合（无论顺序如何） 要检查的组合数量，x，可以使用二项式系数计算，即x=n/（r！（n-r）！其中n是列表中的总字数，r是每个组合中的字数，在我的例子中总是4，因此函数是x=n/（4！（n-4）！=n/（24（n-4）！）。因此，随着总字数的增加，n增加了要检查的组合数，x，因此，按因数增加对吗 让我吃惊的是，WolframAlpha能够将这个函数重写为x=（n^4）/24− （n^3）/4+（11.n^2）/24− n/

我很难找到一些算法的O时间。我已经搜索了很多注释，但每当我的练习变得更难时，我都找不到解决办法。现在我遇到了一个算法，我真的找不到解决方案。 我已经搜索了堆栈溢出，但没有找到真正有帮助的东西。我找到的最好的帖子是。 它只说了我所知道的，而不是如何计算或看到它。第二篇文章也提到了一些算法和解决方案，但没有提到如何找到它 代码 `for i = 1; i <= n; i++ for j = 1; j <= i; j++ for k = 1; k <= i;

我刚刚开始学习时间复杂性，但我不太明白，你能帮我解答这些问题并解释一下思考方式吗： int Fun1(int n) { for (i = 0; i < n; i += 1) { for (j = 0; j < i; j += 1) { for (k = j; k < i; i += 1) { // do something } } } } void Fun2(int n){ i=o while(i<n){

有没有办法提供以下问题的np完全证明： 给定一组n0-1向量（可视为作业） 每个作业都有许多要执行的任务（例如：v_1=（0,1,1,0）此作业需要任务2和3）。此外，我们还有一个整数T。其思想是将T中的所有向量分开 设置A_i，i=1，…，T。有一些限制： 集合a_i中的作业如果启动，则应在启动同一集合中的下一个作业之前完成 每个任务的成本为1，但如果同时有两个或多个作业共享一个任务j，则成本仅为1 因此，我们的目标是将这一成本降至最低。换句话说，查找分区a_1，…，a_T，以及每个中每个作

假设我试图找到一个函数的复杂性类。每次计算函数时，我的数据集都会翻倍，每次发生这种情况时，执行函数所需的时间都会增加（X）倍 如果我们知道（X），我们如何找到函数的复杂性类/O表示法？例如，如果X略大于2，则大O表示法为O（N logn）。假设T（N）是您所讨论的函数的时间复杂度，其中N是输入数据的大小。我们可以为T（n）编写递归方程： 其中，X是常数。让我们“展开”这个递归： T(n) = X * T(n/2) = X^2 * T(n/4) = X^3 * T(n/8) = ... = X^k

以下哪项是正确的 f（n）是O（n^3） f（n）是Θ（n^2） f（n）是Ω（n^3）如果你分析三个循环，从外部循环到嵌套循环，以下是每个循环的时间复杂度（大O）： O（n），因为迭代次数与n成正比 O（n），因为这个循环的长度的平均值是n/2，因为这是1,2,3，…n的反平均值 O（1），因为这是一个恒定长度的循环（它不依赖于n）。 因此，如果将这三个循环乘以（因为它们是嵌套的），则得到： O（n）*O（n）*O（1）->O（n^2） 欢迎来到Stackoverflow。我有一种明显的感

时间复杂度为O（2^N）。如何推导此代码的空间复杂度 int f(int n){ if(n <= 1){ return 1; } return f(n-1) + f(n-1); } intf（intn）{ 如果（n算法的空间复杂度是算法相对于输入大小占用的总空间。空间复杂度包括辅助空间和输入使用的空间。 基本上，代码段是一个递归代码 对于输入n，它递归地调用n-1 调用值3的示例： f（3） f（2）+f（2） f（1）+f（1）[对于一个f（

1….+n/16+n/8+n/4+n/n..= 2…+n/5+n/4+n/3+n/2…n/n…= 我正在寻找一些算法的时间复杂度，在这些算法中我遇到了一些几何级数。 我相信第一个几何级数有logn。第二个几何级数的时间复杂度是多少？假设1是n*…+1/2^k+…+1/16+1/8+1/4+1/2+1/1/1，答案是2n，因为和1+1/2+1/4+…+1/2^k+…收敛于值2。要了解这一点： 1/1 + 1/2 + … + 1/2^n + … = k (1/1 + 1/2 + … + 1/2^n

摘要） math.prod（）的时间复杂度是多少 如何改进此代码以获得通行证 详细信息） 目前正在处理上的“除自身以外的阵列产品” 我的第一个代码是： 并认为是动态数组中的“删除和插入”导致了时间限制问题 因此，我将一些行更正为： 就我而言，'='和append操作的时间复杂度为O（1），因此认为math.prod是这里提出问题的一个，除了'for'是O（n） 请告诉我这里的时间复杂性，以及一些通过这个问题的技巧 几乎肯定是O（n）；追加是O（1），但在多次调用中摊销。这取决于实现，但一些调用将

将n转换为其英文单词表示形式，其中0对于大于100000000的所有输入n，函数立即返回空字符串，无需任何计算或递归调用。当然，时间复杂度是O（1），同样的空间复杂度（因为较小的n发生的情况完全不相关） 如果你去掉这条线，情况就会不同，也会更有趣 elif n < 1000000000 谢谢你的回复。比如说，如果我更有效地处理字符串连接（附加/扩展到列表，然后连接这些字符串），那么算法会花费O（logn）时间（O（logn）用于字符串连接+O（logn）用于递归调用=O（logn）总体）

在学习合并排序算法时，发现合并排序的时间复杂度为O（nlogn） 想知道我们是否可以说O（n logn）=O（n）*O（logn）？不，这样做真的没有意义。Big-O函数产生函数集，而函数集不能相乘 更一般地说，您通常不会对O（…）结果执行任何操作。没有加法，减法，乘法。没有代数。O（…）通常在一个证明的结论：“基于上面的分析，我得出结论，Fink算法的最坏情况复杂度是O（无论什么）。”它并没有真正出现在它可能会受到代数操作的中间。 （我想你可以执行集合运算。我从来没有见过有人这样做。）实际上，

在一次采访中，我讨论了一些代码，但我认为我没有很好地表达我的代码块 我知道（高级）我们学习了两个for循环==O（n^2），但是当你在工作中做出一些断言，将所做的工作限制在一个恒定的数量时，会发生什么呢 我想出的代码是这样的 String[] someVal = new String[]{'a','b','c','d'} ;// this was really - some other computation if(someVal != 4) { return false; } for(i

我对BFS的复杂性感到困惑。Wikipédia说：“时间复杂度可以表示为O（|V|+|E|），因为在最坏的情况下，每个顶点和每个边都会被探索。” 对我来说，最坏的情况是：每个顶点都连接到所有顶点 因此while循环将执行V次，for循环执行E次。最坏的情况是0（VE） 我做错了什么 BFS的时间复杂度为O（|V|+|E|）。V是总顶点数，E是总边数。您可能会误认为E.E不是顶点u的相邻边 我们可以按如下方式实现这一点 对于顶点中的每个u 对于相邻（u）中的每个e BFS的目的是访问所有节点一次。

问题是：你有3^x硬币，其中一枚比其他的重。你必须使用一套天平来确定那是哪枚硬币。问题是，您只能使用磅秤进行x称重 例如 这不是一个特别好的编程挑战，因为您可以遍历数组查找1，即O（n）。正确的答案是将硬币分成三组，并称前两组的重量。这允许您确定三组中的哪一组包含硬币。反复称量这组硬币，以此类推，直到你只剩下一枚硬币。（可以通过获取子列表的和来模拟称重） 我一直在想这个算法的复杂度是多少。起初，我认为这是O（logn），因为您排除了数据集的一部分以收敛于答案，有点像二进制搜索。但是你必须遍历每个

这是选择排序的正确实现吗？我没有得到O（n-1）复杂的交换与此实现 这是选择排序的正确实现吗 这取决于，从逻辑上讲，你所做的是正确的。它使用“查找数组中的最大/最小值”进行排序。但是，在选择排序中，通常在一次迭代中不需要多个交换。您只需将max/min值保存在数组中，然后在最后将其与第i个元素交换 我没有得到O（n-1）的交换复杂性 你是说n-1倍的互换？是的，这是因为您每次交换都会发现一个更大的值，而不仅仅是最大的值。您可以尝试如下方式重写代码： static int count = 0; f

我有以下代码，并试图找出其时间复杂性： int sum(int m, int n, int K) { int s = 0; for (int i = 0; i < n; i++) { s += i; if (i == K % 2) { for (int j = 0; j < m; j++) { s += j; } } } re

我是理论计算机科学的新手，我想计算以下算法的时间复杂度，该算法计算定义为 我的教科书建议使用斯特林近似 然而，考虑到I=2到n do nf=nf*I的，我可以得到相同的结果的复杂度为O（n-2）=O（n），这是主要的 斯特林近似似乎有点过分了。我的方法错了吗？在第一种方法中，您计算n！，K和（n-k）！然后分别计算二项式系数。因此，因为所有这些项都可以用最多的运算来计算，所以时间复杂度为O（n） 然而，关于计算斯特林公式的时间复杂性，你是错的。您只需要在base 2操作中使用log（n）来计

根据： 陈述：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 = [

每个算法都有很大的欧米茄吗 算法是否可能同时具有大O和大Omega（但彼此不相等-不是大θ） 例如，Quicksort的大O-O（n logN），但它有大的欧米茄吗？如果是的话，我该如何计算呢？大O和大Omega可以为每种算法计算，正如你在中所看到的那样。首先，最重要的是不要混淆边界和情况。一个界限，比如大的Oh，大的ω，大的θ，等等，说明了增长率。一个案例说明了您当前正在考虑由您的算法处理的输入类型 我们考虑一个非常简单的例子来说明上面的区别。考虑典型的“线性搜索”算法： LinearSear

支持向量机学习阶段的实际计算复杂度是多少（比如说，在LibSVM中实现的学习阶段） 谢谢这将严重依赖于svm类型和内核。这是一个相当技术性的讨论。 对于一个快速的答案，假设它是n^2。非线性支持向量机的训练复杂度通常在O（n^2）和O（n^3）之间，其中n是训练实例的数量。以下论文是很好的参考文献： PS：如果你想使用线性核，不要使用LIBSVM。LIBSVM是一种通用（非线性）SVM求解器。它不是线性支持向量机的理想实现。相反，你应该考虑（如LIbSVM的同一作者），或者。这些方法对于

其中，D是通过使用通信协议给出函数f的答案的最佳复杂度，该函数f的输入分布均匀，给出正确答案的概率为$1-\epsilon$。不是线索，而是 这是你问题中的表达谢谢，我们通过chernoff bound解决了它。这个问题有点复杂。

所以在我的讲座中，我的教授演示了如何解决这个问题 Prove n^2 + 2n + lgn = O(n^2) Prove 2n^3 - 3n^2 + 2n is Big Omega (n^3) 对于这个问题，如果我是正确的，我可以用n^2替换lgn和2n 因为它比那些术语增长得快。在这样做之后，我们将以n^2+2n^2+n^2作为g（n） 对于这个问题，他完全去掉了-3n^2，只用n^3替换了2n。 在做了所有这些之后，g（n）就是这个 2n^3 - 3n^2 + 2n >= 2n^3

快速排序的递推方程为 T(n) = T(n/2) + T(n/2) + theta(n) if pivot始终将原始数组划分为两个大小相同的子数组 因此，总体时间复杂度为O（nlogn） 但是，如果两个子列表的比率始终为1:99呢 方程肯定是T（n）=T（n/100）+T（99n/100）+θ（n） 但是我怎样才能从上面的等式中得出时间复杂度呢 我读过另一个答案，它描述了我们可以忽略T（n/100），因为T（99n/100）将主导整个时间复杂度 但我还是不能完全理解 任何建议都将不胜感激 Pl

大O循环的时间复杂度是多少 我从开始，因为这是循环停止的条件 然后使用我们得到的日志规则，用log乘以两边 我不知道如何从这里继续下去 我们可以这么说吗我想你很接近了。将分数拆分为单独的项并分配乘法。然后选择增长最大的结果项。您删除了n^2并保留了log_5（n）。为什么？@zkoza我的错，我认为log_5（n）大于n^2

我在程序中使用此算法： for( i=0 ; i<N ; i++ ) for( j=i+1 ; j<N+1 ; j++ ) for( k=0 ; k<i ; k++ ) doWork(); 对吧?？这三个循环加起来怎么样？感谢@Tim Meyer纠正我的错误： 简单方程给出了（N=0,1,2,3,4,5,6,7,8…）以下系列：0,0,1,4,10,20,35,56,84，可通过以下公式进行解析： u(n) = (n - 1)n(n +

我知道，当你将两个时间复杂度相乘时，你只需像往常一样将它们相乘，例如，n log n的时间复杂度乘以n的时间复杂度就会得到（n^2）log n 但是边界在哪里起作用呢？那么如果nlogn是上界，n也是上界，那么它们的乘积是什么样的界？对于下限上限和紧限的其他组合又会是什么呢？（例如，上限x紧绑定、上限x低绑定和紧绑定x低绑定。） 谢谢您的帮助。这是一个纯数学问题： f（x）是O（g（x））当且仅当存在M，x0使得|f（x）|x0。你会在最基本的复杂性书籍中看到这一点 因此，假设f（x）是O（f（

有人能帮我吗？ 用动态规划的思想重写Count（n）的伪代码。并确定时间复杂度 Test(n) If n=1 return 1 Tn=0 For k=1 to n-1 Tn = Tn + Test(k) * Test(n-k) Return Tn 添加以从递归解决方案中获取DP解决方案： Python代码： d = {} def test(n): if n == 1: return 1 if d.get(n) is not N

下面是一个关于分析我课本中不同乘法算法的时间复杂度的示例： 如果我们通过重复加法进行乘法： 4 * 7 = 7 + 7 + 7 + 7 时间复杂度为O（n*10^n），其中n是数字 当n是数字时，我对分析时间复杂性感觉不好。谁能给我解释一下为什么是O（n*10^n）？一个数字n有O（logn）位，其中logn表示十进制对数。因此，将N与自身相加需要O（logn）个步骤，而这样做M次需要O（mlogn）个步骤。对于M in O（N），可以得到O（N logn）步数。这一估计是基于这些数字。如果你

假设我有一对数据结构；一个表示类型，另一个表示值： data Schema = Leaf | PairOf Schema Schema | ListOf Schema data ValueOf (schema :: Schema) where LeafElem :: String -> ValueOf 'Leaf PairElem :: ValueOf x -> ValueOf y -> ValueOf ('PairOf x y) ListElem :: [Val

我有一个300行的JQ代码，在我处理的文件上运行（字面上是几个小时）（简单的列表是200K-2.5M JSON对象，500MB-6GB大小） 乍一看，代码的复杂度看起来是线性的，但我很容易错过一些东西 在JQ的代码复杂性方面，是否有最常见的陷阱需要注意？或者使用一些工具来识别代码中的关键瓶颈 我有点不愿意公开我的代码，一方面是因为它的大小和复杂性，另一方面是因为它有点专有性 对输入文件进行修剪，以仅保留最相关的对象，并对其进行预压缩，以仅保留所需的字段，这是优化处理流程的明显步骤。我想知道在查询

我很难用O表示法定义以下算法的运行时间。我的第一个猜测是O（n），但是迭代次数和我应用的次数之间的差距并不稳定。我是如何错误地定义这一点的 public int function (int n ) { if ( n == 0) { return 0; } int i = 1; int j = n ; while ( i < j ) { i = i + 1; j = j - 1; } return function ( i - 1

Q）为什么必须是1个时间单位 Q）分析仪是否也可以为假设的机器模型定义此类参数，或者是否使用了某种“标准/惯例”？如果发布在stackoverflow的计算机科学等效网站上，您可能会得到更多的响应（stack exchange是这两个网站的主要组织）：感谢您的反馈，我也会把它贴在那里。！你没有。我从来没有听说过这种“1单位时间”的事情。时间复杂性分析的重点不是任何一种绝对时间度量；这是为了确定随着输入大小的增长，一个算法需要多长时间。也就是说，如果输入的大小增加了一倍，那么该算法所用的时间是否大