逐比特校验法-大整数开平方根 Bit-by-Bit Large Number Square Root

问题描述&背景

描述

给定一个大整数（十进制下可能长达数百位）$N$，并保证其是某个整数的平方，如何精确又快速的求出其平方根？

背景

最近正在学习密码学相关的一些问题，遇到了一个题目，其中需要对几个巨大的整数（密码学日常 -_-）开平方根。遇到巨大的整数，自然想Python大法，毕竟对大整数的支持确实很棒，几乎无限位数的加法与乘法，运算速度也是巨快。没想到在给大整数开平方根这个看似轻巧的问题上卡住了，于是经过一番搜索，找到了一个基于二分思想、非常快速的逐比特验证方法，在这里和大家总结分享一下。

逐比特校验开平方根算法

参考来源

这篇文章比较全面总结了整型开根的各算法，包括精确解与近似的迭代法等：点我查看

二分思想

对大数做平方根时，如果直接做开根，大部分语言都会将其视作浮点型，从而带来误差，无法得到精确解；要想直接对大整型开根也是相当费时的操作。为了精确解，便想到通过循环迭代不断试错，找到精确的那个解，其平方等于$N$，因为平方操作本质即乘法，是比较快速且准确的。
暴力迭代循环的次数过多，时间上一般不可忍受，于是可采用二分查找，显著减少搜索时间。

更进一步-比特法校验

二分查找仍然需要包含许多平方后比较的操作，运行速度仍然不尽人意。我们可以换一个思路：对于一个整数进行开平方根的操作，本质就是根据一个写为二进制后长$l$位的整数$N$，构造一个二进制长为$\lceil \frac{l}{2}\rceil$位的整数$sqrtN$，从高位到低位逐个比特验证每一位是0还是1。

bit-$k$	$k_{15}$	$k_{14}$	$k_{13}$	$k_{12}$	$k_{11}$	$k_{10}$	$k_9$	$k_8$	$k_7$	$k_6$	$k_5$	$k_4$	$k_3$	$k_2$	$k_1$	$k_0$	Dec
$N$	1	0	1	0	1	0	1	0	1	0	1	0	0	0	0	1	43681
$sqrtN$									1	1	0	1	0	0	0	1	209

引言1：注意到假设$sqrtN$的二进制长为$k$位，则其最小可能的数的平方为$N=(2^{k-1}{)}^2=2^{2k-2}$，长为$2k-1$位；最大可表示的数的平方为$N=(2^k-1{)}^2=2^{2k}-2^{k+1}+1$，长为$2k+1$位。故若输入$N$的二进制长为$l$，那么其平方根的二进制长最多为$\lceil \frac{l}{2}\rceil$位。所以我们只需判断末尾$\lceil \frac{l}{2}\rceil$位即可。

引言2：假设$sqrtN$最终能表示成某一二进制数，其在$k_i,k_j,k_m,k_n,i>j>m>n$位有值，则其平方将表示成$$N=(2^{k_i}+2^{k_j}+2^{k_m}+2^{k_n}{)}^2$$，展开得$$(2^{2k_i})+(2^{2k_j}+2\cdot 2^{k_i}\cdot 2^{k_j})+(2^{2k_m}+2\cdot 2^{k_i}\cdot 2^{k_m}+2\cdot 2^{k_j}\cdot 2^{k_m})+(2^{2k_n}+2\cdot 2^{k_i}\cdot 2^{k_n}+2\cdot 2^{k_j}\cdot 2^{k_n}+2\cdot 2^{k_m}\cdot 2^{k_n})$$ 即 $$2^{k_i}\cdot (2^{k_i})+2^{k_j}\cdot (2^{k_j}+2^{k_i+1})+2^{k_m}\cdot (2^{k_m}+2^{k_i+1}+2^{k_j+1})+2^{k_n}\cdot (2^{k_n}+2^{k_i+1}+2^{k_j+1}+2^{k_m+1})$$，注意这里特地按特定规律分了组，并且假定最后结果有4位为1以契合下面的例子，能讲述得更加清楚一些。

算法过程

由于均是比特操作，有关2的次方和乘除的操作都可以通过左移操作实现，效率上会快很多。以上面的$209^2=43681$为例，我们来逐步看一下算法流程：

1. 初始时，输入N = 43681。sqrtN为0，shift为$\frac{16}{2}$ = 8位。
2. 查看所需看的最高位$k_8$，设定一个mask = 100000000，即仅$k_8$位被置1的一个掩码。假如sqrtN的$k_8$位应该为0的话，那么N必定不应包含$2^{k_8}\cdot (2^{k_8})$一项。换言之，mask << shift一定超过了N。假如sqrtN的$k_8$位应该为1的话，那么mask << shift一定$\le$ N。根据此来判断得，$k_8$位应为0。
3. shift置为7，对应mask = 10000000。此时sqrtN仍为0，同上判断知，$k_7$应为1。更新sqrtN += mask，并且N要减去该项，此时N仅留下了$$2^{k_j}\cdot (2^{k_j}+2^{k_i+1})+2^{k_m}\cdot (2^{k_m}+2^{k_i+1}+2^{k_j+1})+2^{k_n}\cdot (2^{k_n}+2^{k_i+1}+2^{k_j+1}+2^{k_m+1})$$部分。
4. shift置为6，对应mask = 1000000。此时查看$k_6$位，因为已知$k_7$应为1，于是假如sqrtN的$k_6$位应该为0的话，那么N必定不应包含$2^{k_6}\cdot (2^{k_6}+2^{k_7+1})$一项。换言之，此时的(sqrtN（即之前得到的$2^{k_7}$）* 2 + mask) << shift一定超过了N。假如sqrtN的$k_6$位应该为1的话，那么该式一定$\le$ N。根据此来判断得，$k_6$位应为1。更新sqrtN += mask，并且N要减去该项，此时N仅留下了$$2^{k_m}\cdot (2^{k_m}+2^{k_i+1}+2^{k_j+1})+2^{k_n}\cdot (2^{k_n}+2^{k_i+1}+2^{k_j+1}+2^{k_m+1})$$部分。
5. shift置为5，对应mask = 100000。同样得到$k_5$位应为0。
6. shift置为4，对应mask = 10000。此时查看$k_4$位，因为已知$k_7,k_6$应为1，于是假如sqrtN的$k_4$位应该为0的话，那么N必定不应包含$2^{k_4}\cdot (2^{k_4}+2^{k_7+1}+2^{k_6+1})$一项。换言之，此时的(sqrtN（即之前得到的$2^{k_7}+2^{k_6}$）* 2 + mask) << shift一定超过了$N$。假如$sqrtN$的$k_4$位应该为1的话，那么该式一定$\le$ N。根据此来判断得，$k_4$位应为1。更新sqrtN += mask，并且N要减去该项，此时N仅留下了$$2^{k_n}\cdot (2^{k_n}+2^{k_i+1}+2^{k_j+1}+2^{k_m+1})$$部分。
7. 以此类推，直到$N=0$停止。

相信经过上面的叙述，大家已经了解了这一算法的精髓：以二进制比特的视角，充分运用移位操作的快速性。

算法实现和验证

Python实现

Python代码实现该算法如下，还是非常简洁的。

## Bit-by-Bit Large Number Fast sqrt
from math import ceil, sqrt

# Fast bit-by-bit sqrt func
def bit_by_bit_sqrt(N):
    # Initialize
    shift = ceil(len(bin(N)) - 2)
    mask = 1 << shift
    sqrtN = 0
    # Loop starting from MSB
    while N > 0:
        # Generate intermediate term
        tmp = ((sqrtN << 1) + mask) << shift
        # Just if sqrtN includes that bit
        if tmp <= N:
            sqrtN += mask   # If so, update
            N -= tmp        # sqrtN and N
        # Advance
        shift -= 1
        mask >>= 1
    # Return result
    return sqrtN

# Testing
if __name__ == '__main__':
    N = 43681
    sqrtN = bit_by_bit_sqrt(N)
    print('original N: %d' % N)
    print('calc sqrtN: %d' % sqrtN)
    print('true sqrtN: %d' % sqrt(N))

验证结果

original N: 43681
calc sqrtN: 209
true sqrtN: 209

如果大家有任何疑问或评论，欢迎在评论区留言～ 有关非平方数精确开方和非整型开方相关的算法，也欢迎补充～