Question

我试图计算该算法的时间复杂度，该时间复杂度确定正整数N是否可以表示为x ^ y。该算法的作者是Vaibhav Gupta。

// Returns true if n can be written as x^y
bool isPower(unsigned int n)
{
    // Base case
    if (n <= 1) return true;

    // Try all numbers from 2 to sqrt(n) as base
    for (int x=2; x<=sqrt(n); x++)
    {
        unsigned  p = x;

        // Keep multiplying p with x while is smaller
        // than or equal to x
        while (p <= n)
        {
            p *= x;
            if (p == n)
                return true;
        }
    }
    return false;
}

作者说这个算法是第一个的优化版本，它是：

// Returns true if n can be written as x^y
bool isPower(unsigned n)
{
    if (n==1)  return true;

    // Try all numbers from 2 to sqrt(n) as base
    for (int x=2; x<=sqrt(n); x++)
    {
        unsigned y = 2;
        unsigned p = pow(x, y);

        // Keep increasing y while power 'p' is smaller
        // than n. 
        while (p<=n && p>0)
        {
            if (p==n)
                return true;
            y++;
            p = pow(x, y);
         }
    }
    return false;
}

这是第一个具有不同的时间复杂度，因为他使用pow功能？

Answer 1

当它返回false时，算法会尝试增加所有整数x的幂，直到它们超过n。尝试x = √n后搜索停止。

因此，对于粗略评估，评估权力直到x^d = n大约log n/log x倍增，并从x=2重复到x=√n。

因此复杂性就像

log n.Sum(x=2 to √n)1/log x

不便估算，但O(log n.√n)和Ω(√n)。

pow版本需要log d乘以而不是1来计算功率，前提是它通过重复的方形来实现。作为d = log n/log x，复杂性就像

log n.Sum(x=2 to √n)(log log n - log log x)/log x

更难估算，但O(log n.log log n.√n)和Ω(√n)。

对于int类型所涵盖的n范围，您可以预期pow版本的速度会慢一倍到五倍（除非pow函数的开销很大）。

Answer 2

在我看来，外部循环是n的平方根，内部循环是log n的顺序（因为数字呈指数增长）所以你的复杂性应该是

的调整。

  O(sqrt(n)*log n)

计算此算法的时间复杂度

2 个答案: