在Aho、Hopcroft和Ullman的一本书中，算法A1的时间复杂度为O（nlogn）。最大问题大小为“n”。假设一个时间单位等于一毫秒，则在一秒钟内可解决的最大问题大小为140，同样，在一分钟内为4893，在一小时内为2.0×10^5。有人能解释他们是如何得到这个结果的吗？我相信这本书是在建议解决t=n lg n（即直接使用边界函数并忽略任何C），其中t是“毫秒时间”-如果是，请参阅。或者，绘制函数图并检查相关Y（f（n）=O（n lg n））值的相关X（n）值。 140 * log 14

分析的概念不是特定于某些值的，通常用大Oh表示，不包括系数和低阶项。在您的代码中，时间复杂度将是O（T*N）。它永远不会是O（50*100）或O（100）。没有这样的表示法。任何以恒定时间运行的算法（代码中为50*100）将表示为O（1） 在一个线性函数中，时间复杂度永远不会是一个值，它将被表示为一个依赖于输入大小的函数 另外，为了有一个清晰的理解，我建议您阅读本教程：分析的概念并不是特定于某些值，通常用大Oh表示，不包括系数和低阶项。在您的代码中，时间复杂度将是O（T*N）。它永远不会是O（5

以下代码的时间复杂度是多少？在第二个for循环中，j递增j=j*2 `int k=0; for(i=1;i<=n;i++) for(j=1;j<n;j=j*2) k=k+1; return k;` `int k=0； 对于（i=1；i两个循环是独立的，因为两者都不依赖于另一个。因此，我们可以将两个嵌套循环的复杂性表示为单个复杂性的乘积。在这种情况下，i中的外循环是O（n），而j中的内循环是O（lgn）（n的对数基数2）因此，总时间是O（nlgn） 查

合作伙伴的确切定义（正式和非正式）是什么 与p一般来说，如果你有一个复杂类X，那么类co-X由所有问题组成，这些问题是X中问题的补充。例如，类NP（直觉上）对应的问题是，如果问题的答案是“是”，那么有一些快速的方法来检查答案。因此，类co-NP包含一些问题，如果答案是“否”，那么有一些快速的方法来检查答案。“这是一个布尔公式；有没有办法分配变量值以使其成为真的？”这是NP中问题的典型例子，因为如果答案是“是”，你可以很容易说服某人-只要向他们展示如何设置每个变量以使整个计算结果为真。“这是一个布

我需要计算以下循环的时间复杂度： for (i = 1; i < n; i++) { statements; } （i=1；i

有人问了我一个我觉得奇怪的问题。给定以下两个等式，哪个是真的，哪个是假的（或者它们都是真的还是假的） O（n^2）=O（n^3） O（n^3）=O（n^2） 对我来说，这个问题似乎很荒谬，因为O（f（n））只意味着在一段时间内函数T（n），lim as n->infty of T（n）O（f（n））可以被认为是所有函数的类，其增长在f（n）之上。考虑到这一点，这两个选项都是错误的。，特别是其中的部分，它说“当一个人断言E1=E2，其中E1和E2是由上述表达式表示的集合时，应该始终将其解释为E1⊆

我正在考虑如何正确计算此函数的时间复杂度： def foo(lst): jump = 1 total = 0 while jump < len(lst): for i in range(0, len(lst), jump): total += i jump = jump * 2 return total def foo（lst）： 跳转=1 总数=0 当跳跃

我的问题是： 在数学中loga+logb=logab 这对BigO符号仍然有效吗 两次日志搜索loga+logb是否等于一次搜索logab？是的，因为您可以用熟悉的代数方法操作Big-O表示法中的术语，O（loga+logb）=O（logab） 但是，当谈到两个连续搜索时，将其保留在O（loga+logb）可能更直观。如果要与其他算法进行比较，或者试图找到主导项，则可能需要将其简化为O（Log AB）。是的，它们是。您可以将矩阵视为平坦矩阵，即A*B长度的数组；这里的二进制搜索具有O（log（A

假设我有以下几点： 1- a code snippet "CODE1" with time complexity O(N^2) 2- a code snippet "CODE2" with time complexity O(L*N) 如果我将两个代码段集成到一个java程序中，如： public class Main { CODE1; CODE2; } 我能说这个程序的复杂度是O（N^2+L*N）吗？只有当N依赖于相同的输入时，复杂度才会是O（N^2），因为它是主要术语

我需要证明/反驳以下句子： 对于每个f（n）=O（logn）意味着2^（f（n））=O（n） 我认为这是真的，因为2^（log（n））=n. 你认为呢？f（n）=O（logn）意味着有一个正常数M，因此最终（对于所有足够大的n），我们有| f（n）|假设这个问题包括答案将一起转移到cs（理论）： 您可以查看O（…）的定义。 如果f（n）=O（logn），这意味着存在一些常数M，使得| f（n）|

我想知道本体论的计算复杂性。我正在使用NIFSTD本体，并希望根据一些特定的查询计算时间（大O）建立一个层次结构 我已经读到SPARQL本身就是。如您所知，本体通常基于RDF，并使用SPARQL进行查询 我想要在本体中搜索一个概念（select）和使用一个条件（where{…}）进行搜索的成本 此外，打开和读取本体的计算复杂性是否为O（n），其中n等于本体文件的大小 提前感谢,， Aref搜索已知IRI的概念非常快-大多数API都有这些的索引，因此可以假设为O（1） 使用搜索，其中条件完全取决于

这只是为了检查字符串中的所有字符是否唯一。 我从其他示例中了解到，对于内循环，它通常位于^2，但在本例中，内循环不是从索引0开始的。它从下一个元素开始，不管temp[i]是什么。所以我有点搞不清楚如何确定时间复杂度 外循环第一次迭代中的比较次数为n。第二种情况是n-1，依此类推到0。所以我们有一个总数： boolean isUnique(String s){ char [] temp = s.toCharArray(); for(int i = 0; i &l

如何计算快速联合算法的最坏情况。 事实上，当涉及到树高时，我总是在时间复杂性上挣扎。我知道它与O（h）有关，但是树是在代码中发展的 那么正确的方法应该是什么呢 如果有的话，你正在使用哪些启发式方法（按等级合并？路径压缩？）这些分析可能非常重要！嗨，只是基本的实现，不涉及优化

基本上，我不确定如何衡量时间复杂性 我知道TSP是一个NP难问题，这意味着用来解决它的算法的时间复杂度是指数的：O（2^n） 如果我将子问题分解并解决子问题，它们将结合起来形成完整的解决方案，会怎么样？时间复杂性不那么正确？可能是这样的： 如果n=1，则O（n）=1 O（n）=a（n/b）+cn 将大小为n的问题划分为大小为n/b的子问题，这里cn是线性时间复杂度 参考： 那么，如果采用分而治之的方法，这是否意味着时间复杂度为O（n logn）？我觉得这个逻辑有问题。通过分而治之的方法不可能将指

在我的书中有一个选择题： 以下函数的大O表示法是什么： n^log2+logn^n+nlogn 我认识那个洛根！属于Onlogn，但我在网上看到它们是等价的。洛根怎么样！和说nlogn一样吗？ 如何： logn！=logn+logn-1+…+log2+log1 等价于nlogn？设n/2为n除以2的整数的商。我们有： log(n!) = log(n) + log(n-1) + ... + log(n/2) + log(n/2 - 1) + ... + log(2) + log(1)

我对这一点完全陌生，所以一步一个脚印会非常有帮助，谢谢。首先，你可以从开始了解它的行为 T(n) = 2T(n-1) + 1 = = 2*(2T(n-2) + 1) + 1 = 4T(n-2) + 3 = 4(2T(n-3) + 1) + 3 = 8T(n-3) + 7 = 8*(2T(n-4) + 1) + 7 = 16T(n-4) + 15 = 16*(2T(n-5) + 1) + 15 = 32T(n-5) + 31 现在，我们了解了行为，我们就

我想知道用大O表示法确定国际象棋将死的图形搜索算法的复杂度是多少。。第一步有16种可能，仅兵一种，骑士一种有4种，第二部电影也有同样的可能。在这之后，可能性列表增长到一个无法计算的水平 世界上最好的象棋引擎使用“最可能”的图形搜索 这篇维基百科文章非常有用： “Allis还估计博弈树的复杂度至少为10123，”基于平均分支因子35和平均博弈长度80。作为比较，可观测宇宙中的原子数（经常与之比较）估计在4×1079和1081之间。”国王最多有八步。而且每次移动后都要花一定的时间来验证国王是否受到威

考虑到Lee和Preparata将一个简单多边形分割成单调片段的算法，我读到，如果我们的多边形用DCEL表示，则添加每个新对角线可以在O（1）时间内完成。但我不知道那时候怎么做 我认为我们需要为O（n）半边更改面。我们只有一条对角线，所以它的插入取O（n）

有人能帮我找出并解释一下以下python函数的时间和空间复杂性吗 #L is a list of length N def countdist(L, i): if L[i] in L[i+1:]: return L[i+1:].index(L[i]) + 1 else: return 2*N - i + 1 填充L的元素类型是什么？请分享更多关于你的想法的细节，让回答者更容易开始。填充L的元素类型是什么

我今天有个工作面试。被问及std:set\u交叉点的复杂性。我在回答时提到了这一点 O（n+m） 等于： O（最大值（n，m）） 有人告诉我这是不正确的。我试图证明与以下内容等价，但没有成功： O（0.5*（n+m））≤ O（最大值（n，m））≤ O（n+m） 我的问题是：我真的错了吗？对于所有的m，n≥ 0最大值（m，n）是有效的≤ m+n→ O（m+n）和m+n中的最大值（m，n）≤ 2max（m，n）→ O中的m+n（最大值（m，n）） 因此O（max（m，n））=O（m+n） 附录：

假设T1（n）和T2（n）是P1和P2程序的运行时间，并且 T1（n）∈ O（f（n）） T2（n）∈ O（g（n）） 当P1沿P2侧运行时，T1（n）+T2（n）的量是多少 答案是O（max{f（n），g（n）}）但是为什么呢 答案是O（max{f（n），g（n）}） 只有当程序彼此独立运行时，这才是正确的。无论如何，让我们假设，情况就是这样 为了回答为什么，我们需要仔细看看BIG-O符号代表什么。与您陈述的方式相反，它不代表时间，而是复杂性的上界 因此，虽然运行这两个程序可能需要更多的时间，

给你2个整数数组 A=[1, 2, 1] B=[2, 3, 3] so fractions are: 1/2, 2/3, 1/3 A是分子，B是分母。 所以分数是：1/2，2/3，1/3 查找总和为1的所有对 示例：这里我们有2/3+1/3=1，所以count=1 返回1 返回模10^9+7，因为输入可能很大 我在O（n^2）中做了一次，然后计算2的加法，检查它是否为1，并更新计数器 在

我试图从理论上理解，当传递给merge sort的输入大小加倍时，需要多长时间。我当时正在读一本教科书，上面写着： “因为合并的运行时间（对于大N）是O（n Log2 2n），所以我们应该考虑比率，r= n^ { 1.1 } Log2（n^ { 1.1 }）/（n Log2（n）），这简化为1.1 n^ { 0.1 }，该值在3.5“左右”。 我想问他们是如何计算的，当输入大小增加一倍时，执行合并排序需要大约3.5倍的时间。本质上，他们希望如何进行转换。使用对数算法： 这仍然取决于N 我的猜测

有一种理论认为六度的分离度是最高的 通过熟人链将人们联系起来的程度。 （你知道面包师-分离度1，面包师认识某人 您不知道-分离度2） 我们有一份人员名单，一份相应熟人的名单 在这些人中，有一个人x 我们正在尝试实现一种算法来检查personx是否尊重 六度分离。如果距离x 对于中的所有其他人，P最多为6，否则为false 我们正努力在最坏的情况下完成O（| p |+| A |） 为了实现这个算法，我考虑在邻接矩阵上实现一个邻接列表，用顶点p和边A表示图G，因为邻接矩阵需要O（n^2）遍历 现在我

难以找到最坏情况下的时间复杂度。这种情况适用于大小相同（n）的两个排序数组的交集 不确定如何计算带有两个条件的while循环，或者如何计算if和elseif语句 我知道大0将是N+N，但不知道如何显示最坏的情况 int printIntersection(int arr1[], int arr2[]) { int i = 0, j = 0; while (i < n && j < n) { if (arr1[i] < arr2[j])

我在课本上偶然发现了这个问题： “一般来说，Prim、Kruskal和Dijkstra算法的时间复杂度取决于什么？” a。图形中的顶点数。 B图形中的边数。 C这两个参数都取决于图中顶点和边的数量 解释你的选择 因此，根据维基百科Prim的说法，Kruskal和Dijkstra的算法最坏情况下的时间复杂度分别是O（ElogV），O（ElogV）和O（E+VlogV）。所以我猜答案是c？但是为什么呢？我不知道普里姆和克鲁斯卡尔的情况，可能对迪杰斯特拉的情况是错误的，但我认为在这种情况下答案应该是b

我试图学习各种程序/算法的时间复杂性。有人知道吗，我在哪里可以得到一套解释的示例，比如在现场找到的示例（标题练习） 先谢谢你 谷歌 看

我们现在正在学习时间复杂性，我在这个例子中遇到了很多麻烦 for (i = 2; i < n; i = i * i) { ... do something ... } （i=2；i

在大Oh符号中，n是什么意思？我看到了向量的输入大小和长度。如果是输入大小，是指计算机上的内存空间吗？我看到n经常与输入大小互换使用 大的例子哦, O（n）是线性运行时间 O（logn）是对数运行时间 代码复杂性分析示例，（我正在将输入n更改为m） 这是O（n）。n是什么意思？它需要多少内存？可能n向量中元素的平均数？那么，当n=3是单个数字时，您如何解释 n通常表示输入数据量 例如，以10个元素的数组为例。要迭代所有元素，需要十次迭代n为10 在您的示例中，n也是描述输入数据大小的值。如您所见

用数学术语来说，这个程序的复杂性是什么 int main() { int k = 1, n; cin >> n; //User Input while(k < n) { k = 7*k+5; } } intmain（） { int k=1，n； cin>>n；//用户输入 而（k

大O复杂度估计 inti，j； int n=（某个值）； int B=1000； 对于（i=B；i您在stackoverflow上搜索过这个主题了吗？似乎是重复的。哦，真的吗？是否有重复？此代码不会在较大的n值时终止，因为内部循环更改了用于外部循环的相同变量i。内部循环总是离开i=B+1。谈论这个问题没有意义不终止的算法的时间复杂度。嗯。那么这就没有时间复杂度了？ int i,j; int n=(some value); int B=1000; for (i=B;

我正在读一本关于竞争编程的书，遇到了一个问题，我们必须计算n*n矩阵中所有可能的路径。 现在的条件是： ` 现在，这是我的问题代码： typedef long long ll; ll path_count(ll n,vector<vector<bool>>& done,ll r,ll c){ ll count=0; done[r][c] = true; if(r==(n-1) && c==(n-1)){ fo

鉴于此代码： intf（intn） { int j=10； while（jC1=-6。这是一个有趣的方法，你有没有其他方法，通常不是用来解决这个问题，而是用来解决像this@aliberro这是另一个更广泛的问题。如果你有其他类似的任务，那么发布它，我们将看看我们能做些什么。

我相信这会更快： //伪码 for() {} for() {} for() {} 除此之外： for() { for() { for() { } } } 我说得对吗？是的，你说得对。 第一个具有O（n）的复杂性，而第二个位于O（n3）[n立方体]

简单的问题。使用一个mxn矩阵，我正在做一些O（mn）运算。我的问题是O（mn）是否在O（n^2）中。看看big O上的维基百科，我想是的，但我一直不太了解复杂性的界限，所以我希望有人能澄清一下。m*n是O（n2），如果m是O（n） 我假设对于矩阵，您可能会有m=O（n），这是列的数量，而n是行的数量。所以m*n=O（n2）。但是谁知道你的矩阵会有多少列呢 这完全取决于m有什么界限 看看。O（mn）对于mxn矩阵意味着你对矩阵的每个值都做恒定的功 O（n^2）意味着，对于每个列，您所做的工作都是

哪一个是假的 对数（n^3*9^n）是θ（9^n） 对数（n^5*4^（n^2））是θ（n^2） C.log（n！）是θ（nlogn） D.log（n）是θ（logn） E.cos（3logn^4/19e^n）是θ（1） 我相信是E，因为余弦是自然振荡的。因此，说它是紧有界的O（1）是错误的。然而，答案是A，我不明白他们是如何得出这个结论的 这是一个同学为准备考试而创建的，他们没有提供解决方案。谢谢大家! E没有说它是以O（1）为界的；它说是θ（1）。对不起，输入错误。然而，我仍然不明白θ（1）

下面循环的时间复杂度和平铺是多少 for (int i = N/2; i < N; i++) { for (int j = i; j < N; j++) { doSomething(i, j); } } for（int i=N/2；i

数据结构中二叉树的顺序、后序和前序遍历的时间复杂度是多少？？是O（n）还是O（logn）还是O（n^2） O（n），因为每个节点遍历一次。或者更确切地说，您为每个节点所做的工作量是恒定的（不取决于其余节点）。对于任何顺序，Travesal都是O（n）-因为您只对每个节点执行一次操作。如果树具有某种组织模式（即二叉搜索树），则查找可以小于O（n）。O（n），我会说。 我所做的是一棵平衡树，适用于所有的树。 假设使用递归 T（n）=2*T（n/2）+1------>（1） T（n/2）表示左子树，T

我想问一个关于时间复杂性的问题 Sum (array,n) { 1.1 total_sum = 0; 1.2 for (i=0;i<n;i++) 1.2.1 total_sum = total_sum +array[i]; 1.3 return total_sum; } Sum（数组，n） { 1.1总和=0； 1.2对于（i=0；i比如说，i=n-1。它被递增，循环返回；再进行一次比较，这次它的计算结果为false（因为i现在等于n）。总之，您运行这个0，1，…，n次，每次执行两个操作

如果矩阵有行“r”和列“c”，则打印每个矩阵位置的复杂性为O（r*c） 但是，如果列长度不均匀，例如：List List=new ArrayList（）我们需要打印每个字符，复杂性会是多少 O（n*m）-其中n是字符串的数量，m是最长字符串的长度 这个问题的目的是验证我的复杂性。如果stack overflow不是正确的网站，我请求在适当的位置提醒我提出这个问题。通常在进行大O分析时，您会在限制内进行分析，或者基本上是在最坏的情况下进行分析。因此，对于长度可能不均匀的列，最糟糕的情况是它们的长度

假设函数f的复杂度等级为O（N（logn）2），对于N=1000，程序在8秒内运行。 如何编写一个公式T（N）来计算任何大小为N的输入运行f所需的近似时间 答案如下： 8 = c (1000 x 10) c = 8x10^-4 T(N) = 8x10-4* (N log2 N) 我不明白第一行，10是从哪里来的？ 谁能给我解释一下答案吗？谢谢 O（N（logn）^2）描述了运行时如何以N进行缩放，但它不是以秒为单位计算运行时的公式。事实上，Big-O表示法通常不会给出精确的标度函数本身，而是

这是一个关于算法复杂性的问题。如果我正在创建一个循环（例如“for”循环），并且想要测试在这个循环中返回的值的素性（在一些操作之后），因此，我运行一个内部循环。相反，如果我创建一个函数来测试素性，然后在第一个循环中调用该函数，时间复杂度仍然保持不变，对吗？ 这两种情况的复杂性是什么？怎么计算呢 多亏了代码的复杂性是用空间和时间来衡量的。让我们试着理解时间的复杂性 让我们来看一种测量时间复杂度的方法，它是最著名的，被称为大O形环。根据维基百科，“大O表示法是一种数学表示法，它描述了当参数趋向于某个

在表方法或记忆递归方法中，动态规划的每一个代码都具有相同的时间复杂度吗 如果能提供一个合适的示例，我们将不胜感激。时间复杂性-是（如果您在备忘录中忽略函数调用/返回） 空间复杂性-否。制表可以通过覆盖以前计算但不再需要的值来节省空间 如本答案“最佳性”部分所述- 如果您访问（或尝试访问）子问题的顺序不是最优的，则这两种方法都可能不是时间最优的，特别是如果有多种方法来计算子问题（通常缓存可以解决此问题，但在某些特殊情况下，理论上缓存可能不会）。记忆通常会在空间复杂度的基础上增加时间复杂度（例如，使

考虑以下代码： void counterMethod(int n) { int count=0; for(int i=0; i<n; i++) { count++; } } void计数器方法（int n） { 整数计数=0； 对于（inti=0；i在这样的边缘情况下，理论家使用的“输入大小”的正式定义与大多数程序员在考虑实际代码时使用的实际定义不一致 “输入大小”的正式定义是表示输入所需的位数（有时是机器字）。在大多数情况下，这与数组长度、字典

如果n为奇数：3*（n-1）/2 如果n为偶数：3n/2-2 这里n=100 3n/2-2=3*100/2-2=148 147.1到148.1之间的数值是多少？也许我不理解这个问题的格式，但非整数所需的比较次数如何？给出的答案是否错误？不一定。我只是想知道允许比较的0.1存在的心态-什么是比较的0.1？甚至我也在想同样的问题。 (A) 147.1 to 148.1 (B) 145.1 to 146.1 (C) 140 to 146 (D) 140 to 148

从使用线性探测的哈希表中删除条目的最佳方法是什么？我知道这样做的一种方法是使用标志来指示已删除的元素？还有比这更好的方法吗？通过减少值之间的间距来实现myabe？ 时间复杂度是多少？请展示您的研究成果：编辑代码并将其放入问题。请展示您的研究成果：编辑代码并将其放入问题。

我想知道一个算法的复杂度和一个问题的复杂度之间的区别，也就是说，哪一点不同于这两件事好问题！大多数人对这两者没有区别，这是一个很大的禁忌 简单地说，算法的复杂度是算法的运行时间。这可以用很多方式来表示，大O，大θ，或者任何一种。还有其他表示法，但最常用的是大O表示法，它可用于分析作为输入大小函数的算法最坏情况下的时间复杂度 问题的复杂性通常是解决问题的任何算法的下限（这里是一个不错的资源）。例如，我们可以证明基于比较的排序的下界为n log n。这意味着，任何通过比较元素进行排序的算法，无论是哪

我试图找出以下两个函数的时间复杂性： 第一个 public static int myMethod1(int[] arr) { int x = 0; for (int i = 0; i < arr.length / 2; i++) { for (int j = 0; j < arr.length; j++) { for (int k = 0; k < arr.length; k++) { x

假设您的代码具有完全缩进，如下所示： void function(int n) { int count = 0; // outer loop for (int i=n/2; i<=n; i++) // middle loop for (int j=1; j+n/2<=n; j = j++) // inner loop executes log n times for (i

我在寻找下面算法的时间复杂度时遇到了一些问题。虽然乍一看很容易。。。每次输入的结果都不同 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