Question

我刚遇到一个问题，我们应该计算一个大范围数字的二进制表示形式中的1。是否有任何算法或技术可以轻松找到它？例如，对于输入N = 6，其先前数字的二进制表示形式中的1的数目。喜欢， 1 - 0001 - No. of 1's = 1; 2 - 0010 - No. of 1's = 1; 3 - 0011 - No. of 1's = 2; 4 - 0100 - No. of 1's = 1;
5 - 0101 - No. of 1's = 2;

约束：1 <= N <= 10 ^ 20

所以总数是7（1 + 1 + 2 + 1 + 2）。还有其他技巧可以找出答案吗？提前致谢！

Answer 1

让S（n）为数字0到n的集合（没有重复项，但是以任何顺序）。然后是S(2n+1) = {2*s for s in S(n)} + {2*s+1 for s in S(n)}和S(2n) = {2*s for s in S(n)} + {2*s+1 for s in S(n-1)}。

两个例子：

S(7) = {2*s for s in S(3)} + {2*s+1 for s in S(3)}
     = {0, 2, 4, 6} + {1, 3, 5, 7}

S(10) = {2*s for s in S(5)} + {2*s+1 for s in S(4)}
      = {0, 2, 4, 6, 8, 10} + {1, 3, 5, 7, 9}

将a(n)定义为S(n)中所有数字中设置的总位数，并使用S的公式，我们得到a(2n+1) = 2a(n) + n+1和{ {1}}。这是因为在a(2n) = a(n) + a(n-1) + n中设置的位数与在{2*s for s in S(n)}中设置的位数相同，而在S(n)中设置的位数是在{{ {1}}为{2*s+1 for s in S(n)}的每个元素加一个（即：S(n)）。

这些相同的方程式出现在https://oeis.org/A000788上，归功于拉尔夫·斯蒂芬（Ralf Stephan）：

S(n)

使用此方法，可以使用n+1编写函数a(0) = 0 a(2n) = a(n)+a(n-1)+n a(2n+1) = 2a(n)+n+1：

双返回值是动态编程的一种形式，避免了多次重新计算相同的值。

第二个返回值是您感兴趣的值。例如：

B(N) = a(N), a(N-1)

这显然以O（log N）算术运算运行，并使用O（log N）堆栈。

达到恒定的空间复杂度

只要稍加注意就可以将空间复杂度降低到O（1）。

我们可以将Ralf Stephan方程写成矩阵乘以向量形式：

def B(N):
    if N == 0:
        return 0, 0
    r, s = B(N//2)
    if N % 2:
        return 2*r+N//2+1, r+s+N//2
    else:
        return r+s+N//2, 2*s+N//2

和

>> print(B(7)[1])
9

>> print(B(28)[1])
64

>> print(B(10**20)[1])
3301678091638143975424

反复应用这些规则中的一项或多项，得出：

[ a(2n+1) ] = [2 0 1 1]   [ a(n)  ]
[ a(2n)   ]   [1 1 1 0] * [ a(n-1)]
[ 2n+1    ]   [0 0 2 1]   [ n     ]
[ 1       ]   [0 0 0 1]   [ 1     ]

其中[ a(2n) ] = [1 1 1 0] [ a(n) ] [ a(2n-1) ] [0 2 1 0] * [ a(n-1)] [ 2n ] [0 0 2 0] [ n ] [ 1 ] [0 0 0 1] [ 1 ]，[ a(n) ] = M[0] * M[1] * ... * M[k] * [ a(0) ] [ a(n-1)] [ a(-1)] [ n ] [ 0 ] [ 1 ] [ 1 ]，...，M[0]是出现在Ralf Stephan的矩阵时间矢量版本中的两个4x4矩阵中的一个或另一个方程，具体取决于M[1]的第M[k]位。

因此：

函数n执行O（log n）算术运算，但使用恒定空间。

我们可以做得更好，注意def mat_mul(A, B): C = [[0] * 4 for _ in range(4)] for i in range(4): for j in range(4): for k in range(4): C[i][k] += A[i][j] * B[j][k] return C M1 = [[2, 0, 1, 1], [1, 1, 1, 0], [0, 0, 2, 1], [0, 0, 0, 1]] M0 = [[1, 1, 1, 0], [0, 2, 1, 0], [0, 0, 2, 0], [0, 0, 0, 1]] def B2(N): M = [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]] while N: M = mat_mul(M, M1 if N%2 else M0) N >>= 1 return M[1][3]矩阵始终为以下形式：

B2

然后，M根据观察到的[ a b c d ] [ a-1 b+1 c e ] [ 0 0 a+b a-1 ] [ 0 0 0 1 ]的结构，以优化的方式执行B3的矩阵乘法：

B2

这与这种方法可以带给我们的一样好：唯一的算术运算是加法，乘以2，除以2并测试最低位。空间复杂度是恒定的。即使对于巨大的M（例如10 ^ 200），所花费的时间也可以忽略不计。

C中的快速版本。

为了提高速度，C版本（使用gcc的__int128扩展名）在我的计算机上大约140纳秒内计算def B3(N): a, b, c, d, e = 1, 0, 0, 0, 0 while N: if N%2: a, c, d, e = 2*a+b, a+b+2*c, a+c+d, a+c+e-1 else: b, c = a+2*b, a+b+2*c N >>= 1 return e。该代码是N python函数的直接转换（请注意，不需要b3(10**20)），但由于C语言中缺少多个赋值，因此略有阻碍。

B3

Answer 2

是的。让我们首先分析 1 和两个 2 ^k 的幂之间的1个数（下限包括在内，上限*不包括）。我们稍后将基于此方法解决一般问题。

这意味着最终将为最后的 k 位选择所有位组合（000除外，但其中不包含任何设置位）。实际上，对于 k = 3 ，我们看到001，010，011，100，101，{{1} }和110。因此，平均而言，一半的位被设置。因此，我们知道设置的总位数为：

因此对于 1 （或 0 ）之间的范围，但这没有区别，因为 0 没有设置位）和 2 ^k ，我们有 2 ^k-1×k 设置位。例如，对于 k = 3 ，我们计算 2 ²×3 = 12 位，这确实是我们手动枚举时看到的。

这对一般情况有什么帮助？

假设我们要计算在 0 和 l 之间以及 2 ^k k + 1 ，那么我们可以首先计算设置为 2 ^k 的总位数，然后将其总和为在 2 ^k 和 l 之间设置的总位数。

现在，后者当然仍然存在问题：因为我们不知道如何计算。但是我们可以执行“移位”：我们可以计算 0 和 l-2 ^k 之间的位数（我们知道如何这样做），并在结果中额外添加 l-2 ^k 。我们以相同的方式计算 0 和 l-2 ^k 之间的位数，但是我们知道，两个 l-2 ^k 小于 2 ^k ，因为 2 ^k 是 l 中2的最高幂，因此可以保证“进度”。

如何将 l-2 ^k 添加到结果中？让我们举个例子：如果要计算k 2 --- \ k k-1 / --- = 2 * k --- 2 i=0和000之间的设置位数（不包括），则必须对110，{{1 }}，000，001，这是第一个“迭代”。然后，第二次迭代是在010和011之间设置的位，因此，我们通过执行移位并计算100和110之间的元素数来做到这一点，但是在“原始”数字中，每个数字都设置了一个额外的位：最高的设置位，因此我们计算要迭代的元素数，从而补偿位的丢失。

算法：我们现在可以使用以下方法导出算法：

或非递归方法：

例如：

def count_bit_range(n):
    if n <= 1:
        return 0
    k = n.bit_length()-1
    pk = 1 << k
    pk1 = 1 << (k-1)
    return k * pk1 + (n-pk) + count_bit_range(n-pk)

例如对于12，我们得到：

def count_bit_range(n):
    c = 0
    while n > 1:
        k = n.bit_length()-1
        pk = 1 << k
        pk1 = 1 << (k-1)
        c += k * pk1 + n - pk
        n -= pk
    return c

所以有20个设置位。

或28：

>>> count_bit_range(0)
0
>>> count_bit_range(1)
0
>>> count_bit_range(2)
1
>>> count_bit_range(3)
2
>>> count_bit_range(4)
4
>>> count_bit_range(5)
5
>>> count_bit_range(6)
7
>>> count_bit_range(12)
20
>>> count_bit_range(28)
64

确实是64。

基准：如果我们以上限（ 10 ²⁰ ）运行算法，则在本地计算机上可获得11.9微秒：

      0001  0010  0011  0100  0101  0110  0111
1000  1001  1010  1011

（可能）不是范围内最昂贵的电话号码，但是，回叫呼叫的数目随上限的设置位的数目而定，因此也是该范围内最昂贵的电话号码可能00001 00010 00011 00100 00101 00110 00111 01000 01001 01010 01011 01100 01101 01110 01111 10000 10001 10010 10011 10100 10101 10110 10111 11000 11001 11010 11011：

>>> timeit(partial(count_bit_range, 10**20), number=1000000)
11.911393816000782

但是，计算设置在1到73'786'976'294'838'206'463之间的位数仍然是32.4微秒。

在本地计算机上，它以非递归方法给出的即时结果可达 10 ^20'0000 。

时间复杂度：递归调用的数量与上限中的设置位数量成比例：实际上，每次迭代都将最高设置位移除，并且当上限达到一或零时算法停止。对于 w 位数字，此算法因此需要 O（w）递归调用（这本身是 not 的“基本操作数” “）。

确切的时间复杂度有点难计算，因为在通话过程中，我们对变量进行大量计算，这些变量严格来说可以任意变大，而加法，减法等会占用非恒定时间任意大数。

我们可以假定大多数操作将以该数目的位数线性运行（例如(1<<66)-1和二进制移位），但是乘法所花费的时间超过线性时间（在长度上）。尤其是因为 k 的长度与上界的长度成对数比例，所以它是“ tricky”。

如果我们假设递归步骤在上限的 length 中花费了二次时间（这可能是高估了），那么我们得到的时间复杂度为 O（w ³），或者直到 n 的范围，时间复杂度为 O（log ³ n）

Answer 3

为值0..2 ^ P-1制作表格，其中P = 8

 byte[] table = new byte[] {0,1,1,2,1,2,1,3, ... 7,8};

以及所有长度为P的掩码：

 long mask = (1 << P)-1;

然后，将输入数字分割为字节，并对每个字节求和：

int numUnits(long number) {
  int sum=0;
  for (int k=0; k<64/P, k++) {
      sum += table[number & mask];
      num = num >> P;
  }
  return sum;
}

根据表的可用内存量，您可以取P = 4或16，而不是8。

在正数范围内找出二进制表示形式中1的数目的算法

3 个答案:

达到恒定的空间复杂度

C中的快速版本。