【Leetcode】311. Sparse Matrix Multiplication

題目地址：

https://leetcode.com/problems/sparse-matrix-multiplication/

給定兩個稀疏矩陣$A$和$B$，求它們的乘積。題目保證$A$和$B$可乘。

法1：遍歷$A$的第$i$行和$B$的第$j$列的時候，用兩個指針分別指向它們，然後分別移動，先找到第一個非零數，然後看偏移量是否相等，若相等則累加到乘積$C$裏去，否則直接將偏移量小的指針賦值爲偏移量大的指針的值，再重複做同樣的事情，直到該行（列）遍歷完，就得到了$C[i][j]$。如此這樣遍歷兩個矩陣的所有行和列即可。代碼如下：

public class Solution {
    public int[][] multiply(int[][] A, int[][] B) {
        if (A == null || A.length == 0 || A[0].length == 0 || B == null || B.length == 0 || B[0].length == 0) {
            return new int[0][0];
        }
        
        int p = A.length, q = A[0].length, r = B[0].length;
        int[][] res = new int[p][r];
        
        // 計算res[i][j]
        for (int i = 0; i < p; i++) {
            for (int j = 0; j < r; j++) {
                int idx1 = 0, idx2 = 0;
                while (idx1 < q && idx2 < q) {
                	// 找到A第i行的下一個非零數
                    while (idx1 < q && A[i][idx1] == 0) {
                        idx1++;
                    }
                    // 如果出界了則直接退出循環
                    if (idx1 == q) {
                        break;
                    }
                    // 找到B第j列的下一個非零數
                    while (idx2 < q && B[idx2][j] == 0) {
                        idx2++;
                    }
                    // 如果出界了則直接退出循環
                    if (idx2 == q) {
                        break;
                    }
                    
                    // 如果兩個偏移量相等，說明A[i][idx1]和B[idx1][j]都非零，
                    // 則乘起來並累加到res[i][j]上去，並將兩個指針都向後移動一位；
                    // 如果偏移量不等，譬如idx1 < idx2，那麼我們起碼知道B[idx1, ..., idx2 - 1][j]都等於0，
                    // 這時應該直接將idx1賦值爲idx2，否則將idx2賦值爲idx1
                    if (idx1 == idx2) {
                        res[i][j] += A[i][idx1] * B[idx1][j];
                        idx1++;
                        idx2++;
                    } else {
                        int max = Math.max(idx1, idx2);
                        idx1 = idx2 = max;
                    }
                }
            }
        }
        
        return res;
    }
}

時間複雜度$O(pqr)$，$p$和$q$分別是$A$的行數和列數，$r$是$B$的列數。空間$O(1)$（不計返回結果的空間）。由於是稀疏矩陣，所以做乘法的機會是比較少的，實際運行速度會比樸素乘法快很多。

法2：我們可以發現，$A[i][j]$對最終乘積$C$的貢獻只體現在$A[i][j]$和$B$的第$j$行各個數字相乘上。所以可以直接遍歷$A$的非零項$A[i][j]$，然後再遍歷$B$的第$j$行，把$A[i][j]$和$B[j][k]$的乘積累加到$C[i][k]$上即可。代碼如下：

public class Solution {
    public int[][] multiply(int[][] A, int[][] B) {
        if (A == null || A.length == 0 || A[0].length == 0 || B == null || B.length == 0 || B[0].length == 0) {
            return new int[0][0];
        }
        
        int p = A.length, q = A[0].length, r = B[0].length;
        int[][] res = new int[p][r];
        
        // 外面兩層循環是遍歷A
        for (int i = 0; i < p; i++) {
            for (int j = 0; j < q; j++) {
                if (A[i][j] != 0) {
                	// 再遍歷B的第j行
                    for (int k = 0; k < r; k++) {
                        if (B[j][k] != 0) {
                        	// 累加
                            res[i][k] += A[i][j] * B[j][k];
                        }
                    }
                }
            }
        }
        
        return res;
    }
}

時間複雜度$O(xr)$，$x$爲$A$的非零項的個數。空間$O(1)$。