2. 程式人生 > >矩陣乘法的演算法實現 [轉載]

矩陣乘法的演算法實現 [轉載]

阿新 • • 發佈：2019-01-09

一般矩陣乘法演算法：

原理：矩陣相乘最重要的方法是一般矩陣乘積。它只有在第一個矩陣的欄數（column）和第二個矩陣的列數（row）相同時才有定義。一般單指矩陣乘積時，指的便是一般矩陣乘積。若A為m×n矩陣，B為n×p矩陣，則他們的乘積AB會是一個m×p矩陣。其乘積矩陣的元素如下面式子得出：

程式碼如下：

struct mat{
    int n, m;
    double data[MAXN][MAXN];
};

int mul(mat& c, const mat& a, const mat& b){
    int i, j, k;
    if (a.m != b.n)
        
 
return 0;
    c.n = a.n;
    c.m = b.m;
    for (i = 0; i < c.n; i++)
        for (j = 0; j < c.m; j++)
            for (c.data[i][j] = k = 0; k < a.m; k++)
                c.data[i][j] += a.data[i][k] * b.data[k][j];
    return 1;
}

時間複雜度：O(n3)

傳統分治方法：

C = AB

將A, B, C分成相等大小的方塊矩陣：

C11=A11

B11+A12B21                           (2)

C12=A11B12+A12B22                           (3)

C21=A21B11+A22B21                           (4)

C22=A21B12+A22B22                           (5)

     如果n=2，則2個2階方陣的乘積可以直接用(2)-(5)式計算出來，共需8次乘法和4次加法。當子矩陣的階大於2時，為求2個子矩陣的積，可以繼續將子矩陣分塊，直到子矩陣的階降為2。這樣，就產生了一個分治降階的遞迴

演算法。依此演算法，計算2個n階方陣的乘積轉化為計算8個n/2階方陣的乘積和4個n/2階方陣的加法。2個n/2×n/2矩陣的加法顯然可以在c*n2/4時間內完成，這裡c是一個常數。因此，上述分治法的計算時間耗費T(n)應該滿足：

T(2) = b

T(n) = 8T(n / 2) + cn2   (n > 2)

由上式可知：分治法的運用，方陣的乘法的演算法效率並沒有提高！

分治法的設計思想：將一個難以直接解決的大問題，分割成一些規模較小的相同問題，以便各個擊破，分而治之。

      任何一個可以用計算機求解的問題所需的計算時間都與其規模有關。問題的規模越小，越容易直接求解，解題所需的計算時間也越少。例如，對於n個元素的排。n=2時，只要作一次比較即可排好序。n=3時序問題，當n=1時，不需任何計算只要作3次比較即可，…。而當n較大時，問題就不那麼容易處理了。要想直接解決一個規模較大的問題，有時是相當困難的。

分治法所能解決的問題一般具有以下幾個特徵：

1.可縮性。問題的規模縮小到一定的程度就可以容易地解決；

2.最有子結構性。問題可以分解為若干個規模較小的相同問題；

3.可合性。利用該問題分解出的子問題的解可以合併為該問題的解；

4.獨立性。該問題所分解出的各個子問題是相互獨立的，即子問   題之間不包含公共的子子問題。

分治思想與遞迴就像一對孿生兄弟，經常同時應用在演算法設計中，並由此產生高效的演算法！

Strassen演算法

傳統方法2個2階方陣相乘需要8次乘法。按照上述分治法的思想可以看出，要想減少乘法運算次數，關鍵在於計算2個2階方陣的乘積時，能否用少於8次的乘法運算。Strassen提出了一種新的演算法來計算2個2階方陣的乘積。他的演算法只用了7次乘法運算，但增加了加、減法的運算次數。這7次乘法是:

M1=A11(B12-B22)                           

M2=(A11+A12)B22

M3=(A21+A22)B11

M4=A22(B21-B11)

M5=(A11+A22)(B11+B22)

M6=(A12-A22)(B21+B22)

M7=(A11-A21)(B11+B12)

做了7次乘法後，再做若干次加、減法：　

C11=M5+M4-M2+M6

C12=M1+M2

C21=M3+M4

C22=M5+M1-M3-M7

演算法效率分析:

Strassen矩陣乘積分治演算法中，用了7次對於n/2階矩陣乘積的遞迴呼叫和18次n/2階矩陣的加減運算。由此可知，該演算法的所需的計算時間T(n)滿足如下的遞迴方程:

T(2) = b

T(n) = 7T(n / 2) + cn2   (n > 2)

按照解遞迴方程的套用公式法，其解為T(n)=O(nlog7)≈O(n2.81)。由此可見，Strassen矩陣乘法的計算時間複雜性比普通矩陣乘法有階的改進。

資料的儲存結構：

二維陣列（弊端：必須巨集定義一常量N）

二重指標 （擺脫巨集定義的限制，但程式變得繁瑣）

原始矩陣:

A,B,C(C=AB)

分塊矩陣：

A11，A12，A21，A22(對方陣A分成四塊)

B11，B12，B21，B22(對方陣B分成四塊)

七塊關鍵陣：

M1，M2，M3，M4，M5，M6，M7

中間方陣：

 AA，BB(計算加法時作一個橋樑)

二級指標定義說明：

int **c;
    c = (int**)malloc(n * sizeof(int));
    for(int i = 0; i < n; i++)
        c[i] = (int *)malloc(n * sizeof(int));
兩矩陣相加問題: 
//矩陣加法：
void add(int n, int A[][N], int B[][N], int R[][N])
{ 
    int i, j;
    for(i = 0; i < n; i++)
        for(j = 0; j < n; j++)
            R[i][j] = A[i][j] + B[i][j];
}
兩矩陣相減問題: 
//矩陣減法：
void sub(int n,int A[][N],int B[][N],int R[][N])
{ 
    int i,j;
    for(i = 0; i < n; i++)
        for(j = 0; j < n; j++)
            R[i][j] = A[i][j] - B[i][j];
}
兩方陣相乘問題: 
//階為2的方陣相乘：
void multiply(int A[][N],int B[][N],int R[][N])
{   
    int M1 = A[0][1] * (B[0][1] - B[1][1]);
    int M2 = (A[0][0] + A[0][1]) * B[1][1];
    int M3 = (A[1][0] + A[1][1]) * B[0][0];
    int M4 = A[1][1] * (B[1][0] - B[0][0]);
    int M5 = (A[0][0] + A[1][1]) * (B[0][0] + B[1][1]);
    int M6 = (A[0][1] - A[1][1]) * (B[1][0] + B[1][1]);
    int M7 = (A[0][0] - A[1][0]) * (B[0][0] + B[0][1]);
    R[0][0] = M5 + M4 - M2 + M6;
    R[0][1] = M1 + M2;
    R[1][0] = M3 + M4;
    R[1][1] = M5 + M1 - M3 - M7;
}
將大的方陣劃分的問題 
//分塊函式
void divide(int A[][N], int n, int X11[][N], int X12[][N], int X21[][N], int X22[][N] )
{
    int i, j;
    for(i = 0; i < (n / 2); i++)
        for(j = 0; j < (n / 2); j++) {
            X11[i][j] = A[i][j];
            X12[i][j] = A[i][j + (n / 2)];
            X21[i][j] = A[i + (n / 2)][j];
            X22[i][j] = A[i + (n / 2)][j + (n / 2)];
        }
}
完整程式碼如下: 
#include<stdio.h>
#include<math.h>

#define N 4

//二階矩陣相乘
void Matrix_Multiply(int A[][N], int B[][N], int C[][N]) { 
     for(int i = 0; i < 2; i++) {  
        for(int j = 0; j < 2; j++) {  
           C[i][j] = 0;        
           for(int t = 0; t < 2; t++) {  
              C[i][j] = C[i][j] + A[i][t] * B[t][j];          
           }    
        }          
     }  
}  

//矩陣加法：
void add(int n, int A[][N], int B[][N], int R[][N])
{ 
    int i, j;
    for(i = 0; i < n; i++)
        for(j = 0; j < n; j++)
            R[i][j] = A[i][j] + B[i][j];
}

//矩陣減法：
void sub(int n, int A[][N], int B[][N], int R[][N])
{ 
    int i,j;
    for(i = 0; i < n; i++)
        for(j = 0; j < n; j++)
            R[i][j] = A[i][j] - B[i][j];
}
void strassen(int n, int A[][N], int B[][N], int C[][N])
{
    int i, j;
    int A11[N][N], A12[N][N], A21[N][N], A22[N][N];
    int B11[N][N], B12[N][N], B21[N][N], B22[N][N];
    int C11[N][N], C12[N][N], C21[N][N], C22[N][N];
    int AA[N][N], BB[N][N];
    int M1[N][N], M2[N][N], M3[N][N], M4[N][N], M5[N][N], M6[N][N], M7[N][N];
    if(n == 2) {
        Matrix_Multiply(A, B, C);
    } else {
        for(i = 0; i < n / 2; i++) {
            for(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];
            }
        }

        sub(n / 2, B12, B22, BB);
        strassen(n / 2, A11, BB, M1);

        add(n / 2, A11, A12, AA);
        strassen(n / 2, AA, B22, M2);

        add(n / 2, A21, A22, AA);
        strassen(n / 2, AA, B11, M3);

        sub(n / 2, B21, B11, BB);
        strassen(n / 2, A22, BB, M4);

        add(n / 2, A11, A22, AA);
        add(n / 2, B11, B22, BB);
        strassen(n / 2, AA, BB, M5);

        sub(n / 2, A12, A22, AA);
        add(n / 2, B21, B22, BB);
        strassen(n / 2, AA, BB, M6);

        sub(n / 2, A11, A21, AA);
        add(n / 2, B11, B12, BB);
        strassen(n / 2, AA, BB, M7);

        //C11 = M5 + M4 - M2 + M6
        add(n / 2, M5, M4, AA);
        sub(n / 2, M6, M2, BB);
        add(n / 2, AA, BB, C11);

        //C12 = M1 + M2
        add(n / 2, M1, M2, C12);

        //C21 = M3 + M4
        add(n / 2, M3, M4, C21);

        //C22 = M5 + M1 - M3 - M7
        sub(n / 2, M5, M3, AA);
        sub(n / 2, M1, M7, BB);
        add(n / 2, AA, BB, C22);

         for(i = 0; i < n / 2; i++) {  
           for(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];          
           }          
        } 
    }
}

int main(void)
{
    int A[N][N], B[N][N], C[N][N];
    printf("input A: \n");
    for(int i = 0; i < N; i++)
        for(int j = 0; j < N; j++)
            scanf("%d", &A[i][j]);
    printf("input B: \n");
    for(int i = 0; i < N; i++)
        for(int j = 0; j < N; j++)
            scanf("%d", &B[i][j]);
    strassen(N, A, B, C);
    printf("C:\n");
    for(int i = 0; i < N; i++)
        for(int j = 0; j < N; j++) {
            printf("%d ", C[i][j]);
            if(j > 0 && j % 
            
  

           

              
              

            

            
相關推薦

			   
            
            
            
 

    


    
    
[資料結構]稀疏矩陣乘法演算法實現

     
 
                作者zhonglihao演算法名稀疏矩陣乘法 Sparse Matrix Multiplication分類資料結構複雜度O(n^2)形式與資料結構C++程式碼 一維結構體儲存特性極簡封裝 不使用連結串列 不需要轉置 計算過程容易理解具體參考出處《演算法導論》(寫的不想看)備註 



  
 

    


    
    
[線性代數]矩陣乘法演算法實現

     
 
                作者zhonglihao    演算法名矩陣乘法 Matrix Multiplication分類線性代數複雜度n^3形式與資料結構C++實現 一維陣列儲存特性指標封裝返回具體參考出處 教科書備註// ConsoleApplication1.cpp : 定義控制檯應用程式的入口 



  
 

    


    
    
矩陣乘法的演算法實現 [轉載]

     
 
                

一般矩陣乘法演算法：

原理：矩陣相乘最重要的方法是一般矩陣乘積。它只有在第一個矩陣的欄數（column）和第二個矩陣的列數（row）相同時才有定義。一般單指矩陣乘積時，指的便是一般矩陣乘積。若A為m×n矩陣，B為n×p矩陣，則他們的乘積AB會是一個m×p矩陣。其乘積矩陣 



  
 

    


    
    
感知機PLA演算法實現[轉載]

     
 轉自:https://blog.csdn.net/u010626937/article/details/72896144#commentBox 
1.實現原始形式 
 
 import numpy as np
import matplotlib.pyplot as plt

#1、建立資料集
def crea 



  
 

    


    
    
矩陣基礎演算法實現

     
 
                
       最近花了一段時間去溫習矩陣的基礎演算法，要去敲程式碼的時候才發現原來以前的線性程式碼全都白學了，沒有去用沒有去實現的結果就等於什麼都沒用。
       自己為了練習實現了一些矩陣的基礎演算法，算是一個溫習，一條條羅列下來。其中我的矩陣資料為浮點數格式，0這樣 



  
 

    


    
    
C語言之兩矩陣乘法的實現

     
 
							
							
							首先我們要清楚矩陣乘法實現需要滿足的條件， 矩陣相乘最重要的方法是一般矩陣乘積。它只有在第一個矩陣的列數（column）和第二個矩陣的行數（row）相同時才有意義[1]  。一般單指矩陣乘積時，指的便是一般矩陣乘積。一個m×n的矩陣就是m×n個數排成m行n列的一 



  
 

    


    
    
高斯約當法求逆矩陣的演算法實現（C++）

     
 
                
#include"iostream.h"
#include"math.h"
void main()
{
float a[10][10],A[10][10],b[10],c[10][10],d=0,f=0;
int i=0,j=0,k=1,l=0,m=0,n=0;
//--- 



  
 

    


    
    
MPI實現矩陣乘法程式--實現MPI傳遞連續陣列

     
 
                
怎麼樣用用MPI編寫兩個n階的方陣A和B的相乘程式，結果存放在方陣C中，A、B和C都在節點0中呢？


//#include<stdio.h>
//#include<math.h>
//#pragma comment(lib,"mpi.lib")
# 



  
 

    


    
    
轉置矩陣的分塊並行乘法（C語言實現），計算矩陣C[rawn][rawn]=A[rawm][rawn]'*B[rawm][rawn]，子塊大小為S*T，其演算法實現原理參加本程式碼的附件。

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

#define rawm 4
#define rawn 4
#defi 



  
 

    


    
    
分治法實現矩陣乘法

     
 name   cout   namespace   size   cas   put   分治   ade   add   整體的思路就是分，加&乘，拼

#include <iostream>
#include <cstddef>
#include <cstdlib&g 



  
 

    


    
    
藍書（演算法競賽進階指南）刷題記錄——POJ3613 Cow Replays（最短路+矩陣乘法）

     
  
 
 
 題目：POJ3613. 
 題目大意：給出一張圖，然你求出經過N條邊後，S到T的最短路. 
 這道題一開始覺得挺容易的，用f[i][j]表示從起點到點i經過j的最短路，不斷更新就可以了. 
 但是突然發現數據巨大根本跑不過去... 
 然後就開始看書上的題解了... 
 書上居然要用矩陣乘法，好 



  
 

    


    
    
用C語言實現最小二乘法演算法

     
  
  
  
 分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow
 
 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！
 
 
          



  
 

    


    
    
Kruskal演算法實現最小生成樹（鄰接矩陣儲存圖）

     
  
  
  
 程式碼如下： #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 
 typedef struct { int u; int v; int w; 
 }Edges; 
 void Bubblesort( 



  
 

    


    
    
Prim演算法實現最小生成樹（鄰接矩陣儲存圖）

     
  
  
  
 程式碼如下 #include <stdio.h> #include <stdlib.h> #define MAXSIZE 100 
 typedef struct { int vertex[MAXSIZE]; int edges[MAXSIZE][MAXSIZE];  



  
 

    


    
    
GIS演算法基礎（四）平面座標變換（變換矩陣演算法實現）

     
  
 
 目錄 
 一、平面直角座標系的建立 
 二、平面座標變換矩陣 
 三、平移變換 
 四、比例變換 
 五、對稱變換 
 六、旋轉變換 
 七、錯切變換 
 八、複合變換 
 (1)、複合平移 
 （2）複合比例變換 
 （3）複合旋轉 
 （4）相對某點的比例變換 
 （5）相對某點的選址變換 
  



  
 

    


    
    
java實現兩個矩陣乘法 有個錯誤希望有大佬幫忙

     
  
  
  
 //java實現兩個矩陣相乘  有個錯誤在下邊  有沒有哪個大佬幫我看看  十分感謝

package 實驗五;

import java.util.Scanner;

public class Matrix {
	private int rows;
	private int cols;
	 



  
 

    


    
    
用MapReduce實現矩陣乘法

     
 
                


	import org.apache.hadoop.mapred.JobConf;
	
	
	
	public class MainRun {
	
	
	
	public static final String HDFS = "hdfs://192.168.1.210: 



  
 

    


    
    
【轉載】快速排序(三種演算法實現和非遞迴實現)

     
 
							
							
							原文地址
python實現：
import random
a = [4,1,7,6,9,2,2,3,5,7,8,9,3,1,2,3,4,5,8,0,3,5]
b = [4,1,7,6,9,2,8,0,3,5]
def twoPointerSort(nums,le 



  
 

    


    
    
【LeetCode-演算法】59. 螺旋矩陣Ⅱ（Java實現）

     
 
							
							
							題目
給定一個正整數 n，生成一個包含 1 到 n2 所有元素，且元素按順時針順序螺旋排列的正方形矩陣。
示例
輸入: 3
輸出:
[
 [ 1, 2, 3 ],
 [ 8, 9, 4 ],
 [ 7, 6, 5 ]
]

程式碼實現
class Solutio 



  
 

    


    
    
基於MapReduce的大矩陣乘法（Spark實現）

     
 
                

矩陣-向量乘法實現



xi=∑j=1nmijvj



Map函式

Map函式應用於M的一個元素，但是如果執行Map任務的計算節點還沒有將v讀到記憶體，那麼首先以一個整體的方式讀入v，然後v就可以被該Map任務中執行的Map函式所用。每個Map任務將整個向量v和矩陣