算法导论02--矩阵乘法

已于 2022-06-24 16:38:53 修改
阅读量619 收藏 2
点赞数
分类专栏： 算法导论 文章标签： 算法 矩阵 线性代数
于 2021-11-12 16:03:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45975575/article/details/121289780
版权
本文探讨了Strassen算法在矩阵乘法中的应用，通过编程实现了普通矩阵乘法和Strassen算法，并在不同数据规模下比较了两者的运行时间。实验显示，Strassen算法在大尺寸矩阵中可能提供更快的计算速度。此外，还提出了针对非2的幂次矩阵的Strassen算法改进方案，并进行了性能分析。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、目的

1．熟悉算法设计的基本思想
2．掌握Strassen算法的基本思想，并且能够分析算法性能

二、内容与设计思想

  1. 设计一个随机数矩阵生成器，输入参数包括N, s, t；可随机生成一个大小为N*N、数值范围在[s, t]之间的矩阵。
  2. 编程实现普通的矩阵乘法；
  3. 编程实现Strassen’s algorithm；
  4. 在不同数据规模情况下（数据规模N=2^4, 2^8, 2^9, 2^10, 2^11）下，两种算法的运行时间各是多少；
  5. 思考题：修改Strassen’s algorithm，使之适应矩阵规模N不是2的幂的情况；
  6. 改进后的算法与2中的算法在相同数据规模下进行比较。

三、使用环境

推荐使用C/C++集成编译环境。

四、实验过程

1、写出矩阵生成器和算法的源代码；

//（1）
#include<bits/stdc++.h>
using namespace std;
 
int Strassen(int n, int** MatrixA, int ** MatrixB, int ** MatrixC);
int ADD(int** MatrixA, int** MatrixB, int** MatrixResult, int length );
int SUB(int** MatrixA, int** MatrixB, int** MatrixResult, int length );
int MUL(int** MatrixA, int** MatrixB, int** MatrixResult, int length );
void FillMatrix( int** matrix1, int** matrix2, int length);
int main()
{
 
    int MatrixSize = 0;
 
    int** MatrixA;
    int** MatrixB;
    int** MatrixC;
 
    srand(time(0));

	cout<<"Please Enter your Matrix Size: ";
    cin>>MatrixSize;
 
    int N = MatrixSize;
 
 
    MatrixA = new int *[MatrixSize];
    MatrixB = new int *[MatrixSize];
    MatrixC = new int *[MatrixSize];
 
    for (int i = 0; i < MatrixSize; i++)
    {
        MatrixA[i] = new int [MatrixSize];
        MatrixB[i] = new int [MatrixSize];
        MatrixC[i] = new int [MatrixSize];
    }
 
    FillMatrix(MatrixA,MatrixB,MatrixSize);
 
    clock_t startTime2,endTime2;
	startTime2 = clock();
    
    Strassen( N, MatrixA, MatrixB, MatrixC );
    
    endTime2 = clock();
    cout << "The run time is:" <<(double)(1000*(endTime2 - startTime2) / CLOCKS_PER_SEC) << "ms" << endl; 

    return 0;
 
}

int Strassen(int N, int **MatrixA, int **MatrixB, int **MatrixC)
{
 
    int HalfSize = N/2;
    int newSize = N/2;

    if ( N <= 32 )
    {
        MUL(MatrixA,MatrixB,MatrixC,N);
    }
    else
    {
		int** A11;
		int** A12;
		int** A21;
		int** A22;
	
		int** B11;
		int** B12;
		int** B21;
		int** B22;
	
		int** C11;
		int** C12;
		int** C21;
		int** C22;
	
		int** M1;
		int** M2;
		int** M3;
		int** M4;
		int** M5;
		int** M6;
		int** M7;
		int** AResult;
		int** BResult;

		A11 = new int *[newSize];
		A12 = new int *[newSize];
		A21 = new int *[newSize];
		A22 = new int *[newSize];
	
		B11 = new int *[newSize];
		B12 = new int *[newSize];
		B21 = new int *[newSize];
		B22 = new int *[newSize];
	
		C11 = new int *[newSize];
		C12 = new int *[newSize];
		C21 = new int *[newSize];
		C22 = new int *[newSize];
	
		M1 = new int *[newSize];
		M2 = new int *[newSize];
		M3 = new int *[newSize];
		M4 = new int *[newSize];
		M5 = new int *[newSize];
		M6 = new int *[newSize];
		M7 = new int *[newSize];
	
		AResult = new int *[newSize];
		BResult = new int *[newSize];
	
		int newLength = newSize;

		for ( int i = 0; i < newSize; i++)
		{
			A11[i] = new int[newLength];
			A12[i] = new int[newLength];
			A21[i] = new int[newLength];
			A22[i] = new int[newLength];
	
			B11[i] = new int[newLength];
			B12[i] = new int[newLength];
			B21[i] = new int[newLength];
			B22[i] = new int[newLength];
	
			C11[i] = new int[newLength];
			C12[i] = new int[newLength];
			C21[i] = new int[newLength];
			C22[i] = new int[newLength];
	
			M1[i] = new int[newLength];
			M2[i] = new int[newLength];
			M3[i] = new int[newLength];
			M4[i] = new int[newLength];
			M5[i] = new int[newLength];
			M6[i] = new int[newLength];
			M7[i] = new int[newLength];
	
			AResult[i] = new int[newLength];
			BResult[i] = new int[newLength];
	
	
		}

	    for (int i = 0; i < N / 2; i++)
	    {
	        for (int j = 0; j < N / 2; j++)
	        {
	            A11[i][j] = MatrixA[i][j];
	            A12[i][j] = MatrixA[i][j + N / 2];
	            A21[i][j] = MatrixA[i + N / 2][j];
	            A22[i][j] = MatrixA[i + N / 2][j + N / 2];
	
	            B11[i][j] = MatrixB[i][j];
	            B12[i][j] = MatrixB[i][j + N / 2];
	            B21[i][j] = MatrixB[i + N / 2][j];
	            B22[i][j] = MatrixB[i + N / 2][j + N / 2];
	
	        }
	    }

	    ADD( A11,A22,AResult, HalfSize);
	    ADD( B11,B22,BResult, HalfSize);
	    Strassen( HalfSize, AResult, BResult, M1 ); 

	    ADD( A21,A22,AResult, HalfSize);       
	    Strassen(HalfSize, AResult, B11, M2);      

	    SUB( B12,B22,BResult, HalfSize);        
	    Strassen(HalfSize, A11, BResult, M3);     

	    SUB( B21, B11, BResult, HalfSize);      
	    Strassen(HalfSize, A22, BResult, M4);       

	    ADD( A11, A12, AResult, HalfSize);         
	    Strassen(HalfSize, AResult, B22, M5);       

	    SUB( A21, A11, AResult, HalfSize);
	    ADD( B11, B12, BResult, HalfSize);           
	    Strassen( HalfSize, AResult, BResult, M6);   

	    SUB(A12, A22, AResult, HalfSize);
	    ADD(B21, B22, BResult, HalfSize);           
	    Strassen(HalfSize, AResult, BResult, M7);     

	    ADD( M1, M4, AResult, HalfSize);
	    SUB( M7, M5, BResult, HalfSize);
	    ADD( AResult, BResult, C11, HalfSize);

	    ADD( M3, M5, C12, HalfSize);

	    ADD( M2, M4, C21, HalfSize);

	    ADD( M1, M3, AResult, HalfSize);
	    SUB( M6, M2, BResult, HalfSize);
	    ADD( AResult, BResult, C22, HalfSize);
	
	    for (int i = 0; i < N/2 ; i++)
	    {
	        for (int j = 0 ; j < N/2 ; j++)
	        {
	            MatrixC[i][j] = C11[i][j];
	            MatrixC[i][j + N / 2] = C12[i][j];
	            MatrixC[i + N / 2][j] = C21[i][j];
	            MatrixC[i + N / 2][j + N / 2] = C22[i][j];
	        }
	    }
	
		for (int i = 0; i < newLength; i++)
		{
			delete[] A11[i];delete[] A12[i];delete[] A21[i];
			delete[] A22[i];
	
			delete[] B11[i];delete[] B12[i];delete[] B21[i];
			delete[] B22[i];
			delete[] C11[i];delete[] C12[i];delete[] C21[i];
			delete[] C22[i];
			delete[] M1[i];delete[] M2[i];delete[] M3[i];delete[] M4[i];
			delete[] M5[i];delete[] M6[i];delete[] M7[i];
			delete[] AResult[i];delete[] BResult[i] ;
		}
			delete[] A11;delete[] A12;delete[] A21;delete[] A22;
			delete[] B11;delete[] B12;delete[] B21;delete[] B22;
			delete[] C11;delete[] C12;delete[] C21;delete[] C22;
			delete[] M1;delete[] M2;delete[] M3;delete[] M4;delete[] M5;
			delete[] M6;delete[] M7;
			delete[] AResult;
			delete[] BResult ;
 	}

	return 0;
}
 
int ADD(int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] + MatrixB[i][j];
        }
    }
	return 0;
}
 
int SUB(int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] - MatrixB[i][j];
        }
    }
	return 0;
}

int MUL( int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixSize )
{
    for (int i=0;i<MatrixSize ;i++)
    {
          for (int j=0;j<MatrixSize ;j++)
          {
               MatrixResult[i][j]=0;
               for (int k=0;k<MatrixSize ;k++)
               {
                      MatrixResult[i][j]=MatrixResult[i][j]+MatrixA[i][k]*MatrixB[k][j];
               }
          }
    }
	return 0;
}
 
void FillMatrix( int** MatrixA, int** MatrixB, int length)
{
    for(int row = 0; row<length; row++)
    {
        for(int column = 0; column<length; column++)
        {
 
           MatrixB[row][column] = (MatrixA[row][column] = rand() %5);
        }
 
    }
}


//（2）
#include<bits/stdc++.h>
using namespace std;
 
int Strassen(int n, int** MatrixA, int ** MatrixB, int ** MatrixC);
int ADD(int** MatrixA, int** MatrixB, int** MatrixResult, int length );
int SUB(int** MatrixA, int** MatrixB, int** MatrixResult, int length );
int MUL(int** MatrixA, int** MatrixB, int** MatrixResult, int length );
void FillMatrix( int** matrix1, int** matrix2, int length, int t);
int main()
{
 
    int MatrixSize = 0;
    int t,MatrixSize0;
 
    int** MatrixA;
    int** MatrixB;
    int** MatrixC;
 
    srand(time(0));

	cout<<"Please Enter your Matrix Size: ";
    cin>>MatrixSize0;
    if (MatrixSize0%2==0)
    {
    	MatrixSize=MatrixSize0;
    	t=0;
	}
	else
	{
		MatrixSize = (MatrixSize0/2+1)*2;
		t = MatrixSize - MatrixSize0;
	}
 
    int N = MatrixSize;
 
 
    MatrixA = new int *[MatrixSize];
    MatrixB = new int *[MatrixSize];
    MatrixC = new int *[MatrixSize];
 
    for (int i = 0; i < MatrixSize; i++)
    {
        MatrixA[i] = new int [MatrixSize];
        MatrixB[i] = new int [MatrixSize];
        MatrixC[i] = new int [MatrixSize];
    }
 
    FillMatrix(MatrixA,MatrixB,MatrixSize,t);
 
    clock_t startTime,endTime;
	startTime = clock();
    
    Strassen( N, MatrixA, MatrixB, MatrixC );
    
    endTime = clock();
    cout << "The run time is:" <<(double)(1000*(endTime - startTime) / CLOCKS_PER_SEC) << "ms" << endl; 

    return 0;
 
}

int Strassen(int N, int **MatrixA, int **MatrixB, int **MatrixC)
{
 
    int HalfSize = N/2;
    int newSize = N/2;

    if ( N <= 32 )
    {
        MUL(MatrixA,MatrixB,MatrixC,N);
    }
    else
    {
		int** A11;
		int** A12;
		int** A21;
		int** A22;
	
		int** B11;
		int** B12;
		int** B21;
		int** B22;
	
		int** C11;
		int** C12;
		int** C21;
		int** C22;
	
		int** M1;
		int** M2;
		int** M3;
		int** M4;
		int** M5;
		int** M6;
		int** M7;
		int** AResult;
		int** BResult;

		A11 = new int *[newSize];
		A12 = new int *[newSize];
		A21 = new int *[newSize];
		A22 = new int *[newSize];
	
		B11 = new int *[newSize];
		B12 = new int *[newSize];
		B21 = new int *[newSize];
		B22 = new int *[newSize];
	
		C11 = new int *[newSize];
		C12 = new int *[newSize];
		C21 = new int *[newSize];
		C22 = new int *[newSize];
	
		M1 = new int *[newSize];
		M2 = new int *[newSize];
		M3 = new int *[newSize];
		M4 = new int *[newSize];
		M5 = new int *[newSize];
		M6 = new int *[newSize];
		M7 = new int *[newSize];
	
		AResult = new int *[newSize];
		BResult = new int *[newSize];
	
		int newLength = newSize;

		for ( int i = 0; i < newSize; i++)
		{
			A11[i] = new int[newLength];
			A12[i] = new int[newLength];
			A21[i] = new int[newLength];
			A22[i] = new int[newLength];
	
			B11[i] = new int[newLength];
			B12[i] = new int[newLength];
			B21[i] = new int[newLength];
			B22[i] = new int[newLength];
	
			C11[i] = new int[newLength];
			C12[i] = new int[newLength];
			C21[i] = new int[newLength];
			C22[i] = new int[newLength];
	
			M1[i] = new int[newLength];
			M2[i] = new int[newLength];
			M3[i] = new int[newLength];
			M4[i] = new int[newLength];
			M5[i] = new int[newLength];
			M6[i] = new int[newLength];
			M7[i] = new int[newLength];
	
			AResult[i] = new int[newLength];
			BResult[i] = new int[newLength];
	
	
		}

	    for (int i = 0; i < N / 2; i++)
	    {
	        for (int j = 0; j < N / 2; j++)
	        {
	            A11[i][j] = MatrixA[i][j];
	            A12[i][j] = MatrixA[i][j + N / 2];
	            A21[i][j] = MatrixA[i + N / 2][j];
	            A22[i][j] = MatrixA[i + N / 2][j + N / 2];
	
	            B11[i][j] = MatrixB[i][j];
	            B12[i][j] = MatrixB[i][j + N / 2];
	            B21[i][j] = MatrixB[i + N / 2][j];
	            B22[i][j] = MatrixB[i + N / 2][j + N / 2];
	
	        }
	    }

	    ADD( A11,A22,AResult, HalfSize);
	    ADD( B11,B22,BResult, HalfSize);
	    Strassen( HalfSize, AResult, BResult, M1 ); 

	    ADD( A21,A22,AResult, HalfSize);       
	    Strassen(HalfSize, AResult, B11, M2);      

	    SUB( B12,B22,BResult, HalfSize);        
	    Strassen(HalfSize, A11, BResult, M3);     

	    SUB( B21, B11, BResult, HalfSize);      
	    Strassen(HalfSize, A22, BResult, M4);       

	    ADD( A11, A12, AResult, HalfSize);         
	    Strassen(HalfSize, AResult, B22, M5);       

	    SUB( A21, A11, AResult, HalfSize);
	    ADD( B11, B12, BResult, HalfSize);           
	    Strassen( HalfSize, AResult, BResult, M6);   

	    SUB(A12, A22, AResult, HalfSize);
	    ADD(B21, B22, BResult, HalfSize);           
	    Strassen(HalfSize, AResult, BResult, M7);     

	    ADD( M1, M4, AResult, HalfSize);
	    SUB( M7, M5, BResult, HalfSize);
	    ADD( AResult, BResult, C11, HalfSize);

	    ADD( M3, M5, C12, HalfSize);

	    ADD( M2, M4, C21, HalfSize);

	    ADD( M1, M3, AResult, HalfSize);
	    SUB( M6, M2, BResult, HalfSize);
	    ADD( AResult, BResult, C22, HalfSize);
	
	    for (int i = 0; i < N/2 ; i++)
	    {
	        for (int j = 0 ; j < N/2 ; j++)
	        {
	            MatrixC[i][j] = C11[i][j];
	            MatrixC[i][j + N / 2] = C12[i][j];
	            MatrixC[i + N / 2][j] = C21[i][j];
	            MatrixC[i + N / 2][j + N / 2] = C22[i][j];
	        }
	    }
	
		for (int i = 0; i < newLength; i++)
		{
			delete[] A11[i];delete[] A12[i];delete[] A21[i];
			delete[] A22[i];
	
			delete[] B11[i];delete[] B12[i];delete[] B21[i];
			delete[] B22[i];
			delete[] C11[i];delete[] C12[i];delete[] C21[i];
			delete[] C22[i];
			delete[] M1[i];delete[] M2[i];delete[] M3[i];delete[] M4[i];
			delete[] M5[i];delete[] M6[i];delete[] M7[i];
			delete[] AResult[i];delete[] BResult[i] ;
		}
			delete[] A11;delete[] A12;delete[] A21;delete[] A22;
			delete[] B11;delete[] B12;delete[] B21;delete[] B22;
			delete[] C11;delete[] C12;delete[] C21;delete[] C22;
			delete[] M1;delete[] M2;delete[] M3;delete[] M4;delete[] M5;
			delete[] M6;delete[] M7;
			delete[] AResult;
			delete[] BResult ;
 	}

	return 0;
}
 
int ADD(int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] + MatrixB[i][j];
        }
    }
	return 0;
}
 
int SUB(int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixSize )
{
    for ( int i = 0; i < MatrixSize; i++)
    {
        for ( int j = 0; j < MatrixSize; j++)
        {
            MatrixResult[i][j] =  MatrixA[i][j] - MatrixB[i][j];
        }
    }
	return 0;
}

int MUL( int** MatrixA, int** MatrixB, int** MatrixResult, int MatrixSize )
{
    for (int i=0;i<MatrixSize ;i++)
    {
          for (int j=0;j<MatrixSize ;j++)
          {
               MatrixResult[i][j]=0;
               for (int k=0;k<MatrixSize ;k++)
               {
                      MatrixResult[i][j]=MatrixResult[i][j]+MatrixA[i][k]*MatrixB[k][j];
               }
          }
    }
	return 0;
}
void FillMatrix( int** MatrixA, int** MatrixB, int length, int t)
{
	for(int row = 0; row<length-t; row++)
    {
        for(int column = 0; column<length-t; column++)
        {
           MatrixA[row][column] = rand() %5;
        }
    }
    
    for (int row = length-t; row<length; row++)
    {
    	for (int column = length-t; column<length; column++)
    	{
    		MatrixA[row][column] = 0;
		}
	}
}

2、分别画出各个实验结果的折线图，运行时间用自然对数处理

算法导论--------------Strassen矩阵乘法
chen
12-13 2123
由于看到 了动态规划来分析解决矩阵链乘的问题，所以回顾了一下矩阵乘法，发现这个知识点忘记的差不多了，现在再来总结一下。 首先我们知道两个矩阵相乘A*B，那么A的列数必须等于B的行数，否则不能进行相乘. 首先我们来回顾一下解决矩阵相乘问题的一般方法：利用三个for循环来解决，时间复杂度为o（n^3）。 矩阵乘法定义：      例如有两个n乘以n的矩阵A和B，C=A*B； 那么求C的
算法导论-基于 C# 的矩阵链乘法实现
最新发布
东城十三
06-24 301
矩阵链乘法是一个经典的动态规划问题，其目标是找到最优的矩阵乘法顺序，以使得计算矩阵乘积所需的标量乘法次数最少。本文介绍如何使用C#实现矩阵链乘法问题的动态规划解法。本文介绍了如何在C#中实现矩阵链乘法问题的动态规划解法。通过定义子问题、构建状态转移方程和自底向上求解，能够高效地找到最优的矩阵乘法顺序，从而最小化标量乘法次数。这种方法在解决类似的优化问题中非常有用。
【算法导论】矩阵乘法
青峰碧陋室
02-11 2200
离过年都不到十天了，还要等到这周五才能回家，想想也一年没回家了。从寒假开始到现在，已经有二十来天，这期间把2014年总结中的寒假计划也大多数完成了：The Element Of Style的阅读，三门数学课《随机过程》、《工程优化》、《数值分析》的算法实现。回家过年期间肯定不会写博客了，今天一看，这个月只写了三篇，于是乎今天必须再写一篇来完成这个月的基本工作量。言归正传，这篇文章写写选修课《算法设
算法导论——矩阵相乘（一）
WaterWin的博客
11-09 776
矩阵的相乘，这个计算方法就直接看下面的源码实现： void mul_array(int a_array[][ARRAY_SIZE], int b_array[][ARRAY_SIZE], int c_array[][ARRAY_SIZE], int size){ for(int i = 0; i &lt; size; i++){ for(int j = 0; j &l...
算法导论之矩阵乘法
z444_579的博客
11-12 369
2. 矩阵乘法 void SqaureMatrixMutiply(float **A, float **B, float **C, int n) { for (int i=0; i<n; i++) { for (int j=0; j<n; j++) { C[i][j] = 0.0; for (int k=0; k<n; k++) { C[i][j]
《算法导论》——矩阵乘法Strassen算法
lost-person的博客
07-13 2861
《算法导论》——Strassen算法 矩阵乘法 接触过线性代数的读者，对于矩阵乘法想必一定不陌生。若A=(aij)A=(aij)A=(a_{ij})和B=(bij)B=(bij)B=(b_{ij})是n∗nn∗nn*n的方阵，则对i,j,…,ni,j,…,ni, j, \ldots, n，定义乘积C=A⋅BC=A⋅BC=A \cdot B中的元素cijcijc_{ij}为： cij=...
算法导论 矩阵乘法(简单分治)
苦海无涯闯进来
03-22 1232
1
算法导论15.2-1矩阵链最优括号化方案
11-27
算法导论第三版练习题15.2-2的C++实现方案
算法导论讲义--答案.rar
05-27
4. **动态规划**：用于解决复杂问题的优化策略，如背包问题、最长公共子序列、矩阵链乘法等。 5. **递归与分治**：如快速幂、归并排序、分治法求解汉诺塔等问题。 6. **贪心算法**：在每一步选择局部最优解，以期...
高性能计算导论实验1-通用矩阵乘法基于串行编程的实现及优化
05-07
高性能计算导论课程实验一，通用矩阵乘法基于串行编程的实现及优化，通用矩阵乘法，基于Strassen 算法和 Coppersmith–Winograd 算法等算法分析的方法对矩阵乘法进行优化， 基于软件优化的方法对矩阵乘法进行优化，...
共现矩阵生成器.zip
11-27
共现矩阵生成python实现 包括源代码和打包好的exe Co-occurrence_Matrix.exe 软件本体 data.csv 原始数据 上面让你准备的那个 node.csv 节点数据 (包含节点名称+词频数) edge.csv 节点关系的三元组存储形式存储(包含两两节点关系+关系频数) co_occurrence_matrix.csv 共现矩阵(稀疏矩阵形式)
简洁高效的数独矩阵生成器
12-24
最近看别人玩数独游戏，了解了游戏规则后，编写了一个简洁高效的数独矩阵生成器，可任意设值矩阵阶数，算法简洁高效，欢迎大家下载
矩阵生成工具（含源码）
06-08
可以生成M*N矩阵，用于一些特定需要标记的用途，使用MFC编写，界面操作简单直观，可以拖动显示矩阵
算法导论 矩阵乘法(自然定义法)
苦海无涯闯进来
03-22 328
#include #define LEN 2 void nativeMult(const int a[LEN][LEN],const int b[LEN][LEN],int c[LEN][LEN]) { for(int i=0;i<LEN;i++) { for(int j=0;j<LEN;j++) { c[i][j]=0; for(int k=0;k<LEN;k++)
《算法导论》第四章-矩阵乘法的Strassen算法（含C++代码）
Toby的博客
07-26 2720
本文为《算法导论》第四章-4.2-矩阵乘法的Strassen方法笔记，欢迎大家参考。
《算法导论》第四章矩阵相乘
xuqn0606的博客
08-13 393
1.采用递归分治的方法进行矩阵相乘，代码如下： def matrix_divide(mat): """将n*n分解为4个n/2*n/2的四个矩阵""" n = len(mat) / 2 a11 = [[0 for i in range(n)]for j in range(n)] a12 = [[0 for i in range(n)] for j in rang...
[算法导论]矩阵乘法的Strassen算法
A beginner's learning path
03-18 505
#include&lt;stdio.h&gt; #include&lt;iostream&gt; using namespace std; #define Length 3 int * MatrixMultiply(int numa[][Length], int numb[2][Length], int n);//直接计算 //void MatrixMultiplyRecursive(i...
《算法导论》学习（四）---- 矩阵乘法的Strassen（斯特拉森）算法
weixin_52042488的博客
08-29 5520
矩阵乘法可以采用分治的策略。这里提供了两个分治策略的解决n∗nn*nn∗n矩阵之间乘法的算法1.矩阵乘法的普通递归方法2.矩阵乘法的Strassen（斯特拉森）方法但是着两个方法的缺点是只能是两个n∗nn*nn∗n矩阵的乘法，同时n必须为2的幂之后也对这两个算法进行了时间复杂度上的分析。......
POJ 矩阵相乘 (随机化算法-舍伍德(Sherwood))
10-30 258
周三的算法课，主要讲了随机化算法，介绍了拉斯维加斯算法，简单的理解了为什么要用随机化算法，随机化算法有什么好处。 在处理8皇后问题的时候，穷举法是最费时的，回朔比穷举好点，而当数据量比较大的时候，如1000皇后问题，穷举的化有1000的1000次方，肯定超时，用随机化算法的思路，先随机的在棋盘上放一部分皇后，再来设计算法，会大大节省时间，使算法性能更加优良。 本篇介绍令一种随机化算法...
C++实现算法导论中的递归矩阵乘法
资源摘要信息:"本资源是一份关于C++实现的算法导论中的矩阵乘法的递归算法的学习笔记和代码示例。算法导论作为计算机科学领域的经典教材，被广泛应用于算法学习与教学之中。资源涵盖了算法导论第六版第四章的内容，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值