c++ 分而治之（施特拉森矩阵乘法）

于 2024-05-24 09:22:23 发布
阅读量574 收藏 17
点赞数 20
分类专栏： c++ 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hefeng_aspnet/article/details/138953523
版权

给定两个大小分别为 nxn 的方阵 A 和 B，求它们的乘法矩阵。 
朴素方法：以下是两个矩阵相乘的简单方法。
 
void multiply(int A[][N], int B[][N], int C[][N])
{
    for (int i = 0; i < N; i++)
    {
        for (int j = 0; j < N; j++)
        {
            C[i][j] = 0;
            for (int k = 0; k < N; k++)
            {
                C[i][j] += A[i][k]*B[k][j];
            }
        }
    }
}
 
// This code is contributed by noob2000.

上述方法的时间复杂度为O(N 3 )。 

分而治之 ：
以下是两个方阵相乘的简单分而治之方法。 
1、将矩阵 A 和 B 分为 4 个大小为 N/2 x N/2 的子矩阵，如下图所示。 
2、递归计算以下值。 ae + bg、af + bh、ce + dg 和 cf + dh。 

执行：
#include <bits/stdc++.h>
using namespace std;
 
#define ROW_1 4
#define COL_1 4
 
#define ROW_2 4
#define COL_2 4
 
void print(string display, vector<vector<int> > matrix,
           int start_row, int start_column, int end_row,
           int end_column)
{
    cout << endl << display << " =>" << endl;
    for (int i = start_row; i <= end_row; i++) {
        for (int j = start_column; j <= end_column; j++) {
            cout << setw(10);
            cout << matrix[i][j];
        }
        cout << endl;
    }
    cout << endl;
    return;
}
 
void add_matrix(vector<vector<int> > matrix_A,
                vector<vector<int> > matrix_B,
                vector<vector<int> >& matrix_C,
                int split_index)
{
    for (auto i = 0; i < split_index; i++)
        for (auto j = 0; j < split_index; j++)
            matrix_C[i][j]
                = matrix_A[i][j] + matrix_B[i][j];
}
 
vector<vector<int> >
multiply_matrix(vector<vector<int> > matrix_A,
                vector<vector<int> > matrix_B)
{
    int col_1 = matrix_A[0].size();
    int row_1 = matrix_A.size();
    int col_2 = matrix_B[0].size();
    int row_2 = matrix_B.size();
 
    if (col_1 != row_2) {
        cout << "\nError: The number of columns in Matrix "
                "A  must be equal to the number of rows in "
                "Matrix B\n";
        return {};
    }
 
    vector<int> result_matrix_row(col_2, 0);
    vector<vector<int> > result_matrix(row_1,
                                       result_matrix_row);
 
    if (col_1 == 1)
        result_matrix[0][0]
            = matrix_A[0][0] * matrix_B[0][0];
    else {
        int split_index = col_1 / 2;
 
        vector<int> row_vector(split_index, 0);
        vector<vector<int> > result_matrix_00(split_index,
                                              row_vector);
        vector<vector<int> > result_matrix_01(split_index,
                                              row_vector);
        vector<vector<int> > result_matrix_10(split_index,
                                              row_vector);
        vector<vector<int> > result_matrix_11(split_index,
                                              row_vector);
 
        vector<vector<int> > a00(split_index, row_vector);
        vector<vector<int> > a01(split_index, row_vector);
        vector<vector<int> > a10(split_index, row_vector);
        vector<vector<int> > a11(split_index, row_vector);
        vector<vector<int> > b00(split_index, row_vector);
        vector<vector<int> > b01(split_index, row_vector);
        vector<vector<int> > b10(split_index, row_vector);
        vector<vector<int> > b11(split_index, row_vector);
 
        for (auto i = 0; i < split_index; i++)
            for (auto j = 0; j < split_index; j++) {
                a00[i][j] = matrix_A[i][j];
                a01[i][j] = matrix_A[i][j + split_index];
                a10[i][j] = matrix_A[split_index + i][j];
                a11[i][j] = matrix_A[i + split_index]
                                    [j + split_index];
                b00[i][j] = matrix_B[i][j];
                b01[i][j] = matrix_B[i][j + split_index];
                b10[i][j] = matrix_B[split_index + i][j];
                b11[i][j] = matrix_B[i + split_index]
                                    [j + split_index];
            }
 
        add_matrix(multiply_matrix(a00, b00),
                   multiply_matrix(a01, b10),
                   result_matrix_00, split_index);
        add_matrix(multiply_matrix(a00, b01),
                   multiply_matrix(a01, b11),
                   result_matrix_01, split_index);
        add_matrix(multiply_matrix(a10, b00),
                   multiply_matrix(a11, b10),
                   result_matrix_10, split_index);
        add_matrix(multiply_matrix(a10, b01),
                   multiply_matrix(a11, b11),
                   result_matrix_11, split_index);
 
        for (auto i = 0; i < split_index; i++)
            for (auto j = 0; j < split_index; j++) {
                result_matrix[i][j]
                    = result_matrix_00[i][j];
                result_matrix[i][j + split_index]
                    = result_matrix_01[i][j];
                result_matrix[split_index + i][j]
                    = result_matrix_10[i][j];
                result_matrix[i + split_index]
                             [j + split_index]
                    = result_matrix_11[i][j];
            }
 
        result_matrix_00.clear();
        result_matrix_01.clear();
        result_matrix_10.clear();
        result_matrix_11.clear();
        a00.clear();
        a01.clear();
        a10.clear();
        a11.clear();
        b00.clear();
        b01.clear();
        b10.clear();
        b11.clear();
    }
    return result_matrix;
}
 
int main()
{
    vector<vector<int> > matrix_A = { { 1, 1, 1, 1 },
                                      { 2, 2, 2, 2 },
                                      { 3, 3, 3, 3 },
                                      { 2, 2, 2, 2 } };
 
    print("Array A", matrix_A, 0, 0, ROW_1 - 1, COL_1 - 1);
 
    vector<vector<int> > matrix_B = { { 1, 1, 1, 1 },
                                      { 2, 2, 2, 2 },
                                      { 3, 3, 3, 3 },
                                      { 2, 2, 2, 2 } };
 
    print("Array B", matrix_B, 0, 0, ROW_2 - 1, COL_2 - 1);
 
    vector<vector<int> > result_matrix(
        multiply_matrix(matrix_A, matrix_B));
 
    print("Result Array", result_matrix, 0, 0, ROW_1 - 1,
          COL_2 - 1);
}
 
// Time Complexity: O(n^3)
// Code Contributed By: lucasletum

输出
数组A =>
         1 1 1 1
         2 2 2 2
         3 3 3 3
         2 2 2 2


数组 B =>
         1 1 1 1
         2 2 2 2
         3 3 3 3
         2 2 2 2


结果数组=>
         8 8 8 8
        16 16 16 16
        24 24 24 24
        16 16 16 16
        
在上述方法中，我们对大小为 N/2 x N/2 的矩阵进行 8 次乘法和 4 次加法。两个矩阵相加需要 O(N 2 ) 时间。所以时间复杂度可以写成 

T(N) = 8T(N/2) + O(N 2 )  

根据马斯特定理，上述方法的时间复杂度为 O(N 3 )
不幸的是，这与上面的简单方法相同。

简单的分而治之也导致O(N 3 )，有更好的方法吗？ 

        在上面的分而治之的方法中，高时间复杂度的主要成分是8次递归调用。Strassen 方法的思想是将递归调用次数减少到 7 次。Strassen 方法与上述简单的分而治之方法类似，该方法也将矩阵划分为大小为 N/2 x N/2 的子矩阵：如上图所示，但在Strassen方法中，结果的四个子矩阵是使用以下公式计算的。

Strassen 方法的时间复杂度

两个矩阵的加法和减法需要 O(N 2 ) 时间。所以时间复杂度可以写成 

T(N) = 7T(N/2) + O(N 2 )

根据马斯特定理，上述方法的时间复杂度为
O(N Log7 ) 大约为 O(N 2.8074 )

一般来说，由于以下原因，施特拉森方法在实际应用中并不优选。 

1、Strassen 方法中使用的常数很高，对于典型应用，Naive 方法效果更好。 
2、对于稀疏矩阵，有专门为其设计的更好的方法。 
3、递归中的子矩阵占用额外的空间。 
4、由于计算机对非整数值的运算精度有限，Strassen 算法中累积的误差比 Naive 方法中更大。

执行：
#include <bits/stdc++.h>
using namespace std;
 
#define ROW_1 4
#define COL_1 4
 
#define ROW_2 4
#define COL_2 4
 
void print(string display, vector<vector<int> > matrix,
           int start_row, int start_column, int end_row,
           int end_column)
{
    cout << endl << display << " =>" << endl;
    for (int i = start_row; i <= end_row; i++) {
        for (int j = start_column; j <= end_column; j++) {
            cout << setw(10);
            cout << matrix[i][j];
        }
        cout << endl;
    }
    cout << endl;
    return;
}
 
vector<vector<int> >
add_matrix(vector<vector<int> > matrix_A,
           vector<vector<int> > matrix_B, int split_index,
           int multiplier = 1)
{
    for (auto i = 0; i < split_index; i++)
        for (auto j = 0; j < split_index; j++)
            matrix_A[i][j]
                = matrix_A[i][j]
                  + (multiplier * matrix_B[i][j]);
    return matrix_A;
}
 
vector<vector<int> >
multiply_matrix(vector<vector<int> > matrix_A,
                vector<vector<int> > matrix_B)
{
    int col_1 = matrix_A[0].size();
    int row_1 = matrix_A.size();
    int col_2 = matrix_B[0].size();
    int row_2 = matrix_B.size();
 
    if (col_1 != row_2) {
        cout << "\nError: The number of columns in Matrix "
                "A  must be equal to the number of rows in "
                "Matrix B\n";
        return {};
    }
 
    vector<int> result_matrix_row(col_2, 0);
    vector<vector<int> > result_matrix(row_1,
                                       result_matrix_row);
 
    if (col_1 == 1)
        result_matrix[0][0]
            = matrix_A[0][0] * matrix_B[0][0];
    else {
        int split_index = col_1 / 2;
 
        vector<int> row_vector(split_index, 0);
 
        vector<vector<int> > a00(split_index, row_vector);
        vector<vector<int> > a01(split_index, row_vector);
        vector<vector<int> > a10(split_index, row_vector);
        vector<vector<int> > a11(split_index, row_vector);
        vector<vector<int> > b00(split_index, row_vector);
        vector<vector<int> > b01(split_index, row_vector);
        vector<vector<int> > b10(split_index, row_vector);
        vector<vector<int> > b11(split_index, row_vector);
 
        for (auto i = 0; i < split_index; i++)
            for (auto j = 0; j < split_index; j++) {
                a00[i][j] = matrix_A[i][j];
                a01[i][j] = matrix_A[i][j + split_index];
                a10[i][j] = matrix_A[split_index + i][j];
                a11[i][j] = matrix_A[i + split_index]
                                    [j + split_index];
                b00[i][j] = matrix_B[i][j];
                b01[i][j] = matrix_B[i][j + split_index];
                b10[i][j] = matrix_B[split_index + i][j];
                b11[i][j] = matrix_B[i + split_index]
                                    [j + split_index];
            }
 
        vector<vector<int> > p(multiply_matrix(
            a00, add_matrix(b01, b11, split_index, -1)));
        vector<vector<int> > q(multiply_matrix(
            add_matrix(a00, a01, split_index), b11));
        vector<vector<int> > r(multiply_matrix(
            add_matrix(a10, a11, split_index), b00));
        vector<vector<int> > s(multiply_matrix(
            a11, add_matrix(b10, b00, split_index, -1)));
        vector<vector<int> > t(multiply_matrix(
            add_matrix(a00, a11, split_index),
            add_matrix(b00, b11, split_index)));
        vector<vector<int> > u(multiply_matrix(
            add_matrix(a01, a11, split_index, -1),
            add_matrix(b10, b11, split_index)));
        vector<vector<int> > v(multiply_matrix(
            add_matrix(a00, a10, split_index, -1),
            add_matrix(b00, b01, split_index)));
 
        vector<vector<int> > result_matrix_00(add_matrix(
            add_matrix(add_matrix(t, s, split_index), u,
                       split_index),
            q, split_index, -1));
        vector<vector<int> > result_matrix_01(
            add_matrix(p, q, split_index));
        vector<vector<int> > result_matrix_10(
            add_matrix(r, s, split_index));
        vector<vector<int> > result_matrix_11(add_matrix(
            add_matrix(add_matrix(t, p, split_index), r,
                       split_index, -1),
            v, split_index, -1));
 
        for (auto i = 0; i < split_index; i++)
            for (auto j = 0; j < split_index; j++) {
                result_matrix[i][j]
                    = result_matrix_00[i][j];
                result_matrix[i][j + split_index]
                    = result_matrix_01[i][j];
                result_matrix[split_index + i][j]
                    = result_matrix_10[i][j];
                result_matrix[i + split_index]
                             [j + split_index]
                    = result_matrix_11[i][j];
            }
 
        a00.clear();
        a01.clear();
        a10.clear();
        a11.clear();
        b00.clear();
        b01.clear();
        b10.clear();
        b11.clear();
        p.clear();
        q.clear();
        r.clear();
        s.clear();
        t.clear();
        u.clear();
        v.clear();
        result_matrix_00.clear();
        result_matrix_01.clear();
        result_matrix_10.clear();
        result_matrix_11.clear();
    }
    return result_matrix;
}
 
int main()
{
    vector<vector<int> > matrix_A = { { 1, 1, 1, 1 },
                                      { 2, 2, 2, 2 },
                                      { 3, 3, 3, 3 },
                                      { 2, 2, 2, 2 } };
 
    print("Array A", matrix_A, 0, 0, ROW_1 - 1, COL_1 - 1);
 
    vector<vector<int> > matrix_B = { { 1, 1, 1, 1 },
                                      { 2, 2, 2, 2 },
                                      { 3, 3, 3, 3 },
                                      { 2, 2, 2, 2 } };
 
    print("Array B", matrix_B, 0, 0, ROW_2 - 1, COL_2 - 1);
 
    vector<vector<int> > result_matrix(
        multiply_matrix(matrix_A, matrix_B));
 
    print("Result Array", result_matrix, 0, 0, ROW_1 - 1,
          COL_2 - 1);
}
 
// Time Complexity: T(N) = 7T(N/2) +  O(N^2) => O(N^Log7)
// which is approximately O(N^2.8074) Code Contributed By:
// lucasletum

输出
数组A =>
         1 1 1 1
         2 2 2 2
         3 3 3 3
         2 2 2 2


数组 B =>
         1 1 1 1
         2 2 2 2
         3 3 3 3
         2 2 2 2


结果数组=>
         8 8 8 8
        16 16 16 16
        24 24 24 24
        16 16 16 16 

csdn_aspnet
关注
专栏目录
matrix:Javascript中的矩阵运算
05-14
矩阵 使用Javascript的功能性质执行基本矩阵运算的Javascript库 用法 var a = [ [ 1 , 2 , 3 ] , [ 4 , 5 , 6 ] , [ 7 , 8 , 9 ] ] var A = matrix ( a ) ; 运作方式 1.身份 A ( ) ; //returns [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 2.行 A ( 0 ) ; // returns [1, 2, 3] 3.专栏 A ( [ ] , 0 ) ; // returns [[1], [4], [7]] 4.元素 A ( 1 , 2 ) ; // returns 6 5.范围 A ( [ 1 , 2 ] ) ; // returns [[4, 5, 6], [7, 8, 9]] A ( [ ] , [ 1 , 2 ] ) ; // returns [[2, 3
JS实现矩阵相乘、行列式、逆矩阵
十二翼堕落天使
05-15 5380
一、矩阵运算 1.1 矩阵相乘 Am×p{\rm A_{m \times p}}Am×p​、Bp×n{\rm B_{p \times n}}Bp×n​ Cm×n=Am×p×Bp×n{\rm C_{m \times n}} = {\rm A_{m \times p}} \times {\rm B_{p \times n}}Cm×n​=Am×p​×Bp×n​ Cij=∑k=1paik⋅bkj{\rm C_{ij}} = \sum_{ \rm k=1}^{\rm p} a_{\rm ik} \cdot b_{\
JavaScript计算矩阵相乘
weixin_44589374的博客
05-01 2573
JavaScript计算矩阵相乘 封装好的函数，拿去直接用 function matrixMul(a,b){ var c=new Array(a.length); for(var i=0;i<a.length;i++) { c[i]=new Array(b[0].length); for(var j=0;j<b[0].length;j++) { c[i][j...
Strassen矩阵乘法——C++
最新发布
stu_kk的博客
04-28 1545
基于分治法的矩阵快速乘法---C++实现
Strassen矩阵乘法(C++)
阳young的博客
04-29 5034
思路 两个矩阵A,B相乘时.有以下三种方法 暴力计算法. 三个for循环, 这时候时间复杂度为O(n^3).因为Cij=∑(k=1->n)Aik*Bkj,需要一个循环, 且C中有n^2个元素, 所以时间复杂度为O(n^3) 分治法. 首先将A,B,C分成相等大小的方块矩阵. 所以C11=A11*B11+A12*B21, C12=A11*B12+A12*B22, C21=A21*B11+A22*B21, C22=A21*B12+A22*B22 用T(n)表示n*n矩阵的乘法, 所以有T(
五、分治法应用--矩阵乘法
runing
01-17 2523
1 朴素算法 这个算法就是矩阵乘法的定义： 很容易看出这个算法复杂度是Θ(n3)\Theta(n^3)Θ(n3)。 2 递归算法 分治法首先是从分割问题开始的，得到数学上的递归关系后，然后使用递归的方式实现。 由上面的数学性质，可以使用递归实现： T(n)=8T(n/2)+Θ(n2)T(n)=8T(n/2)+\Theta(n^2)T(n)=8T(n/2)+Θ(n2)，应用主定理可知，T(n)=Θ(n3)T(n)=\Theta(n^3)T(n)=Θ(n3)，没有什么进步，不过这里分割思路是没有问题
矩阵乘法的算法实现 [转载]
热门推荐
我的博客
11-26 2万+
一般矩阵乘法算法： 原理：矩阵相乘最重要的方法是一般矩阵乘积。它只有在第一个矩阵的栏数（column）和第二个矩阵的列数（row）相同时才有定义。一般单指矩阵乘积时，指的便是一般矩阵乘积。若A为m×n矩阵，B为n×p矩阵，则他们的乘积AB会是一个m×p矩阵。其乘积矩阵的元素如下面式子得出： 代码如下： struct mat{ int n, m; doubl
C++ 分而治之——木棒切割问题（二分法）
weixin_46227315的博客
05-05 2562
问题描述： 给出n根木棒，长度均已知，现在希望通过切割他们来得到至少K段长度相等的木棒（长度必须是整数），问这些相等的木棒最长有多长。例如对三根长度为15、10、24的木棒来说，假设K = 7，即需要至少7段长度相等的木棒，那么可以达到的最大长度为6。 注意事项 木棒的长度均为整数，在这种情况下，第一根木棒可以提供15 / 6 = 2根木棒，第二根可以提供10 / 6 = 1根，第三根可以提供4根...
矩阵的乘法算法
ryan_jianjian的博客
11-25 7218
一般矩阵乘法算法： 原理：矩阵相乘最重要的方法是一般矩阵乘积。它只有在第一个矩阵的栏数（column）和第二个矩阵的列数（row）相同时才有定义。一般单指矩阵乘积时，指的便是一般矩阵乘积。若A为m×n矩阵，B为n×p矩阵，则他们的乘积AB会是一个m×p矩阵。其乘积矩阵的元素如下面式子得出： 代码如下： struct mat{ int n, m; doubl
strassen矩阵乘法
chenglinhust的专栏
07-02 5213
Strassen矩阵乘法简要解析 Strassen矩阵乘法具体描述如下： 两个n×n 阶的矩阵A与B的乘积是另一个n×n 阶矩阵C，C可表示为假如每一个C(i, j) 都用此公式计算，则计算C所需要的操作次数为n3 m+n2 (n- 1) a，其中m表示一次乘法，a 表示一次加法或减法。 为了使讨论简便，假设n 是2的幂（也就是说， n是1，2，4，8，1 6，...）。 首先，假
JS实现简单的二维矩阵乘积运算
11-22
本文实例讲述了JS实现简单的二维矩阵乘积运算方法。分享给大家供大家参考，具体如下： Console控制台截图如下： (上图为输出结果直接上代码了(A矩阵可以乘以B矩阵的前提是A矩阵的列数等于B矩阵的行数) <!DOCTYPE html> <html> <head> <title>demo</title> </head> <body> </body> [removed] function log(msg) { console.log(msg); } /** * 可视化的打印出
strassen矩阵相乘算法(c++版）
09-27
strassen矩阵相乘算法c++代码，可以计算算法速度。
Strassen矩阵相乘算法，C++实现，可运行
11-04
算法作业题目，用Strassen算法求矩阵相乘问题，C++源代码，可运行
矩阵乘法的strassen算法(C++实现)
04-23
一般情况下矩阵乘法需要三个for循环，时间复杂度为O(n^3)，现在我们将矩阵分块如图：( 来自MIT算法导论 ) 一般算法需要八次乘法 r = a * e + b * g ; s = a * f + b * h ; t = c * e + d * g; u = c * f + d * h; strassen将其变成7次乘法，因为大家都知道乘法比加减法消耗更多，所有时间复杂更高！ strassen的处理是： 令： p1 = a * ( f - h ) p2 = ( a + b ) * h p3 = ( c +d ) * e p4 = d * ( g - e ) p5 = ( a + d ) * ( e + h ) p6 = ( b - d ) * ( g + h ) p7 = ( a - c ) * ( e + f ) 那么我们可以知道： r = p5 + p4 + p6 - p2 s = p1 + p2 t = p3 + p4 u = p5 + p1 - p3 - p7
Strassen 算法 C++ 实现 任意矩阵相乘
11-18
Strassen 算法 C++ 实现 任意矩阵相乘 用Command line 输入编制好的两个矩阵，输出相乘的结果矩阵。如果需要手动输入，删除程序里的相关语句，添加输入命令即可。
JavaScript实现矩阵乘法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
10-24 179
JavaScript实现矩阵乘法（附完整源码）
Strassen矩阵乘法C++实现
qq_39545674的博客
11-15 1905
1 问题描述 求矩阵A，B相乘的结果C Cmn=AmbBbn C_{mn}=A_{mb}B_{bn} Cmn​=Amb​Bbn​ 2 分析 2.1 传统解法 直接根据矩阵乘法的定义来遍历计算。 Cij=∑k=1bAik×Bkj C_{ij}=\sum_{k=1}^{b}{A_{ik}\times B_{kj}} Cij​=k=1∑b​Aik​×Bkj​ c++语言代码： void matrixMul(int** A,int** B,int** C,int m,int b,int n){ for(in
Strassen矩阵乘法算法-c++实现
copbint
09-28 3597
基本完全参考以下文章实现，不过是看了一遍之后自己为了加深理解手写的。 http://www.mamicode.com/info-detail-673908.html #include "stdafx.h" #include #include #include #include using namespace std; template class Strassen { publi
斯特拉森矩阵乘法的实现
weixin_34161029的博客
04-09 233
网上关于斯特拉森矩阵的乘法，代码框架很多 只是没有实现的代码块（有，但是就是不会运行） 老师布置的了相关利用分治法来做的的题目 想了很久，大概三天了（分治法大问题化小问题）是真没有完美的解决方法 找到了个可以运行的java代码：java写的代码思路是真的清晰（粉java） package sort; /** * @Author liguo * @Descriptio...
分治策略实现斯特拉森矩阵乘法
09-30
斯特拉森矩阵乘法的分治策略实现如下： 1. 将矩阵A和矩阵B划分为4个大小相等的子矩阵，每个子矩阵的大小为原矩阵的一半。 2. 对于每个子矩阵，递归地计算以下7个临时矩阵： - S1 = B12 - B22 - S2 = A11 + A12 - S3 = A21 + A22 - S4 = B21 - B11 - S5 = A11 + A22 - S6 = B11 + B22 - S7 = A12 - A22 3. 递归地计算以下7个中间矩阵： - P1 = A11 * S1 - P2 = S2 * B22 - P3 = S3 * B11 - P4 = A22 * S4 - P5 = S5 * S6 - P6 = S7 * S1 - P7 = S5 * S4 4. 计算结果矩阵C的4个子矩阵： - C11 = P5 + P4 - P2 + P6 - C12 = P1 + P2 - C21 = P3 + P4 - C22 = P5 + P1 - P3 - P7 5. 将4个子矩阵组合成新矩阵C。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值