MIT-大整数相乘和大矩阵相乘

大整数相乘（与多项式乘法类似）

问题描述

给定两个非负整数 $A$ 和 $B$ ，它们的位数可以非常大（可能有数千甚至数百万位）。要求计算它们的积：

$$C=A\cdot B$$

由于整数过大，无法直接使用内置整型存储，因此我们通常将每个大整数表示为：
$$A=(a_{n-1}{a}_{n-2}\dots a_1{a}_0),B=(b_{m-1}{b}_{m-2}\dots b_1{b}_0)$$

例子

		       1 2 3 4×      5 6 7 8
---------------------------------------------9 8 7 2   (1234 × 8)8 6 3 8     (1234 × 7, 左移一位)7 4 0 4       (1234 × 6, 左移两位)+  6 1 7 0         (1234 × 5, 左移三位)
---------------------------------------------7 0 0 6 6 5 2

算法实现

暴力算法

首先想到的就是小学学过的竖式计算法则，模拟我们手工笔算乘法的过程。即按每一位与另一数的每一位相乘，再把结果按位数对齐相加（考虑进位）。

vector<int> brute_Multiply(vector<int>& A, vector<int>& B)
{int n = A.size();int m = B.size();vector<int> res(n + m, 0);// 按位乘for (int i = 0; i < n; i ++ )for (int j = 0; j < m; j ++ )res[i + j] += A[i] * B[j];// 处理进位for (int i = 0; i < n + m; i ++ )if (res[i] > 9)res[i + 1] += res[i] / 10, res[i] = res[i] % 10;// 去除前导 0while (res.size() > 1 && res.back() == 0) res.pop_back();return res;
}

时间复杂度：$O(nm)$

---

分治算法

在大整数乘法中，我们可以把两个 $n$ 位的数分为前半部分和后半部分，然后用子问题的结果拼接出整体乘积。这种思想实际上是对“竖式法”的系统化抽象：我们把数字分块计算，再根据块的位置（权值）把结果加回来。

我们假设 $n$ 是 2 的幂，则有：

$$\begin{array}{c}u=w{2}^{n/2}+x\\ v=y{2}^{n/2}+z\end{array}$$

则 $uv$ 的乘积为：

$$uv=(w{2}^{n/2}+x)(y{2}^{n/2}+z)=wy{2}^n+(xy+wz)2^{n/2}+xz$$

进一步 $xy+wz=(w+x)(y+z)-wy-xz$

故可以写成：

$$uv=wy{2}^n+((w+x)(y+z)-wy-xz)2^{n/2}+xz$$

MIT-两个多项式相乘：其实都是一类的问题，大整数相乘不就是多项式乘法代入具体数值吗？代码和时间复杂度分析直接参考这篇文章。

时间复杂度：$O(n^{{\log }_{2}3})$

大矩阵相乘

问题描述

设矩阵 $A$ 的大小为 $m\times n$，矩阵 $B$ 的大小为 $n\times p$。则它们的乘积矩阵 $C$ 的大小为 $m\times p$，定义为：

$$C=A\times B$$

其中

$$C_{ij}=\sum _{k=1}^m{A}_{ik}\times B_{kj}(1\le i\le n,1\le j\le p)$$

例子

算法实现

暴力算法

首先想到的是直接按照矩阵乘法的运算规则，进行按位相乘再相加，即：

$$C_{ij}=\sum _{k=1}^m{A}_{ik}\times B_{kj}(1\le i\le n,1\le j\le p)$$

for (int k = 1; k <= m; k ++ )for (int i = 1; i <= n; i ++ )for (int j = 1; j <= p; j ++ )C[i][j] = A[i][k] * B[k][j];

时间复杂度：$O(nmp)$，若$n=m=p$ ，则时间复杂度为 $O(n^3)$。

---

分治算法

将大矩阵划分成若干个小矩阵块，将矩阵乘法问题分解为几个小规模的矩阵乘法，再递归地求解并合并结果。

假设有两个 $n\times n$ 的矩阵 $A$ 和 $B$，把它们分别划分为 4 个 $\frac{n}{2}\times \frac{n}{2}$ 的子矩阵：

$$A=\left[\begin{array}{cc}{A}_{11}& A_{12}\\ A_{21}& A_{22}\end{array}\right],B=\left[\begin{array}{cc}{B}_{11}& B_{12}\\ B_{21}& B_{22}\end{array}\right]$$

则它们的乘积 $C=A\times B$ 为：

$$C=\left[\begin{array}{cc}{C}_{11}& C_{12}\\ C_{21}& C_{22}\end{array}\right]$$

其中每个子块的计算方式为：

$$\begin{array}{rl}{C}_{11}& =A_{11}{B}_{11}+A_{12}{B}_{21}\\ C_{12}& =A_{11}{B}_{12}+A_{12}{B}_{22}\\ C_{21}& =A_{21}{B}_{11}+A_{22}{B}_{21}\\ C_{22}& =A_{21}{B}_{12}+A_{22}{B}_{22}\end{array}$$

定义：typedef vector<vector<int>> Matrix

矩阵加法

Matrix addMatrix(Matrix& A, Matrix& B) {int n = A.size();int m = A[0].size();Matrix C(n, vector<int>(m, 0));for (int i = 0; i < n; i ++ )for (int j = 0; j < m; j ++ )C[i][j] = A[i][j] + B[i][j];return C;
}

矩阵减法

Matrix subMatrix(Matrix& A, Matrix& B) {int n = A.size();int m = A[0].size();Matrix C(n, vector<int>(m, 0));for (int i = 0; i < n; i ++ )for (int j = 0; j < m; j ++ )C[i][j] = A[i][j] - B[i][j];return C;
}

分治矩阵

Matrix DC_divideConquerMultiply(Matrix& A, Matrix& B) {int n = A.size();// 基本情况：1x1矩阵if (n == 1) {return {{A[0][0] * B[0][0]}};}int mid = n / 2;// 划分子矩阵Matrix A11(mid, vector<int>(mid)), A12(mid, vector<int>(mid));Matrix A21(mid, vector<int>(mid)), A22(mid, vector<int>(mid));Matrix B11(mid, vector<int>(mid)), B12(mid, vector<int>(mid));Matrix B21(mid, vector<int>(mid)), B22(mid, vector<int>(mid));for (int i = 0; i < mid; i++) {for (int j = 0; j < mid; j++) {A11[i][j] = A[i][j];A12[i][j] = A[i][j + mid];A21[i][j] = A[i + mid][j];A22[i][j] = A[i + mid][j + mid];B11[i][j] = B[i][j];B12[i][j] = B[i][j + mid];B21[i][j] = B[i + mid][j];B22[i][j] = B[i + mid][j + mid];}}// 递归计算子矩阵Matrix C11 = addMatrix(DC_divideConquerMultiply(A11, B11),DC_divideConquerMultiply(A12, B21));Matrix C12 = addMatrix(DC_divideConquerMultiply(A11, B12),DC_divideConquerMultiply(A12, B22));Matrix C21 = addMatrix(DC_divideConquerMultiply(A21, B11),DC_divideConquerMultiply(A22, B21));Matrix C22 = addMatrix(DC_divideConquerMultiply(A21, B12),DC_divideConquerMultiply(A22, B22));// 合并四个子矩阵Matrix C(n, vector<int>(n, 0));for (int i = 0; i < mid; i++) {for (int j = 0; j < mid; j++) {C[i][j] = C11[i][j];C[i][j + mid] = C12[i][j];C[i + mid][j] = C21[i][j];C[i + mid][j + mid] = C22[i][j];}}return C;
}

假设 $n=2^h$ 且 $T(1)=O(1)$，$T(n)$ 是执行两个 $n\times n$ 矩阵乘法所需的时间。

• $A_{11}{B}_{11}$：$T(\frac{n}{2})$
• …
• $A_{22}{B}_{22}$：$T(\frac{n}{2})$
• $A_{11}{B}_{11}+A_{12}{B}_{21}$：$O((\frac{n}{2}{)}^2)$
• …
• $A_{21}{B}_{12}+A_{22}{B}_{22}$：$O((\frac{n}{2}{)}^2)$

可知矩阵乘法有 8 次，而矩阵加法有 4 次。

$$\begin{array}{rl}T(n)& =8T(\frac{n}{2})+O(n^2)\\ & =8\left[8T(\frac{n}{2^2})\right]+O(n^2)\\ & =8^{2}T(\frac{n}{2^2})+O(n^2)\\ & =...\\ & =8^{h}T(\frac{n}{2^h})+O(n^2)\\ & =(2^h{)}^{3}T(\frac{n}{2^h})+O(n^2)\\ & =n^{3}T(1)+O(n^2)\\ & =O(n^3)\end{array}$$

---

Strassen算法（分治算法的优化）

依旧采用 MIT-两个多项式相乘 的优化分治算法的思想，通过数学的等式变换，从而通过增加加减法的次数而减少算法中乘法的计算次数。

与分治算法定义的一样，先将矩阵 $A$ 和 $B$ 分成 4 个子块：

$$A=\left[\begin{array}{cc}{A}_{11}& A_{12}\\ A_{21}& A_{22}\end{array}\right],B=\left[\begin{array}{cc}{B}_{11}& B_{12}\\ B_{21}& B_{22}\end{array}\right]$$

Strassen 定义 7 个中间矩阵：

$$\begin{array}{rl}& M_1=(A_{11}+A_{22})(B_{11}+B_{22})\\ & M_2=(A_{21}+A_{22})B_{11}\\ & M_3=A_{11}(B_{12}-B_{22})\\ & M_4=A_{22}(B_{21}-B_{11})\\ & M_5=(A_{11}+A_{12})B_{22}\\ & M_6=(A_{21}-A_{11})(B_{11}+B_{12})\\ & M_7=(A_{12}-A_{22})(B_{21}+B_{22})\end{array}$$

再通过加减组合出最终结果：

$$\begin{array}{rl}& C_{11}=M_1+M_4-M_5+M_7\\ & C_{12}=M_3+M_5\\ & C_{21}=M_2+M_4\\ & {\mathrm{C}}_{22}=M_1-M_2+M_3+M_6\end{array}$$

Matrix StrassenMultiply(Matrix& A, Matrix& B) {int n = A.size();if (n == 1) return {{A[0][0] * B[0][0]}};int mid = n / 2;// 划分子矩阵Matrix A11(mid, vector<int>(mid)), A12(mid, vector<int>(mid));Matrix A21(mid, vector<int>(mid)), A22(mid, vector<int>(mid));Matrix B11(mid, vector<int>(mid)), B12(mid, vector<int>(mid));Matrix B21(mid, vector<int>(mid)), B22(mid, vector<int>(mid));for (int i = 0; i < mid; i++)for (int j = 0; j < mid; j++) {A11[i][j] = A[i][j];A12[i][j] = A[i][j + mid];A21[i][j] = A[i + mid][j];A22[i][j] = A[i + mid][j + mid];B11[i][j] = B[i][j];B12[i][j] = B[i][j + mid];B21[i][j] = B[i + mid][j];B22[i][j] = B[i + mid][j + mid];}// Strassen 7 个中间矩阵Matrix M1 = StrassenMultiply(addMatrix(A11, A22), addMatrix(B11, B22));Matrix M2 = StrassenMultiply(addMatrix(A21, A22), B11);Matrix M3 = StrassenMultiply(A11, subMatrix(B12, B22));Matrix M4 = StrassenMultiply(A22, subMatrix(B21, B11));Matrix M5 = StrassenMultiply(addMatrix(A11, A12), B22);Matrix M6 = StrassenMultiply(subMatrix(A21, A11), addMatrix(B11, B12));Matrix M7 = StrassenMultiply(subMatrix(A12, A22), addMatrix(B21, B22));// 组合出结果矩阵Matrix C11 = addMatrix(subMatrix(addMatrix(M1, M4), M5), M7);Matrix C12 = addMatrix(M3, M5);Matrix C21 = addMatrix(M2, M4);Matrix C22 = addMatrix(subMatrix(addMatrix(M1, M3), M2), M6);// 合并四个子矩阵Matrix C(n, vector<int>(n, 0));for (int i = 0; i < mid; i++)for (int j = 0; j < mid; j++) {C[i][j] = C11[i][j];C[i][j + mid] = C12[i][j];C[i + mid][j] = C21[i][j];C[i + mid][j + mid] = C22[i][j];}return C;
}

时间复杂度：$O(n^{{\log }_{2}7})\approx O(n^{2.81})$

假设 $n=2^h$ 且 $T(1)=O(1)$，$T(n)$ 是执行两个 $n\times n$ 矩阵乘法所需的时间。

可知矩阵乘法有 7 次，而矩阵加法有 18 次。

$$\begin{array}{rl}T(n)& =7T(\frac{n}{2})+O(n^2)\\ & =7\left[7T(\frac{n}{2^2})\right]+O(n^2)\\ & =7^{2}T(\frac{n}{2^2})+O(n^2)\\ & =...\\ & =7^{h}T(\frac{n}{2^h})+O(n^2)\\ & =(2^{{\log }_{2}7}{)}^{h}T(\frac{n}{2^h})+O(n^2)\\ & =(2^h{)}^{{\log }_{2}7}T(\frac{n}{2^h})+O(n^2)\\ & =n^{{\log }_{2}7}T(1)+o(n^2)\\ & =O(n^{{\log }_{2}7})\end{array}$$