稀疏矩陣相乘-Python版

Given two sparse matrices A and B, return the result of AB.

You may assume that A's column number is equal to B's row number.

Example:

    
    
   
  
  
          
 
           
 
            
 
             
 
            
 
            
 
             

               A = [ 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               [ 1, 0, 0], 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               [-1, 0, 3] 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               ] 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               B = [ 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               [ 7, 0, 0 ], 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               [ 0, 0, 0 ], 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               [ 0, 0, 1 ] 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               ] 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               | 1 0 0 | | 7 0 0 | | 7 0 0 | 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               AB = | -1 0 3 | x | 0 0 0 | = | -7 0 3 | 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               | 0 0 1 | 
             
 
            
 
          
   
   
  
 
 
         

使用傳統的矩陣相乘的算法肯定會處理大量的0乘0的無用功，所以我們適當的優化算法，我們知道一個 i x k 的矩陣A乘以一個 k x j 的矩陣B會得到一個 i x j 大小的矩陣C，那么我們來看結果矩陣中的某個元素C[i][j]是怎么來的，起始是A[i][0]*B[0][j] + A[i][1]*B[1][j] + ... + A[i][k]*B[k][j]，那么為了不重復計算0乘0，我們首先遍歷A數組，要確保A[i][k]不為0，才繼續計算，然后我們遍歷B矩陣的第k行，如果B[K][J]不為0，我們累加結果矩陣res[i][j] += A[i][k] * B[k][j]; 這樣我們就能高效的算出稀疏矩陣的乘法，參見代碼如下：

    
    
   
  
  
          
 
           
 
            
 
             
 
            
 
            
 
             
 
              # -*- coding: utf-8 -*- 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              """ 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              Created on Sun Sep 02 15:10:34 2018 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
               
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              @author: Administrator 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              """ 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              def SparseMatrixMultiply(A, B): 
              #減少計算次數 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               res = [[ 
              0 
              for i 
              in range(len(B[ 
              0]))] 
              for j 
              in range(len(A))] 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              for i 
              in range(len(A)): 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              for j 
              in range(len(A[ 
              0])): 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              if A[i][j] != 
              0: 
              #non-zero 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              for k 
              in range(len(B[ 
              0])): 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              if B[j][k] != 
              0: 
              #non-zero 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               res[i][k] += A[i][j] * B[j][k] 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              return res 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             
 
              if __name__ == 
              '__main__': 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               A = [[ 
              1, 
              0, 
              0],[ 
              -1, 
              0, 
              3]] 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               B = [[ 
              7, 
              0, 
              0],[ 
              0, 
              0, 
              0],[ 
              0, 
              0, 
              1]] 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               result = SparseMatrixMultiply(A, B) 
             
 
            
 
           
 
            
 
             
 
            
 
            
 
             

               print(result) 
             
 
            
 
          
   
   
  
 
 
         

三元組方法

typedef struct NODE{ //定義稀疏矩陣結點       
 int i;       //行
 int j;       //列
 int data;   //值
} Node;
typedef struct MATRIX{ //定義稀疏矩陣（可以快速訪問）       
 int mu, nu, tu;      // mu為矩陣行數，nu為矩陣列數，tu為矩陣中非零元素的個數
 Node matrix[MAXSIZE+1];       
 int rpos[MAXR+1];
} Matrix; 

算法時間復雜度為：O(A->tu*B->tu/B->mu)

此外還有十字鏈表法。

Python科學計算包scipy

import scipy as sp

a = sp.sparse.linalg.norm(S, 'fro')