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 |

給2個稀疏矩陣，返回矩陣相乘的結果。

在數值分析中，稀疏矩陣（Sparse matrix），是其元素大部分為零的矩陣。反之，如果大部分元素都非零，則這個矩陣是稠密的。在科學與工程領域中求解線性模型時經常出現大型的稀疏矩陣。在使用計算機存儲和操作稀疏矩陣時，經常需要修改標準算法以利用矩陣的稀疏結構。由於其自身的稀疏特性，通過壓縮可以大大節省稀疏矩陣的內存代價。更為重要的是，由於過大的尺寸，標準的算法經常無法操作這些稀疏矩陣。

解法：稀疏矩陣中絕大多數的元素為0，而相乘的結果是還應該是稀疏矩陣，即還是大多數元素為0，用傳統矩陣相乘的算法肯定會處理大量的0乘0的無用功，所以需要適當的優化算法，使其可以順利通過OJ。一個 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, B數組， 如果A[i][k]， B[K][J]不為0，才繼續計算，累加結果res[i][j] += A[i][k] * B[k][j]。

Java: naive solution. T: O(n^3)

public int[][] multiply(int[][] A, int[][] B) {
    //validity check 
    int[][] C = new int[A.length][B[0].length];
 
    for(int i=0; i<C.length; i++){
        for(int j=0; j<C[0].length; j++){
            int sum=0;
            for(int k=0; k<A[0].length; k++){
                sum += A[i][k]*B[k][j];
            }
            C[i][j] = sum;
        }
    }
 
    return C;
}

Java:

public int[][] multiply(int[][] A, int[][] B) {
    //validity check
    int[][] C = new int[A.length][B[0].length];
 
    for(int i=0; i<C.length; i++){
        for(int k=0; k<A[0].length; k++){
            if(A[i][k]!=0){
                for(int j=0; j<C[0].length; j++){
                    C[i][j] += A[i][k]*B[k][j];
                }
            }
        }
    }
 
    return C;
}

Python: optimized, T: O(n^2)

# Time:  O(m * n * l), A is m x n matrix, B is n x l matrix
# Space: O(m * l)
class Solution(object):
    def multiply(self, A, B):
        """
        :type A: List[List[int]]
        :type B: List[List[int]]
        :rtype: List[List[int]]
        """
        m, n, l = len(A), len(A[0]), len(B[0])
        res = [[0 for _ in xrange(l)] for _ in xrange(m)]
        for i in xrange(m):
            for k in xrange(n):
                if A[i][k]:
                    for j in xrange(l):
                        res[i][j] += A[i][k] * B[k][j]
        return res　　

C++:

class Solution {
public:
    vector<vector<int>> multiply(vector<vector<int>>& A, vector<vector<int>>& B) {
        vector<vector<int>> res(A.size(), vector<int>(B[0].size()));
        for (int i = 0; i < A.size(); ++i) {
            for (int k = 0; k < A[0].size(); ++k) {
                if (A[i][k] != 0) {
                    for (int j = 0; j < B[0].size(); ++j) {
                        if (B[k][j] != 0) res[i][j] += A[i][k] * B[k][j];
                    }
                }
            }
        }
        return res;
    }
};

C++:

class Solution {
public:
    vector<vector<int>> multiply(vector<vector<int>>& A, vector<vector<int>>& B) {
        vector<vector<int>> res(A.size(), vector<int>(B[0].size()));
        vector<vector<pair<int, int>>> v(A.size(), vector<pair<int,int>>());
        for (int i = 0; i < A.size(); ++i) {
            for (int k = 0; k < A[i].size(); ++k) {
                if (A[i][k] != 0) v[i].push_back({k, A[i][k]});
            }
        }
        for (int i = 0; i < A.size(); ++i) {
            for (int k = 0; k < v[i].size(); ++k) {
                int col = v[i][k].first;
                int val = v[i][k].second;
                for (int j = 0; j < B[0].size(); ++j) {
                    res[i][j] += val * B[col][j];
                }
            }
        }
        return res;
    }
};

[LeetCode] 311. Sparse Matrix Multiplication 稀疏矩陣相乘