我們平時接觸的長乘法，按位相乘，是一種時間複雜度為 o(n ^ 2) 的演算法。今天，我們來介紹一種時間複雜度為 o (n ^ log 3) 的大整數乘法(log 表示以 2 為底的對數)。
介紹原理
karatsuba 演算法要求乘數與被乘數要滿足以下幾個條件，第一，乘數與被乘數的位數相同；第二，乘數與被乘數的位數應為 2 次冪，即為 2 ^ 2, 2 ^ 3, 2 ^ 4， 2 ^ n 等數值。
下面我們先來看幾個簡單的例子，並以此來了解 karatsuba 演算法的使用方法。
兩位數相乘
我們設被乘數 a = 85，乘數 b = 41。下面來看我們的操作步驟：
將 a, b 一分為二，令 p = a 的前半部分 = 8，q = a 的後半部分 = 5 ， r = b 的前半部分 = 4 ，s = b 的後半部分 = 1，n = 2。通過簡單的數**算：
a * b = pq * rs = (p * 10 + q) * (r * 10 + s) = p * r * 10 ^ 2 + (p * s + q * r ) * 10 + q * s。
令 u = p * r，v =（p - q) * (s - r)，w = q * s。所以 a * b = u * 10 ^ 2 + (u + v + w) * 10 + w。
換成數值求解的過程如下：
a * b = 85 * 41 = (8 * 10 + 5) * ( 4 * 10 + 1) = 8 * 4 * 10 * 10 + (8 * 1 + 5 * 4) * 10 + 5 * 1。
其中 u = 8 * 4 = 32，v = (8 - 5) (1 - 4) = -9，w = 5 * 1 = 5。
所以，a * b = 32 * 100 + (32 - 9 + 5) * 10 + 5 = 3485。與長乘法所得結果一致。
四位數相乘
我們設被乘數 a = 8537，乘數 b = 4123。下面來看我們的操作步驟：
將 a, b 一分為二，令 p = a 的前半部分 = 85，q = a 的後半部分 = 37 ， r = b 的前半部分 = 41 ，s = b 的後半部分 = 23，n = 4。
==> 其中，u = 85 * 41, v = (85 - 37) * (23 - 41), w = 37 * 23。
==> a * b = 8537 * 4123 = u * 10 ^ 4 + (u + v + w) * 10 ^ 2 + w = 3485_0000 +34_7200 + 851 = 35198051。
在我們計算 u， v, w 的過程中又會涉及兩位數的乘法，我們繼續使用 karatsuba 演算法得出兩位數相乘的結果。
n 位數相乘
我們令 n 為 乘數與被乘數的位數，令 p = a 的前半部分，q = a 的後半部分， r = b 的前半部分 ，s = b 的後半部分。
==> 其中， u = p * r，v = (p - q) * (s - r)，w = q * s。
所以 a * b = u * 10 ^ n + (u + v + w) * 10 ^ (n / 2) + w。
而 u, v, w 則是兩個 n / 2 位的乘法運算。我們繼續呼叫 karatsuba 演算法計算 u, v, w 的數值。接著，我們在計算 n / 2 乘法的過程中又會遇到 n / 4 位的乘法運算……以此類推，直到我們遇到兩個個位數的乘法，我們就直接返回這兩個個位數乘法的結果。層層返回，最終得到 n 位數的乘法結果。
時間複雜度
我們平常使用的長乘法，是 o (n ^ 2) 的時間複雜度。比如兩個 n 位數相乘，我們需要將每一位按規則相乘，所以需要計算 n * n 次乘法。而使用 karatsuba 演算法每層需要計算三次乘法，兩次加法，以及若干次加法，每使用一次 karatsuba 演算法，乘法規模就下降一半。
所以，對於兩個 n = 2 ^ k 位數乘法運算，我們需要計算 3 ^ k 次乘法運算。而 k = log n(底數為 2)， 3 ^ k = 3 ^ log n = 2 ^ (log 3 * log n) = 2 ^ (log n * log 3) = n ^ log 3 （底數為 2）。
**實現
from math import log2, ceil
def pad(string: str, real_len: int, max_len: int) -> str:
pad_len: int = max_len - real_len
return f""
def kara(n1: int, n2: int) -> int:
if n1 < 10 or n2 < 10:
return n1 * n2
n1_str: str = str(n1)
n2_str: str = str(n2)
n1_len: int = len(n1_str)
n2_len: int = len(n2_str)
real_len: int = max(n1_len, n2_len)
max_len: int = 2 ** ceil(log2(real_len))
mid_len: int = max_len >> 1
n1_pad: str = pad(n1_str, n1_len, max_len)
n2_pad: str = pad(n2_str, n2_len, max_len)
p: int = int(n1_pad[:mid_len])
q: int = int(n1_pad[mid_len:])
r: int = int(n2_pad[:mid_len])
s: int = int(n2_pad[mid_len:])
u: int = kara(p, r)
v: int = kara(q-p, r-s)
w: int = kara(q, s)
return u * 10 ** max_len + (u+v+w) * 10 ** mid_len + w
==> kara(123456, 9734) == 123456 * 9734
==> kara(1234233456756, 32459734) == 1234233456756 * 32459734
演算法實現（5）大整數乘法
通常，在分析演算法的計算複雜性時，都將加法和乘法運算當作基本運算來處理，即將執行一次加法或乘法運算所需的計算時間當作乙個僅取決於計算機硬體處理速度的常數。這個假定僅在參加運算的整數能在計算機硬體對整數的表示範圍內直接處理時才是合理的。然而，在某些情況下，需要處理很大的整數，它無法再計算機硬體能直接表...
演算法 大整數乘法
問題描述 求兩個不超過200位的非負整數的積。輸入形式 有兩行，每行是乙個不超過200位的非負整數，沒有多餘的前導0。輸出形式 一行，即相乘後的結果。結果裡不能有多餘的前導0，即如果結果是342，那麼就不能輸出為0342。樣例輸入 1234567890 9876543210 樣例輸出 1219326...
大整數乘法python3實現
由於python具有無限精度的int型別，所以用python實現大整數乘法是沒意義的，但是思想是一樣的。利用的規律是 第乙個數的第i位和第二個數大第j位相乘，一定累加到結果的第i j位上，這裡是從0位置開始算的。如下 import sys def list2str li while li 0 0 d...