矩阵乘法 C++

最新推荐文章于 2024-05-24 16:04:58 发布
最新推荐文章于 2024-05-24 16:04:58 发布
阅读量724 收藏 3
点赞数
文章标签： 算法导论
原文链接：https://github.com/MahadiHasanNahid/Strassen-Algorithm/blob/master/StrassenAlgorithm.cpp
版权
本文介绍了如何使用C++实现矩阵乘法，包括经典的暴力求解方法以及Strassen算法，该算法运用分治策略，通过数学技巧将时间复杂度降低到O(n^lg7)。
摘要由CSDN通过智能技术生成

暴力法：

#include<iostream>
using namespace std;

int main() {
    int a[2][2];
    int b[2][2];
    int c[2][2];

    cout << "输入矩阵a：" << endl;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            cin >> a[i][j];
        }
    }
    cout << "输入矩阵b：" << endl;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            cin >> b[i][j];
        }
    }
    for (int i = 0; i < 2; i++)  //初始化矩阵c
    {
        for (int j = 0; j < 2; j++)
        {
            c[i][j] = 0;
        }
    }

    for (int i = 0; i < 2; i++)  //3个for循环计算c[i][j]
    {
        for (int j = 0; j < 2; j++)
        {
            for (int k = 0; k < 2; k++)
            {
                c[i][j] = c[i][j] + (a[i][k] * b[k][j]);  
            }
        }
    }
    cout << "矩阵a乘矩阵b结果如下：" << endl;
    for (int i = 0; i < 2; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            cout << c[i][j] << " ";
        }cout << endl;
    }
    return 0;
}

Strassen算法：巧妙利用分治法，是时间复杂度为O(n^lg7)，感觉是用数学的方法缩短了时间复杂度，第一次看的时候感觉满骚的。

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define SIZE 16

using namespace std;

void ReadMatrix(double**,int);
void WriteMatrix(double**,int);

void MatrixAdd(double **A, double **B, double **Result, int N);
void MatrixSubtrac(double **A, double **B, double **Result, int N);

void StrassenAlgorithm(double **A, double **B, double **C, int N);


/*输入矩阵*/
void ReadMatrix(double A[][SIZE],int N)
{
    int i,j;

    for(i=0; i<N; i++)
    {
        for(j=0; j<N; j++)
        {
            scanf("%lf", &A[i][j]);
        }
    }
}

/*打印矩阵*/
void WriteMatrix(double A[][SIZE], int N)
{
    int i, j;

    for(i=0; i<N; i++)
    {
        for(j=0; j<N; j++)
        {
            printf("%0.1lf \t", A[i][j]);
        }
        printf("\n");
    }
}

/*把两个矩阵相加*/
void MatrixAdd(double A[][SIZE], double B[][SIZE], double Result[][SIZE], int N)
{
    int i, j;

    for(i=0; i< N; i++)
    {
        for(j=0; j<N; j++)
        {
            Result[i][j] = A[i][j] + B[i][j];
        }
    }

}

/*从一个矩阵中减去另一个矩阵*/
void MatrixSubtrac(double A[][SIZE], double B[][SIZE], double Result[][SIZE], int N)
{
    int i, j;

    for(i=0; i< N; i++)
    {
        for(j=0; j<N; j++)
        {
            Result[i][j] = A[i][j] - B[i][j];
        }
    }
}


/* Strassen算法 分治*/
void StrassenAlgorithm(double A[][SIZE], double B[][SIZE], double C[][SIZE], int N)
{
    // trivial case: when the matrice is 1 X 1:
    if(N == 1)
    {
        C[0][0] = A[0][0] * B[0][0];
        return;
    }

    // other cases are treated here:
    else
    {
        int Divide  = (int)(N/2);

        double A11[SIZE][SIZE], A12[SIZE][SIZE], A21[SIZE][SIZE], A22[SIZE][SIZE];
        double B11[SIZE][SIZE], B12[SIZE][SIZE], B21[SIZE][SIZE], B22[SIZE][SIZE];
        double C11[SIZE][SIZE], C12[SIZE][SIZE], C21[SIZE][SIZE], C22[SIZE][SIZE];
        double P1[SIZE][SIZE], P2[SIZE][SIZE], P3[SIZE][SIZE], P4[SIZE][SIZE], P5[SIZE][SIZE], P6[SIZE][SIZE], P7[SIZE][SIZE];
        double AResult[SIZE][SIZE], BResult[SIZE][SIZE];

        int i, j;

        //将矩阵划分为4个矩阵
        for (i = 0; i < Divide; i++)
        {
            for (j = 0; j < Divide; j++)
            {
                A11[i][j] = A[i][j];
                A12[i][j] = A[i][j + Divide];
                A21[i][j] = A[i + Divide][j];
                A22[i][j] = A[i + Divide][j + Divide];

                B11[i][j] = B[i][j];
                B12[i][j] = B[i][j + Divide];
                B21[i][j] = B[i + Divide][j];
                B22[i][j] = B[i + Divide][j + Divide];
            }
        }

        // 计算p1到p7:
      
        MatrixAdd(A11, A22, AResult, Divide);   // a11 + a22
        MatrixAdd(B11, B22, BResult, Divide);   // b11 + b22
        StrassenAlgorithm(AResult, BResult, P1, Divide);  // p1 = (a11+a22) * (b11+b22)

        MatrixAdd(A21, A22, AResult, Divide);   // a21 + a22
        StrassenAlgorithm(AResult, B11, P2, Divide); // p2 = (a21+a22) * (b11)

        MatrixSubtrac(B12, B22, BResult, Divide); // b12 - b22
        StrassenAlgorithm(A11, BResult, P3, Divide); // p3 = (a11) * (b12 - b22)

        MatrixSubtrac(B21, B11, BResult, Divide); // b21 - b11
        StrassenAlgorithm(A22, BResult, P4, Divide); // p4 = (a22) * (b21 - b11)

        MatrixAdd(A11, A12, AResult, Divide); // a11 + a12
        StrassenAlgorithm(AResult, B22, P5, Divide); // p5 = (a11+a12) * (b22)

        MatrixSubtrac(A21, A11, AResult, Divide); // a21 - a11
        MatrixAdd(B11, B12, BResult, Divide); // b11 + b12
        StrassenAlgorithm(AResult, BResult, P6, Divide); // p6 = (a21-a11) * (b11+b12)

        MatrixSubtrac(A12, A22, AResult, Divide); // a12 - a22
        MatrixAdd(B21, B22, BResult, Divide); // b21 + b22
        StrassenAlgorithm(AResult, BResult, P7, Divide); // p7 = (a12-a22) * (b21+b22)

        // 计算 c21, c21, c11 ， c22:

        MatrixAdd(P3, P5, C12, Divide); // c12 = p3 + p5
        MatrixAdd(P2, P4, C21, Divide); // c21 = p2 + p4

        MatrixAdd(P1, P4, AResult, Divide); // p1 + p4
        MatrixAdd(AResult, P7, BResult, Divide); // p1 + p4 + p7
        MatrixSubtrac(BResult, P5, C11, Divide); // c11 = p1 + p4 - p5 + p7

        MatrixAdd(P1, P3, AResult, Divide); // p1 + p3
        MatrixAdd(AResult, P6, BResult, Divide); // p1 + p3 + p6
        MatrixSubtrac(BResult, P2, C22, Divide); // c22 = p1 + p3 - p2 + p6


        // 将获得的结果放在矩阵c中

        for (i = 0; i < Divide ; i++)
        {
            for (j = 0 ; j < Divide ; j++)
            {
                C[i][j] = C11[i][j];
                C[i][j + Divide] = C12[i][j];
                C[i + Divide][j] = C21[i][j];
                C[i + Divide][j + Divide] = C22[i][j];
            }
        }

    }

}


int main()
{
    double A[SIZE][SIZE], B[SIZE][SIZE], C[SIZE][SIZE];
    int i,j;
    int N,M,Count = 0;

    printf("What Is The Dimention: ");
    scanf("%d",&N);

    M = N;

    printf("Matrix A:\n");
    ReadMatrix(A,M);
    printf("Matrix B:\n");
    ReadMatrix(B,M);

    if(M > 1)
    {

        while(M>=2)
        {
            M/=2;
            Count++;
        }

        M = N;

        if(M != (pow(2.0,Count)))
        {
            N = pow(2.0,Count+1);

            for(i=0; i<N; i++)
            {
                for(j=0; j<N; j++)
                {
                    if((i>=M) || (j>=M))
                    {
                        A[i][j] = 0.0;
                        B[i][j] = 0.0;
                    }
                }
            }
        }
    }

    StrassenAlgorithm(A,B,C,N); 

    printf("Matrix A:\n\n");
    WriteMatrix(A,M);
    printf("Matrix B:\n\n");
    WriteMatrix(B,M);
    printf("The Product Of These Two Matrix:\n\n");
    WriteMatrix(C,M);

    return 0;

}

m0_56075632
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
c++实现矩阵乘法
D_D_zy的博客
02-10 1439
c++实现矩阵乘法
C++矩阵乘法C++矩阵乘法
05-20
C++矩阵乘法C++矩阵乘法C++矩阵乘法C++矩阵乘法C++矩阵乘法
C++ 矩阵乘法
最新发布
u011022940的博客
05-24 173
【代码】C++ 矩阵乘法。
矩阵乘法C++
大罗山下瓯江畔的博客
08-01 2344
// 如果A是个x行y列的矩阵，B是个y行z列的矩阵，把A和B相乘， // 其结果将是另一个x行z列的矩阵C。 // 矩阵的大小不超过100*100 using namespace std; // 输入描述： // 第一行包含一个正整数x，代表第一个矩阵的行数 // 第二行包含一个正整数y，代表第一个矩阵的列数和第二个矩阵的行数 // 第三行包含一个正整数z，代表第二个矩阵的列数 // 之后x行，每行y个整数，代表第一个矩阵的值 // 之后y行，每行z个整数，代表第二个矩阵的值 ...
矩阵乘法（c++）
gyk1303的博客
11-27 335
AC代码： ​ #include<bits/stdc++.h> using namespace std; int main() { int n,m,k; int A[101][101],B[101][101],C[101][101]={0}; cin>>n>>m>>k;//输入n,m,k for(int i=0;i<=n-1;i++)//输入A { for(int j=0;j<=m-1;j++) { cin>...
矩阵乘法（C++）
m0_74036684的博客
10-30 1万+
一般难度的for循环应用，是典型线性代数例题
Strassen矩阵乘法 c++实现
04-11
算法分析与设计课程作业，单个cpp文件
c++矩阵乘法
05-15
#include #include #include using namespace std;//使用标准名字空间 typedef int Subscript;//凡用到Subscript的地方都定义为int #undef TNT_BOUNDS_CHECK//检查边界是否合法 template <class T>//定义向量类...
两个矩阵乘法c++实现
05-10
在编程领域，矩阵乘法是线性代数中的基本操作，广泛应用于图形学、机器学习、科学计算等众多领域。本篇文章将详细讲解如何使用C++语言实现两个矩阵的乘法运算。 首先，我们需要理解矩阵乘法的基本规则。对于两个...
Desktop_C++_算法导论_矩阵乘法_递归_
10-03
在本项目中，我们主要探讨的是C++编程语言中的矩阵乘法算法，特别是基于《算法导论》第六版第四章77页所描述的递归方法。递归是一种强大的编程技术，它允许函数调用自身来解决问题。在这个特定的场景中，递归被用来...
c++ 矩阵乘法
05-30
C++面向对象，矩阵的乘法运算，没有构造函数而是直接在main函数里面运行
矩阵的乘法C++
MAINKEYS的博客
01-15 1万+
无聊中自己写了个矩阵乘法。 已知A，B两个矩阵相乘为C矩阵。 代码如下 #include<iostream> using namespace std; #define ROW 100 #define COL 100 int main() { int a[ROW][COL],b[ROW][COL],c[ROW][COL]; int i,j,k,m,n,q; cin>&g...
矩阵乘法(C/C++)
weixin_45500953的博客
03-08 1747
矩阵乘法(C/C++) 代码如下： #include<stdio.h> int main(){ //r1表示第一个矩阵的行数，c1表示第一个矩阵的列数 //r2表示第二个矩阵的行数，c2表示第二个矩阵的列数 int r1, c1, r2, c2; //输入第一个矩阵的行数和列数 printf("输入第一个矩阵的行数和列数："); scanf("%d %d", &r1, &c1); //输入第二个矩阵的行数和列数 printf("输入第二个矩阵的行数和列
【C++】矩阵的乘法
qq_63806300的博客
05-19 3962
由矩阵相乘的性质可以用三层循环求出结果，注意i的循环需要放在最外层，j的循环需要放在中间层，k的循环需要放在最低层。因为矩阵A是2×3矩阵，矩阵B是3×3矩阵，A的列数等于B的行数，所以矩阵A与B可以相乘，乘积AB是一个2×3矩阵。矩阵相乘时需要注意两点，一点是矩阵1的列数要等与矩阵2的行数，一点是矩阵相乘后的矩阵。手算一下AB，不难发现结果是正确的。先复习一下矩阵的乘法。
C++ 实现矩阵乘法
热门推荐
yang20141109的专栏
03-31 1万+
矩阵相乘的时间复杂度为o(n*n*n)。使用vector>来表示矩阵。#include #include using namespace std; vector> matrix_multiply(vector> arrA, vector> arrB) { //矩阵arrA的行数 int rowA = arrA.size(); //矩阵arrA的列数 int colA = arrA[0].
(c++)矩阵乘法
执念斩长河
03-10 490
算法基础 c++ 矩阵乘法 MATLAB 郭炜
大规模矩阵乘法c++
09-27
大规模矩阵乘法是通过对两个矩阵的每个元素进行逐个相乘，并将结果相加得到新的矩阵的过程。具体而言，对于一个m×p的矩阵A和一个p×n的矩阵B，其矩阵乘法结果C的大小为m×n。在计算过程中，需要遍历矩阵A的每一行和矩阵B的每一列，将对应元素相乘并累加得到矩阵C的相应元素。 对于大规模的矩阵乘法计算，可以采用并行计算的方法来提高计算效率。例如，可以将矩阵A和矩阵B分解为多个小的块矩阵，并分配给多个处理单元同时进行计算。这样可以充分利用多核处理器或者分布式计算系统的计算能力，加速矩阵乘法的计算过程。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值