4.2 矩阵乘法的Strassen算法

最新推荐文章于 2024-07-24 22:13:06 发布

树根朽木

最新推荐文章于 2024-07-24 22:13:06 发布

阅读量784

点赞数 1

文章标签：算法矩阵数据结构

本文链接：https://blog.csdn.net/jiaoqi6132/article/details/130171496

版权

1.伪代码以及用到的公式

2.代码

package collection;

public class StrassenMatrixMultiplication {
    public static int[][] multiply(int[][] a, int[][] b) {
        int n = a.length;
        int[][] result = new int[n][n];

        if (n == 1) {
            result[0][0] = a[0][0] * b[0][0];
        } else {
            int[][] a11 = new int[n / 2][n / 2];
            int[][] a12 = new int[n / 2][n / 2];
            int[][] a21 = new int[n / 2][n / 2];
            int[][] a22 = new int[n / 2][n / 2];
            int[][] b11 = new int[n / 2][n / 2];
            int[][] b12 = new int[n / 2][n / 2];
            int[][] b21 = new int[n / 2][n / 2];
            int[][] b22 = new int[n / 2][n / 2];

            // Divide matrices into sub-matrices of size n/2 x n/2
            divide(a, a11, 0, 0);
            divide(a, a12, 0, n / 2);
            divide(a, a21, n / 2, 0);
            divide(a, a22, n / 2, n / 2);
            divide(b, b11, 0, 0);
            divide(b, b12, 0, n / 2);
            divide(b, b21, n / 2, 0);
            divide(b, b22, n / 2, n / 2);

            // Calculate p1 to p7
            int[][] p1 = multiply(add(a11, a22), add(b11, b22));
            int[][] p2 = multiply(add(a21, a22), b11);
            int[][] p3 = multiply(a11, sub(b12, b22));
            int[][] p4 = multiply(a22, sub(b21, b11));
            int[][] p5 = multiply(add(a11, a12), b22);
            int[][] p6 = multiply(sub(a21, a11), add(b11, b12));
            int[][] p7 = multiply(sub(a12, a22), add(b21, b22));

            // Calculate sub-matrices of result matrix
            int[][] c11 = add(sub(add(p1, p4), p5), p7);
            int[][] c12 = add(p3, p5);
            int[][] c21 = add(p2, p4);
            int[][] c22 = add(sub(add(p1, p3), p2), p6);

            // Combine sub-matrices into result matrix
            combine(c11, result, 0, 0);
            combine(c12, result, 0, n / 2);
            combine(c21, result, n / 2, 0);
            combine(c22, result, n / 2, n / 2);
        }
        return result;
    }

    // Divide matrix into sub-matrices
    public static void divide(int[][] parent, int[][] child, int i, int j) {
        for (int m = 0, n = i; m < child.length; m++, n++) {
            for (int p = 0, q = j; p < child.length; p++, q++) {
                child[m][p] = parent[n][q];
            }
        }
    }

    // Combine sub-matrices into matrix
    public static void combine(int[][] child, int[][] parent, int i, int j) {
        for (int m = 0, n = i; m < child.length; m++, n++) {
            for (int p = 0, q = j; p < child.length; p++, q++) {
                parent[n][q] = child[m][p];
            }
        }
    }

    // Add two matrices
    public static int[][] add(int[][] a, int[][] b) {
        int n = a.length;
        int[][] result = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                result[i][j] = a[i][j] + b[i][j];
            }
        }
        return result;
    }

    // Subtract two matrices
    public static int[][] sub(int[][] a, int[][] b) {
        int n = a.length;
        int[][] result = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                result[i][j] = a[i][j] - b[i][j];
            }
        }
        return result;
    }
}

3.原理

如果 n = 1，则每个矩阵包含一个元素。执行单个标量乘法和单个标量加法，就像 MATRIX-Multiply-RECURSIVE 的第3行那样，计算 Θ (1)的时间，然后返回。否则，将输入矩阵 A、 B 和输出矩阵 C 划分为 n/2 × n/2子矩阵，如方程(4.2)所示。这一步通过索引计算 Θ (1)的时间，就像在 MATRIX-Multiply-RECURSIVE 中一样。
创建 n/2 × n/2矩阵 S~1~，S~2~，... ，S~10~，每个矩阵都是步骤1中两个子矩阵的和或差。建立并归零七个 n/2 × n/2矩阵 P~1~，P~2~，... ，P~7~的条目以保持七个 n/2 × n/2矩阵乘积。所有17个矩阵都可以在 Θ (n2)时间内创建并初始化 P~i~
使用步骤1中的子矩阵和步骤2中创建的矩阵 S1，S2，... ，S10，递归地计算7个矩阵乘积 P~1~，P~2~，... ，P~7~中的每一个，花费7T (n/2)的时间。
对结果矩阵 C 的四个子矩阵 C11，C12，C21，C22进行修正，通过加减各种 P~i~ 矩阵来实现，这需要 Θ (n2)的时间。

假定一旦矩阵规模从n变为1,就进行简单的标量乘法计算，正如SQUARE-MATRIX-MULTIPLYRECURSIVE的第4行那样。当n>l时，步骤1、2和4共花费Θ(n2)时间，步骤3要求进行7次n/2Xn/2矩阵的乘法。因此，我们得到如下描述Strassen算法运行时间T(n)的递归式：

4.数学计算原理

步骤2，创建如下10个矩阵

10个矩阵:

由于必须进行10次n/2Xn/2矩阵的加减法，因此，该步骤花费8(n^2^)时间。

步骤3，递归地计算7次n/2*n/2矩阵的乘法

步骤4,对步骤3创建的P;矩阵进行加减法运算，计算出C的4个n/2* n/2的子矩阵.

C11 = C11 + P5 + P4-P2 + P6.

C~12~ = C~12~ + P~1~ + P~2~

C~21~ = C~21~ + P~3~ + P~4~

C22 = C22 + P5 + P1-P3-P7

5.疑问

1.为什么要使用P1 到p7

用加减法来降低乘法的次数

在 Strassen 算法中，使用了七个中间矩阵 P1 到 P7 来计算矩阵乘积，具体原因如下：为了避免重复计算，需要将输入的两个矩阵分别拆分成四个小矩阵，然后将这些小矩阵用来计算中间矩阵 P1 到 P7。中间矩阵 P1 到 P7 的计算方式是通过加减法来实现的，因此可以减少乘法的次数，从而减少计算量。通过使用中间矩阵 P1 到 P7，可以将原来需要进行 8 次矩阵乘法的计算量减少到 7 次。综上所述，使用中间矩阵 P1 到 P7 可以提高矩阵乘法的效率，减少计算量。

2.可以使用p1到p10吗

在 Strassen 算法中，使用中间矩阵 P1 到 P7 是该算法的核心思想之一，它们用于表示两个矩阵相乘的结果。通常情况下，使用七个中间矩阵是足够的，因为它们已经能够减少矩阵乘法的计算量，从而提高算法的效率。虽然可以添加更多的中间矩阵，例如 P8、P9、P10 等，但是这样并不一定能够进一步提高算法的效率，反而可能会增加计算量和程序的复杂度。因此，使用七个中间矩阵 P1 到 P7 是 Strassen 算法的常规做法，也是较为有效的优化策略。

3.至于为什么c11,c12 是这样的表达式

在 Strassen 算法中，矩阵乘积的计算采用了递归的方式，将输入矩阵分解成多个子矩阵进行计算，最终将这些子矩阵合并得到矩阵乘积。

具体地说，对于两个 n×n 的矩阵 A 和 B，Strassen 算法将 A 和 B 分解成四个 n/2×n/2 的子矩阵，然后通过以下公式计算矩阵乘积 C = A × B：

C11 = P5 + P4 - P2 + P6
C12 = P1 + P2
C21 = P3 + P4
C22 = P5 + P1 - P3 - P7

其中，P1 到 P7 是中间矩阵，表示为：

P1 = A11 × (B12 - B22)
P2 = (A11 + A12) × B22
P3 = (A21 + A22) × B11
P4 = A22 × (B21 - B11)
P5 = (A11 + A22) × (B11 + B22)
P6 = (A12 - A22) × (B21 + B22)
P7 = (A11 - A21) × (B11 + B12)

在这个公式中，C11 表示乘积的左上角 n/2×n/2 的子矩阵，P5、P4、P2 和 P6 都是中间矩阵，它们通过加减法来计算 C11 的值。具体来说：

P5 表示 (A11 + A22) × (B11 + B22) 的结果，它包含 C11、C12、C21 和 C22 中的所有元素。 P4 表示 A22 × (B21 - B11) 的结果，它包含 C11 和 C21 中的所有元素。 P2 表示 (A11 + A12) × B22 的结果，它包含 C11 和 C12 中的所有元素。 P6 表示 (A12 - A22) × (B21 + B22) 的结果，它包含 C11 和 C21 中的所有元素。因此，将这些中间矩阵相加减，可以得到 C11 的值。具体来说，C11 = P5 + P4 - P2 + P6。这个公式的含义是，将 P5、P4、P2 和 P6 中包含 C11 的部分相加减，可以得到 C11 的值。

‍