在 O(n) 时间内计算 2^n

Question

不使用位移，有什么方法可以在 O(n) 时间内计算 2^n？

我正在考虑使用记忆的解决方案，因为我总是先从较低的 n 开始计算。 即

d = dict()
def pwr2(n):
    if n == 0:
       return 1
    if n == 1:
       return 2
    if n in d:
       return d[n]
    d[n] = 2 * pwr2(n-1)
    return d[n]

但我不太确定复杂性是什么。

编辑：我应该补充一点，我正在使用算法的一部分以比 O(n^2) 时间更快的速度将二进制转换为十进制。作为我的分治算法的一部分，我必须乘以 2 的幂次方，这就是我尝试记忆的原因。

EDIT2：在这里发布我的完整算法以帮助解决混淆 pwr2dict = dict()

def karatsuba(x, y):
    // use karatsuba's algorithm to multiply x*y


def pwr2(n):
    if n == 0:
        return 1
    if n == 1:
        return 2
    if n in pwr2dict:
        return pwr2dict[n]
    pwr2dict[n] = karatsuba(pwr2(n-1),2)
    return pwr2dict[n]


def binToDec(b):
    if len(b) == 1:
        return int(b)
    n = int(math.floor(len(b)/2))
    top = binToDec(b[:n])  # The top n bits
    bottom = binToDec(b[n:])  # The bottom n bits
    return bottom + karatsuba(top, pwr2(len(b)-n))

print binToDec("10110") // Prints 22

Answer 1

我们可以在Time = T(f(n)) + T(g(n)) 中实现它，其中f(n) 是构造一个二进制数n binary-digits 所用的时间，g(n) 是将该数字转换为十进制所用的时间。

Test Code Online

public BigInteger pow_2 (int n)
{
    String binary = "1";
    for (int i=0; i<n; i++) binary += "0"; // f(n)
    return new BigInteger(binary, 2); // g(n)
}

并且由于编译器优化，f(n) 将得到T(f(n)) 和Θ(1)。

至于g(n)，代表BigInteger(value,radix)的构造函数，g(n)基于有多少个二进制数字，其中2^n在二进制中是一个有n+1数字的数字。

Answer 2

我认为你想多了你的问题。 2^n 仅表示将自身乘以 2 n 次。所以一个从 1 到 n 的简单循环就可以了：-)

r = 2
for 1 to n do
  r = r * 2
end

这是在O(n) 中运行的解决方案，计算2^n 的真正问题是，在现代计算机上，您将达到相当小的n 的体系结构字长，例如32、64 或128。然后你必须使用任意长度的整数，这可能不会给你足够的O(n) 时间，但这是一个不同的问题:-) 从理论上讲，它可以在O(n) 中轻松完成。

编辑

好的，如果我理解正确，你有一个很长的二进制字符串，你想把它转换成十进制。

我会按如下方式实现它：

将长度为n 的二进制字符串放入数组s（可以是位图以节省空间，也可以是支持这些的编程语言中的字符串）。反转字符串，使 LSB 位于索引 0 处（如果不是这样的话）。

e := 1
r := 0
for i := 0 to (n - 1) 
  if s[i] = 1
    r := r + e
  end
  e := e * 2
end

反转字符串可以在O(n)中完成，伪代码只有一个从0到n - 1的循环，所以在O(n)中也是如此。位串反转可以避免在循环中进行一些简单的算术运算。并不是说r 必须是任意长度的整数类型。

Answer 3

您实际上可以在 O(1) 时间内完成。乘以 2 本身意味着左移 n-1 位。或将 1 左移 n 位。

您的问题可以通过以下方式解决。 long k = 2 << n-1. 要么 long k = 1 << n.

是不是很简单？

编辑 我意识到这是在没有位移的情况下完成的。你仍然不需要 O(n) 时间。可以在 O(logn) 内完成

private int power(int x, int n) {

    if (n == 1)
        return x;
    if (n % 2 == 0) {
        int power = power(x, n / 2);
        return power * power;
    } 

    else{
        int power = power(x, (n - 1) / 2);
        return x * power * power;
    }
}

详细了解递归Recursion