两个矩阵相乘—Strassen算法与传统算法(要求矩阵阶n为2的幂)

package com.work.home_2;

/**
 * 矩阵乘法
 * @author xuejun
 */
public class MatrixMultiplication {
    /**
     * strassen 算法(阶数n为2的幂)
     */
    public static int[][] strassens(int n, int[][] a, int[][] b) {
        int[][] c = new int[n][n];
        if (!(n == 2)) {
            // 如果n不是2,拆分矩阵 A
            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];
            // 拆分矩阵 B
            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];
            // 矩阵 A 左上角赋给矩阵 a11
            for (int i = 0; i < (n / 2); i++) {
                for (int j = 0; j < (n / 2); j++) {
                    a11[i][j] = a[i][j];
                }
            }
            // 矩阵 A 右上角赋给矩阵 a12
            for (int i = 0; i < (n / 2); i++) {
                for (int j = (n / 2), k = 0; j < n; j++, k++) {
                    a12[i][k] = a[i][j];
                }
            }
            // 矩阵 A 左下角赋给矩阵 a21
            for (int i = (n / 2), k = 0; i < n; i++, k++) {
                for (int j = 0; j < (n / 2); j++) {
                    a21[k][j] = a[i][j];
                }
            }
            // 矩阵 A 右下角赋给矩阵 a22
            for (int i = (n / 2), k = 0; i < n; i++, k++) {
                for (int j = (n / 2), g = 0; j < n; j++, g++) {
                    a22[k][g] = a[i][j];
                }
            }
            // 矩阵 B 左上角赋给矩阵 b11
            for (int i = 0; i < (n / 2); i++) {
                for (int j = 0; j < (n / 2); j++) {
                    b11[i][j] = b[i][j];
                }
            }
            // 矩阵 B 右上角赋给矩阵 b12
            for (int i = 0; i < (n / 2); i++) {
                for (int j = (n / 2), k = 0; j < n; j++, k++) {
  
  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
传统方法和Strassen算法是两种不同的矩阵相乘算法传统方法的时间复杂度为O(n^3),而Strassen算法的时间复杂度为O(n^log2(7)),其中log2(7)约等于2.807。 因此,为了结合两种算法的优点,我们可以采用一个分治的思想,对矩阵的大小进行适当的划分,在两种算法之间进行选择。 具体实现如下: ```java public class MatrixMultiply { // 传统矩阵相乘算法 public static int[][] multiply(int[][] A, int[][] B) { int m = A.length; int n = A[0].length; int p = B[0].length; int[][] C = new int[m][p]; for (int i = 0; i < m; i++) { for (int j = 0; j < p; j++) { for (int k = 0; k < n; k++) { C[i][j] += A[i][k] * B[k][j]; } } } return C; } // Strassen算法 public static int[][] strassen(int[][] A, int[][] B) { int n = A.length; if (n <= 64) { return multiply(A, B); // 当矩阵大小小于等于64时,使用传统算法 } 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]; // 将矩阵A、B分成四个子矩阵 for (int i = 0; i < n / 2; i++) { for (int j = 0; j < n / 2; j++) { A11[i][j] = A[i][j]; A12[i][j] = A[i][j + n / 2]; A21[i][j] = A[i + n / 2][j]; A22[i][j] = A[i + n / 2][j + n / 2]; B11[i][j] = B[i][j]; B12[i][j] = B[i][j + n / 2]; B21[i][j] = B[i + n / 2][j]; B22[i][j] = B[i + n / 2][j + n / 2]; } } // 计算7个子矩阵 int[][] M1 = strassen(add(A11, A22), add(B11, B22)); int[][] M2 = strassen(add(A21, A22), B11); int[][] M3 = strassen(A11, sub(B12, B22)); int[][] M4 = strassen(A22, sub(B21, B11)); int[][] M5 = strassen(add(A11, A12), B22); int[][] M6 = strassen(sub(A21, A11), add(B11, B12)); int[][] M7 = strassen(sub(A12, A22), add(B21, B22)); // 计算结果矩阵C的四个子矩阵 int[][] C11 = add(sub(add(M1, M4), M5), M7); int[][] C12 = add(M3, M5); int[][] C21 = add(M2, M4); int[][] C22 = add(sub(add(M1, M3), M2), M6); // 将四个子矩阵合并成一个矩阵 int[][] C = new int[n][n]; for (int i = 0; i < n / 2; i++) { for (int j = 0; j < n / 2; j++) { C[i][j] = C11[i][j]; C[i][j + n / 2] = C12[i][j]; C[i + n / 2][j] = C21[i][j]; C[i + n / 2][j + n / 2] = C22[i][j]; } } return C; } // 矩阵加法 public static int[][] add(int[][] A, int[][] B) { int n = A.length; int[][] C = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { C[i][j] = A[i][j] + B[i][j]; } } return C; } // 矩阵减法 public static int[][] sub(int[][] A, int[][] B) { int n = A.length; int[][] C = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { C[i][j] = A[i][j] - B[i][j]; } } return C; } // 随机生成一个n*n的矩阵 public static int[][] generateMatrix(int n) { int[][] A = new int[n][n]; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { A[i][j] = (int) (Math.random() * 10); } } return A; } // 打印矩阵 public static void printMatrix(int[][] A) { int n = A.length; for (int i = 0; i < n; i++) { for (int j = 0; j < n; j++) { System.out.print(A[i][j] + " "); } System.out.println(); } } public static void main(String[] args) { int n = 8; int[][] A = generateMatrix(n); int[][] B = generateMatrix(n); System.out.println("矩阵A:"); printMatrix(A); System.out.println("矩阵B:"); printMatrix(B); int[][] C = strassen(A, B); System.out.println("矩阵C:"); printMatrix(C); } } ``` 在上述代码中,程序首先生成两个大小为n\*n的随机矩阵A和B,然后调用strassen方法计算它们的乘积。当矩阵大小小于等于64时,程序使用传统矩阵相乘算法。否则,程序将矩阵A和B分成四个子矩阵,递归地调用strassen方法计算它们的乘积,最后将结果矩阵的四个子矩阵合并成一个矩阵
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值