计算递归关系 T(n)=T(n / log n) + Θ(1)

Posted 2023-02-19

【中文标题】计算递归关系 T(n)=T(n / log n) + Θ(1)

【英文标题】：Calculating the Recurrence Relation T(n)=T(n / log n) + Θ(1)

【发布时间】：2015-08-29 19:40:12

【问题描述】：

这个问题来自Introduction to Algorithms 3rd Edition, P63, Problem 3-6, 其中以迭代函数的形式引入。我重写如下：

int T(int n)
   for(int count = 0; n > 2 ; ++count)
   
      n = n/log₂(n); 
   
   return count;

然后在T(n) 上尽可能严格地限制。

O(log n) 和 Ω(log n / log log n) 可以，但可以更紧吗？

---

PS：使用 Mathematica，我了解到当n=1*10^3281039，T(n)=500000 时

同时，T(n)=1.072435*log n/ log log n

系数随着n 从1.22943 (n = 2.07126*10^235) 下降到1.072435 (n = 1*10^3281039)。

希望这些信息对您有所帮助。

【问题讨论】：

您确实尝试插入其中一个边界并查看它们是否满足循环（可能通过简单的修改），对吗？

我尝试了 Ω，因为我认为它更有可能。似乎是这样，因为 (log log N=23.3777) 可以产生显着差异，而系数变化很小。 @Hurkyl

这个有趣的问题属于计算机科学。我这样标记它。

@Elyasin：我觉得这更像是一个微积分问题而不是计算机科学问题，因为问题的核心是对函数估计进行错误分析。

你可能是对的。我认为这不是编程问题。到现在我只知道CS。

【参考方案1】：

看起来下限还不错，所以我试着证明上限是O(log n / log log n)。 但让我先解释一下其他界限（只是为了更好地理解）。

TL;DR

T(n) 在Θ(log n / log log n) 中。

T(n) 在O(log n)

这可以通过将n := n/log₂n修改为n := n/2来查看。 它需要O(log₂ n) 步骤直到n ≤ 2 成立。

T(n) 在Ω(log n / log log n)

这可以通过将n := n/log₂(n)修改为n := n/m来看到，其中m是log n的初始值。 求解方程 n / (log n)<sup>x</sup> &lt; 2 for x 引导我们到

日志 n - x 日志日志 n

提高上限：O(log n) → O(log n / log log n)

现在让我们尝试改进上限。我们不是将n 除以一个固定常数（即上述证明中的2），而是将n 除以log(n)/2 的初始值，因为log(n) 的当前值更大。为了更清楚，请查看修改后的代码：

int T₂(int n)
     n_old = n;
     for(int count=0; n>2 ;++count)
     
         n = n / (log₂(n_old)/2);

         if(log₂(n)) <= log₂(n_old)/2)
         
            n_old = n;
         
     
     return count;

函数T₂ 的复杂度显然是函数T 的上限，因为log₂(n_old)/2 < log₂(n) 一直存在。

现在我们需要知道每个1/2⋅log(n_old)除以多少次：

n / (log(sqrt(n)))^x ≤ sqrt(n) ⇔ n / sqrt(n) ≤ log(sqrt(n))^x ⇔ log(sqrt(n)) ≤ x log(log(sqrt(n))) ⇔ log(sqrt(n)) / log(log(sqrt(n))) ≤ x

所以我们得到了递归公式T₂(n) = T(sqrt(n)) + O(log(sqrt(n)) / log(log(sqrt(n))))。

现在我们需要知道这个公式需要多久扩展一次，直到n < 2 成立。

n^2-x-x⋅log n

所以我们需要将公式扩展为log log n 次。

现在变得有点难了。 （也可以看看Mike_Dog's answer）

T2(n) = T(sqrt(n)) + log(sqrt(n)) / log(log(sqrt(n))) = Σ_{k=1,...,log log n - 1} 2^-k⋅log(n) / log(2^-k ⋅log n)) = log(n) ⋅ Σ_{k=1,...,log log n - 1} 2^-k / (-k + log log n)) (1) = log(n) ⋅ Σ_{k=1,...,log log n - 1} 2^{k - log log n} / k = log(n) ⋅ Σ_{k=1,...,log log n - 1} 2^k ⋅ 2^{- log log n} / ķ = log(n) ⋅ Σ_{k=1,...,log log n - 1} 2^k / (k ⋅ log n) = Σ_{k=1,...,log log n - 1} 2^k / k

在标有 (1) 的行中，我重新排序了总和。

所以，最后我们“只”必须为t = log log n - 1 计算Σ<sub>k=1,...,t</sub> 2<sup>k</sup> / k。此时 Maple 解决了这个问题

Σ_k=1,...,t 2^k / k = -I⋅π - 2^t⋅LerchPhi(2, 1, t) +2^t/t

其中I 是虚数单位，LerchPhi 是Lerch transcendent。由于上述总和的结果对于所有相关情况都是实数，因此我们可以忽略所有虚部。 Lerch 超越者LerchPhi(2,1,t) 似乎在O(-1/t) 中，但我对此不是100% 确定的。也许有人会证明这一点。

最终结果是

T₂(n) = -2^t⋅O(-1/t) + 2^t/t = O(2^t/t) = O(log n / log log n)

我们有T(n) ∈ Ω(log n / log log n)和T(n) ∈ O(log n/ log log n)， 所以T(n) ∈ Θ(log n/ log log n) 成立。您的示例数据也支持此结果。

我希望这是可以理解的，它会有所帮助。

【讨论】：

感谢您的回答。此外，我刚刚学习了一个所谓的“主定理”来简化你证明的最后一部分，你可以在下面我自己的答案中看到。

【参考方案2】：

验证推测估计的问题的核心是得到一个很好的塞值估计

n / log(n)

进入函数

n --> log(n) / log(log(n))

定理：

log( n/log(n) ) / log(log( n/log(n) )) = log(n)/log(log(n)) - 1 + o(1)

（如果出现字体可读性问题，那就是小哦，不是大哦）

证明：

为了节省符号，写

A = n
B = log(n)
C = log(log(n))

这项工作基于（自然）对数的一阶近似：当0 < y < x，

log(x) - y/x < log(x - y) < log(x)

我们试图估计的值是

log(A/B) / log(log(A/B)) = (B - C) / log(B - C)

应用差的对数的界限得到

(B-C) / log(B) < (B-C) / log(B-C) < (B-C) / (log(B) - C/B)

也就是说，

(B-C) / C < (B-C) / log(B-C) < (B-C)B / (C (B-1))

我们试图满足的递归和下限都表明我们应该用B/C - 1 来估计它。把它从两边拉下来

B/C - 1 < (B-C) / log(B-C) < B/C - 1 + (B-C)/(C(B-1))

因此我们得出结论

(B-C) / log(B-C) = B/C - 1 + o(1)

---

如果你从这个分析中拿走一个想法来自己使用，那就让它成为使用微分近似（甚至更高阶的泰勒级数）来用更简单的函数代替复杂函数的重点。例如一旦你有了使用的想法

log(x-y) = log(x) + Θ(y/x) when y = o(x)

那么您的问题所需的所有代数计算都可以直接进行。

【参考方案3】：

感谢@AbcAeffchen 的回答

我是题主，利用昨天学到的“大师方法”的知识，证明“稍微难一点”的部分可以简单的做如下。

我将从这里开始：

T(n) = T(sqrt(n)) + O(log(sqrt(n)) / log(log(sqrt(n))))
⇔ T(n)=T(sqrt(n)) + O(log n  / log log n)

让

n=2^k , S(k)=T(2^k)

那么我们有

T(2^k) =T(2^k/2) + O(log 2^k / log log 2^k) ⇔ S(k) =S(k/2) + O( k/log k)

用主方法

S(k)=a*S(k/b)+f(k)，其中a=1, b=2，f(k)=k/log k = Ω(k^{log₂1 +ε}) = Ω(k^ε)，

只要ε∈(0,1)

所以我们可以应用案例 3。然后

S(k) = O(k/log k)

T(n) = S(k) = O(k/log k) = O(log n/ log log n)

【讨论】：

这比我的容易多了：D