Question

我有一个迭代算法，在每次迭代时，计算量逐渐减少。以下是我的算法说明：

Input size: n和Total iteration = k

iter 1: time taken -> f1 * n
iter 2: time taken -> f2 * n
iter 3: time taken -> f3 * n
...
iter k: time taken -> fk * n

其中f1 > f2 > f3 >...> fk和0 <= f1, f2,...,fk <= 1

问题：此算法的时间复杂度是多少？是Big-O(klog n)

Update:

我认为这个问题看起来很模糊。我会用文字解释：

我的算法输入为n，我会在k次迭代中运行它。但是在每次迭代时，输入大小减少了unknown因子。减少没有模式。

例如：

iter 1: input size = n (always n)
iter 2: input size = n/2 (can change)
iter 3: input size = n/5 (can change)
iter 4: input size = n/8 (can change)
...
iter k: input size = n/10 (can change)

Answer 1

给定的信息是不够的，我们可以确定的复杂性是 O((f1+ ... + fk)*n) ¹。

为什么？我将举例说明fi的两个案例 - 每个案例都有不同的复杂性：

案例1： fi = 1/2^i
在这种情况下，我们得到n * 1/2 + n* 1/4 + ... + n*1/2^k < n，算法为O(n)

案例2： fi = 1/i
在这种情况下，我们得到harmonic series：n * 1/2 + n*1/3 + ... + n*1/k = n(1/2+1/3+...+1/k) = O(nlogk)

修改根据您的评论和编辑，似乎算法运行的最坏情况（如果我理解正确）是：

iter1 -> n ops iter2 -> n/2 ops iter3 -> n/3 ops ... iterk -> n/k ops

如果情况确实如此，它与描述的 case2 匹配，则总运行时间为harmonic series：n + n/2 + n/3 + .. + n/k = n(1 + 1/2 + 1/3 + ... + 1/k)，即 {{1} }

（1）从数学角度讲 - 大O是一个上渐近界，从O(nlogk)开始，我们可以推导出算法fi <= 1，但它不是一个严格的界限，如示例所示 - 不同的O(nk)值可以给出不同的严格界限。

Answer 2

修改

更具体地说：

如果你的例子的分母：

iter 1: input size = n (always n) iter 2: input size = n/2 (can change) iter 3: input size = n/5 (can change) iter 4: input size = n/8 (can change) ... iter k: input size = n/10 (can change)

是严格整数，然后是 O（n * log k）。

这就是原因。对于序列Xn为 O（Yn），必须存在一些M，一个实数，并且m，一个整数，使得Xn <1。 M * | YN |对于所有n＆gt;米。

现在考虑序列K = {1,1 / 2,1 / 3，... 1 / k}。还要考虑序列N = {1,2,3,4 ...}。

现在让我们让Yn = N ^ t * K（这是N和K的左外积）。无论fi的值如何，此序列Yn始终大于您的序列。

所以Xn＆lt; 1 * | Yn |，其中Yn是谐波系列乘以n。正如amit所指出的，Yn属于 O（n * log k），所以Xn也是如此。由于我们无法将Xn限制在上方，因此我们对Xn的最佳限制近似也是 O（n * log k）。

迭代算法的时间复杂度

2 个答案: