[Leetcode] 311. Sparse Matrix Multiplication 解题报告_sparsematrix tll解法-优快云博客

这篇博客探讨了LeetCode中的311题，即如何高效地进行两个稀疏矩阵的乘法。通过识别并跳过全零行和列以加速计算，同时改变传统矩阵乘法算法，逐个累加增量而不是一次性计算所有元素，实现了优化解法。文章提供了详细的思路解析和代码实现。

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

题目：

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 |

思路：

1、记录A中的全零行和B中的全零列，并且在双重循环中跳过这些行和列，以达到加速的目标。

2、改变一下正常矩阵乘积算法中的第二三重循环。这里的技巧是：对于结果矩阵，我们不是逐个完成里面每个元素的计算的，而是为每个元素逐步累加新的增量。这样当遇到A矩阵中的0元素时就可以直接跳过，因为它不会对结果矩阵中的任何一个元素提供增量。实验结果证明这种优化方法还要优于第一种优化方法。

代码：

1、

class Solution {
public:
    vector<vector<int>> multiply(vector<vector<int>>& A, vector<vector<int>>& B) {
        if (A.size() == 0 || B.size() == 0) {
            return {};
        }
        int row_A = A.size(), col_A = A[0].size(), col_B = B[0].size();
        vector<vector<int>> ret(row_A, vector<int>(col_B, 0));
        set<int> row, col;      // store all the rows and cols who contain all 0s
        for (int i = 0; i < row_A; ++i) {
            int j = 0;
            for (; j < col_A; ++j) {
                if (A[i][j] != 0) {
                    break;
                }
            }
            if (j == col_A) {
                row.insert(i);
            }
        }
        for (int i = 0; i < col_B; ++i) {
            int j = 0;
            for (j = 0; j < col_A; ++j) {
                if (B[j][i] != 0) {
                    break;
                }
            }
            if (j == col_A) {
                col.insert(i);
            }
        }
        for (int i = 0; i < row_A; ++i) {
            if (row.count(i)) {                 // skip the 0 row
                continue;
            }
            for (int j = 0; j < col_B; ++j) {
                if (col.count(j)) {             // skip the 0 col
                    continue;
                }
                for (int k = 0; k < col_A; ++k) {
                    ret[i][j] += A[i][k] * B[k][j];
                }
            }
        }
        return ret;
    }
};

2、

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