精华内容
下载资源
问答
  • 矩阵相乘算法

    2020-01-16 19:43:32
    数学中矩阵相乘的具体过程: 1、当矩阵A的列数等于矩阵B的行数时,A与B可以相乘。 2、矩阵C的行数等于矩阵A的行数,C的列数等于B的列数。 3、乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应...

    数学中矩阵相乘的具体过程:

    1、当矩阵A列数等于矩阵B行数时,AB可以相乘。

    2、矩阵C的行数等于矩阵A的行数C的列数等于B的列数

    3、乘积C的第m行第n列的元素等于矩阵A的第m行的元素与矩阵B的第n列对应元素乘积之和。

     

    C语言算法过程:

    for(i=0;i<n;i++)

       for(j=0;j<n;j++) {

       c[i][j]=0;

       for(k=0;k<n;k++)

       c[i][j]=c[i][j]+a[i][k]*b[k][j];

       }

       //矩阵相乘只有在第一个矩阵的列数和第二个矩阵的行数相同时才有意义

    展开全文
  • srassen矩阵相乘算法++代码 作者: 日期 ? tassen 矩阵相乘算法代码 如果喜欢请下载使用,谢谢 #includ tchah> iclude <ostra #inclde cme> #ilude ; templatetypname T> ls Srase_las { public ?oi ADDT MarxA, T* ...
  • 使用Hadoop MapReduce实现两个矩阵相乘算法
  • java矩阵相乘算法

    2011-08-13 21:41:56
    java写的二维矩阵相乘算法,控制台程序,要求用户输入行数及列数,自动生成二维数组相乘
  • 数据结构实验一 —— 矩阵相乘算法 实验名称 矩阵相乘算法 实验内容 实现两个矩阵的相乘算法。 实验要求 输入要求:矩阵大小阶数及元素值可以在程序中固定。但最好不固定矩阵形式,从键盘输入矩阵阶数以及元素值。 ...

    数据结构实验一 —— 矩阵相乘算法

    实验名称

    矩阵相乘算法

    实验内容

    实现两个矩阵的相乘算法。

    实验要求

    1. 输入要求:矩阵大小阶数及元素值可以在程序中固定。但最好不固定矩阵形式,从键盘输入矩阵阶数以及元素值。
    2. 输出要求:在屏幕上显示矩阵相乘的结果。
    3. 严格按照要求的文件命名方式进行命名,如个人文档命名:实验1-班级-学号-名字.doc。
      当然,我们为了让用户更加便捷,我们增加了图片拖拽功能。

    问题描述

    使用C语言编写代码实现两个矩阵的相乘算法,并将结果输出。

    算法描述

    在这里插入图片描述

    代码

    #define true 1
    #define false 0
    #include <malloc.h>
    #include <stdio.h>
    
    int IsAvailable(int line[], int column[]);                                                                     //判断两个矩阵是否可相乘
    void input(double *matrix, int line, int column);                                                              //输入矩阵
    void output(double *matrix1, int line1, int column1, double *matrix2, int line2, int column2, double *matrix); //输出矩阵
    int main()
    {
        int line[2], column[2];
        do
        {
            printf("请输入矩阵A的行数和列数,输入完成后请换行以录入系统。\n");
            scanf("%d%d", &line[0], &column[0]);
            double *matrix1 = (double *)malloc(line[0] * column[0] * sizeof(double)); //利用一维数组模拟二维数组
            printf("请输入矩阵A的元素,每行的元素以空格隔开,输入完每行数据后换行输入下一行\n");
            input(matrix1, line[0], column[0]);
            printf("请输入矩阵B的行数和列数,输入完成后请换行以录入系统。\n");
            scanf("%d%d", &line[1], &column[1]);
            double *matrix2 = (double *)malloc(line[1] * column[1] * sizeof(double)); //利用一维数组模拟二维数组
            printf("请输入矩阵B的元素,每行的元素以空格隔开,输入完每行数据后换行输入下一行\n");
            input(matrix2, line[1], column[1]);
            if (IsAvailable(line, column) == false)
            {
                free(matrix1);
                free(matrix2);
                continue;
            }
    
            double *matrix = (double *)malloc(line[0] * column[1] * sizeof(double)); //矩阵乘积行数和矩阵A相同,列数和矩阵B相同
            output(matrix1, line[0], column[0], matrix2, line[1], column[1], matrix);
            free(matrix1);
            free(matrix2);
            free(matrix);
            system("pause");
            return 0;
        } while (1);
    }
    
    
    int IsAvailable(int line[], int column[])
    {
        if (column[0] != line[1])
        {
            printf("矩阵A的列数不等于矩阵B的行数,无法进行相乘,请按任意键重新输入!\n");
            system("pause");
            return false;
        }
        else
            return true;
    }
    void input(double *matrix, int line, int column)  
    {
        for (int i = 0; i < line; ++i)
        {
            for (int j = 0; j < column; ++j)
            {
                scanf("%lf", &matrix[i * column + j]);
            }
        }
    }
    void output(double *matrix1, int line1, int column1, double *matrix2, int line2, int column2, double *matrix)  
    {
        int line = line1;
        int column = column2;
        printf("矩阵A*矩阵B=\n");
        for (int i = 0; i < line; ++i)
        {
            for (int j = 0; j < column; ++j)
            {
                matrix[i * column + j] = 0;
                for (int k = 0; k < column1; ++k)
                {
                    matrix[i * column + j] += matrix1[i * column1 + k] * matrix2[k * column2 + j];
                }
                printf("%lf ", matrix[i * column + j]);
            }
            printf("\n");
        }
        printf("程序执行完毕。\n");
    }
    
    
    展开全文
  • strassen矩阵相乘算法c++代码,可以计算算法速度。
  • 基于MapReduce的矩阵相乘算法代码及其使用
  • 发布于2012.11.26,作者Stoimen引言Strassen的矩阵相乘方法是一种典型的分治算法。目前为止,我们已经见过一些分治策略的算法了,例如归并排序和Karatsuba大数快速乘法。现在,让我再来看看分治策略的背后是什么。同...

    发布于2012.11.26,作者Stoimen

    引言

    Strassen的矩阵相乘方法是一种典型的分治算法。目前为止,我们已经见过一些分治策略的算法了,例如归并排序和Karatsuba大数快速乘法。现在,让我再来看看分治策略的背后是什么。

    同动态规划不同,在动态规划中,为了得到最终的解决方案,我们经常需要把一个大的问题“展开”为几个子问题,但是这里,我们会更多的谈到如何把一些子解决方案组合到一起。这些子问题的解决方案是对等的,他们的归并方式也是通过某种方式定义好的。

    一个典型的例子就是归并排序算法。在归并排序中,我们有两个有序数组,我们想要这两个数组在合并之后仍然保持有序。当然了,在归并排序中,最复杂的部分当属自我合并,而原因在于,我们不得不传递两个数组,A和B,然后去比较每一“对”分别来自数组A和数组B的元素。有一点离题,但是,这是归并排序的一个弱点,虽然,它的最坏情况的时间复杂度是 O(n.log(n)),但是,快速排序却往往是实践中更为有效的排序方法,因为,它没有“合并”的过程。快速排序仅仅把两个子数组连接到一起,请注意,在快速排序中,子数组一般并不具有相同的长度,虽然他的最坏时间复杂度是O(n^2),但它的性能却经常好于归并排序。

    在上文中,那个简单的例子告诉我们:有时候如何合并两个子问题并不是一个简单的事情。因此,当我们使用分治策略的时候,我们必须非常谨慎。

    历史

    Volker Strassen是一位出生于1936年的德国数学家。他因为在概率论上的工作而广为人知,但是在计算机科学和算法领域,他却因为矩阵相乘算法而被大部分人认识,这个算法目前仍然是比通用矩阵相乘算法性能好的主要算法之一。

    Strassen在1969年第一次发表关于这个算法的文章,并证明了复杂度为n^3的算法并不是最优算法。实际上,Strassen给出的解决方案只是更好一点点,但是,他的贡献却是巨大的,因为他的工作触发了矩阵相乘领域更多的研究,比如复杂度为O(n^2,3737)的Coppersmith-Winograd算法。

    概述

    两个矩阵 A[NxN] 和 B[NxN] 相乘的通用算法是非常简单的。虽然矩阵相乘比两个数字相乘要复杂得多,而且也不满足交换律,但它仍然非常简单——同时也很慢。

    让我们先来定义一下什么是A[NxN]矩阵。因为我们要说下NxN矩阵,让我们先想象一个有N行N列的方格网。在每一行和每一列的A[i][j],我们都有一个值。

    当然,作为一个开发者,我们可以把一个矩阵看成一个二维数组。

    // PHP two-dimensional array

    $a = array(

    0 => array($v1, $v2, $v3, $v4),

    1 => array($v5, $v6, $v7, $v8),

    2 => array($v9, $v10, $v11, $v12),

    );

    不要忘记,一个NxN的矩阵仅仅是矩阵中的一种情况,同样的,我们可以有其他任何大小的NxM阶矩阵(N <> M)。

    然而,为了和另外的矩阵相乘,矩阵的大小是非常重要的,为什么?

    正如我上面提到的一样,矩阵相乘和数字相乘并不一样。首先,这个操作并不满足交换律。

    第二个问题是,你用来相乘A和B的方法。

    仅仅因为这种方法只对NxN阶矩阵有效,因此我们能看到把矩形矩阵相乘产生的问题。确实,这是不可能的,除非A矩阵的第二维和B矩阵的第一维相等。

    不过好在我们现在正在讨论的是具有相同维数的方形矩阵。

    好的,现在我们知道如何把两个方形矩阵相乘了(具有相同维数NxN),现在,让我们一起去估算一下通用矩阵相乘算法的时间复杂度。

    我们知道A.B = C,当且仅当:

    C[i][j] = sum(A[i][k] * B[k][j]) for k = 0 .. n

    于是,我们有一个n^3复杂度的操作。现在,让我们尽力找一个分治策略的算法。

    这个对于矩阵来说确实并不难,因为我们知道,一个矩阵可以被分成很多更小的子矩阵。

    现在,我们有什么?

    再一次——同样的时间复杂度——我们有了8个乘积和4个和,那么,计算量在哪?

    当然, 为了得到更快的解决方案,我们不得不看一下Strassen在1969做过的工作。他如下图定义了P1, P2, P3, P4, P5, P6 和 P7。

    时间复杂度

    正如我以上提到的,Strassen算法仅仅比通用矩阵相乘算法好一点点。通用矩阵相乘算法时间复杂度是O(n^3),然而Strassen算法复杂度则是O(n^2.80)。

    你能在下图观察到,随着n的变大,Strassen算法是如何比通用矩阵相乘算法变得更有效率的。

    应用

    虽然这个算法看起来更接近纯数学领域,而不是计算机领域。但在实际应用中,任何用到NxN数组的地方,我们都可以从矩阵相乘算法中获益。

    另一方面,Strassen算法并不比n^3复杂度的通用矩阵相乘算法快很多。这很重要,因为对于一个很小的n(通常n<45)来说,通用矩阵相乘算法在实践中往往是更好的选择。然而,你可以从以上的图片中看到,对于n>100的情况来说,这两个算法的差别还是相当大的。

    同时,当我们谈到|V| = n的邻接矩阵,以及一些依赖矩阵相乘的图论算法的时候,NxN数组经常会在这些领域中使用。

    展开全文
  • 两个矩阵相乘算法

    2018-03-19 11:55:00
    两个矩阵相乘算法 本来是处理两个矩阵的连乘求如何加括号使得中间的运算次数最少的问题,但是突然想到实现一下如何求连个矩阵连乘的算法,就实现了一下,挺简单的: 注意程序围绕的思想: 1.两个矩阵相乘,前一...

    本来是处理两个矩阵的连乘求如何加括号使得中间的运算次数最少的问题,但是突然想到实现一下如何求连个矩阵连乘的算法,就实现了一下,挺简单的:

    注意程序围绕的思想:
    1.两个矩阵相乘,前一个矩阵的列等于一个矩阵的行
    2.拿前一个矩阵的每一行,依次的乘以后一个矩阵的每一列
    [cpp] view plain copy

        #include  
        //注意矩阵连乘需要满足的是:  
        //前一个矩阵的列等于后一个矩阵的行   
        using namespace std;  
        int main(){  
            int a[3][1] = {  
            {1},  
            {2},  
            {3}  
            };  
            int b[1][3] = {{1,2,3}};  
            int c[3][3];  
            int temp;  
            for (int i=0; i<3; i ){ //拿出数组a的每一行   
                for (int z=0; z<3; z ){ //分别和数组b的每一列进行相乘  
                    int sum = 0;  //因为每次乘以数组a的每一列都会产生数组c中的一个元素,所以sum要放在这里   
                    for(int j=0; j<1; j ){  
                        sum = a[i][j] * b[j][z];  
                    }  
                    c[i][z] = sum;    
                }   
            }   
              
            for (int i=0; i<3; i ){  
                for (int j=0; j<3; j )  

    转载于:https://www.cnblogs.com/amengduo/p/9586511.html

    展开全文
  • 所以决定研究一下Strassen矩阵相乘算法,由于本人比较懒,所以就从网上找了一些相关的资料供大家参考; 下面内容均转自https://i.cnblogs.com/EditPosts.aspx?opt=1请尊重版权,支持原创。 题目描述 ...
  • Program:多线程矩阵相乘算法的设计 Description:利用多线程实现矩阵相乘,因为各个线程的运算互不影响,  所以不用使用锁,代码如下: thread.OperateMatrix类,实现矩阵运算 1 /* 2 * Description:...
  • 使用MapReduce方式实现矩阵相乘算法,支持map输出切分。附有代码,注释完善。
  • 矩阵相乘算法java.doc

    2020-10-28 01:16:15
    PAGE / NUMPAGES package dijkstradata; public class TestArrays { public static void main(String []args){ int[][] a=new int[3][3]; int[][] b=new int[3][3]; int[][] c=new int[3][3]; //循环出两个二维数组...
  • I've been trying to figure out the algorithm behind NumPy's matrix multiplication for complex numbers:import numpy as npA = np.array([[17.+0.j, -3.+0.j],[-7.+0.j, 1.+0.j]])B = np.array([[ 60.+0.j, -.....
  • 我们所要介绍的斯特拉森矩阵相乘算法是德国数学家沃尔克·施特拉森(Volker Strassen)于1969年提出的,该算法的主要思想是一种分治思想,即将一个2n的方阵分解成4个2n-1的小方阵。 借助这种办法,任何有穷方阵都可以...
  • Strassen矩阵相乘算法

    千次阅读 2015-08-17 20:04:48
    引言Strassen的矩阵相乘方法是一种典型的分治算法。目前为止,我们已经见过一些分治策略的算法了,例如归并排序和Karatsuba大数快速乘法。现在,让我再来看看分治策略的背后是什么。同动态规划不同,在动态规划中,...
  • 矩阵相乘算法代码

    2016-09-25 16:48:27
    * 矩阵相乘函数(MResult = MOrigin1 * MOrigin2),参数说明: * MOrigin1 - 原始矩阵1,以一维数组形式存储,m行n列 * MOrigin2 - 原始矩阵2,以一维数组形式存储,n行l列 * MResult - 相乘后矩阵,以一维数组...
  • 特斯拉森算法快速矩阵相乘算法

    千次阅读 2018-03-15 11:44:19
    特斯拉森算法快速矩阵相乘:讲八次乘法简化为七次n^2.81远小于n^3.http://blog.csdn.net/ljn393124204/article/details/17149153
  • 稀疏矩阵的三元组顺序表存储及矩阵相乘算法小结 转载自:http://blog.csdn.net/qiaoruozhuo)   一:稀疏矩阵的三元组顺序表数据结构  typedef int ElemType; typedef struct { intx, y; //该非零...
  • 矩阵相乘算法#########

    2011-04-09 10:08:40
    矩阵相乘矩阵相乘矩阵矩矩阵相乘阵相乘矩阵相乘相乘
  • 算法作业题目,用Strassen算法矩阵相乘问题,C++源代码,可运行
  • 矩阵相乘大家应该都不陌生。 设有两个矩阵M和N,假设M和N都是方阵,维度均为width × width 如果M和N均为1000 × 1000的矩阵,总共要进行1000000次点乘。其中,每次点乘有1000次乘法和1000次加法。 Matirx Multiply...
  • I want to multiply a sparse matrix A, with a matrix B which has 0, -1, or 1 as elements. To reduce the complexity of the matrix multiplication, I can ignore items if they are 0, or go ahead and add th...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,440
精华内容 576
关键字:

矩阵相乘算法