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

2021年09月15日 阅读数:1
这篇文章主要向大家介绍[LeetCode] 311. Sparse Matrix Multiplication 稀疏矩阵相乘,主要内容包括基础应用、实用技巧、原理机制等方面,希望对大家有所帮助。

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

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

Example:python

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]。post

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:url

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)spa

# 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++:htm

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;
    }
};

  

  

 

All LeetCode Questions List 题目汇总