俄罗斯农民乘法

原创已于 2023-06-27 15:31:24 修改 · 231 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #javascript #备忘录模式

于 2023-02-27 11:05:35 首次发布

小白算法库专栏收录该内容

8 篇文章

订阅专栏

文章介绍了如何在不允许使用乘除法、循环和条件判断语句的情况下，利用俄罗斯农民乘法计算1到n的和。这种方法基于位运算，将乘法转化为加法的连续操作。文章提供了两种解决方案，一种是递归实现，另一种是手动模拟不超过14次的循环操作。

剑指 Offer 64 求1+2+…+n

题目

求 1+2+…+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。
限制：1 <= n <= 10000

俄罗斯农民乘法

又称快速乘法，对被乘数进行二进制展开后，基于加法实现乘法。由于计算机中位运算速度很快，所以效率很高。
算法描述：对于A * B，如果 A / 2有余数，则把B累加到最后结果中，更新A = A / 2，B = B * 2。
$\begin{aligned} 57 \times 48 & =28 \times 96+48 \\ & = 14 \times 192 + 48 \\ & = 7 \times 384 + 48 \\ & = 3 \times 768 + 48 + 384 \\ & = 1 \times 1536 + 48 + 384 + 768 \\ \end{aligned}$
这里实际上是对57进行了二进制展开
$\begin{aligned} 57 & = 2^0 + 2^3 + 2^4 + 2^5 \\ 57 \times 48 & = ( 2^0 + 2^3 + 2^4 + 2^5 ) \times 48 \\ & = 48 \times 2^0 + 48 \times 2^3 + 48 \times 2^4 + 48 \times 2^5\\ & = 48 + 48>>1 + 48>>3 + 48>>4 + 48>>5 \end{aligned}$

function quickMultiple (A, B) {
    let res = 0
    while(A >= 1) {
        if (A & 1) {
            res += B
        }
        A>>1
        B<<1
    }
    return res
}

题解

$\frac{(1 + n) \times n}{2} = (1 + n) \times n >>1$

根据上述俄罗斯农民乘法，(1+n)*n = quickMultiple(1+n, n)

但是，由于题目中要求不能使用while，所以接下来对quickMultiple进行改造：

方法一：递归

function quickMultipleRecrution (A, B) {
    if (A <= 1) {
        return 0
    }

	// 这里其实相当于 const res = A & 1 ? B : 0
    const res = (A & 1) && B || 0

    return res + quickMultipleRecrution(A>>1, B<<1)
}

方法二：由于题目限制了n <= 1000 < 16384，二进制展开最多只有14位，所以手动模拟循环，进行14次的处理。
- 记录官方题解

function quickMultiple (A, B) {
    let res = 0;
    // 1
    (A & 1) && (res += B);
   	A >>= 1;
    B <<= 1;
    // 2
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 3
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 4
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 5
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 6
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 7
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 8
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 9
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 10
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 11
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 12
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 13
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    // 14
    (A & 1) && (res += B);
    A >>= 1;
    B <<= 1;
    return res
}