Leetcode 311- 稀疏矩阵的乘法

给你两个 稀疏矩阵 A 和 B，请你返回 AB 的结果。你可以默认 A 的列数等于 B 的行数。

请仔细阅读下面的示例。

题解

题解转载自klb
法一.
直接按照矩阵乘法的定义来就行

ci,j+=ai,k*bk,j(k=0,1,2,b.length)

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

方法二

转载自wh1te-2
哈希表存储元素

基本思路

先对A、B两个矩阵转存储方式，利用哈希表存；也就是这里的transA和transB这两个方法
对于A，先索引行号，再索引列号；B矩阵则先索引列，再索引行，对非0元素进行存储
完成了矩阵稀疏化存储后，对于A中的key（A的行）和B中的key（B的列），进行对应行列的向量点乘操作，点乘结果放置到结果的对应索引（A行B列）处
对于向量的点乘，由于是稀疏向量点乘，所以只需要考虑这两个哈希表的公共索引即可，这里增加了一个retainAll操作，避免那些乘0操作

class Solution {
    public int[][] multiply(int[][] A, int[][] B) {
        int m = A.length;
        int n = B[0].length;
        int[][] AB = new int[m][n];
        Map<Integer, Map<Integer, Integer>> mA = transA(A);
        Map<Integer, Map<Integer, Integer>> mB = transB(B);
        for(Map.Entry<Integer, Map<Integer, Integer>> e1:mA.entrySet()){
            Map<Integer, Integer> m1 = e1.getValue();
            Set<Integer> s1 = m1.keySet();
            int i = e1.getKey();
            for(Map.Entry<Integer, Map<Integer, Integer>> e2:mB.entrySet()){
                Map<Integer, Integer> m2 = e2.getValue();
                Set<Integer> s2 = new HashSet<>(m2.keySet());
                int j = e2.getKey();
                s2.retainAll(s1);
                for(Integer idx : s2)
                    AB[i][j] += m1.get(idx) * m2.get(idx);
            }
        }
        return AB;
    }

    public Map<Integer, Map<Integer, Integer>> transA(int[][] A){
        Map<Integer, Map<Integer, Integer>> mA = new HashMap<>();
        for(int i = 0; i < A.length; i++){
            Map<Integer, Integer> rowA = new HashMap<>();
            for(int j = 0; j < A[0].length; j++)
                if(A[i][j] != 0)
                    rowA.put(j, A[i][j]);
            if(rowA.size() > 0) mA.put(i, rowA);
        }
        return mA;
    }

    public Map<Integer, Map<Integer, Integer>> transB(int[][] B){
        Map<Integer, Map<Integer, Integer>> mB = new HashMap<>();
        for(int i = 0; i < B[0].length; i++){
            Map<Integer, Integer> colB = new HashMap<>();
            for(int j = 0; j < B.length; j++)
                if(B[j][i] != 0)
                    colB.put(j, B[j][i]);
            if(colB.size() > 0) mB.put(i, colB);
        }
        return mB;
    }
}

方法三、跳过非零的行和列
题解转载自mmmmmJCY
矩阵AB结果集的行数和列数分别为A的行数和B的列数。因为稀疏矩阵的0较多，创建两个Set来记录A全为0的行和B全为0的列，如果碰到全0行或者全0列，计算时当前元素为0，所以遍历时遇到直接continue。

public int[][] multiply(int[][] A, int[][] B) {
        int[][] res = new int[A.length][B[0].length];
        Set<Integer> aSet = new HashSet<>();
        Set<Integer> bSet = new HashSet<>();
        for(int i = 0;i < A.length;i++){
            boolean flag = true;
            for(int j = 0;j < A[0].length;j++){
                if(A[i][j] != 0){
                    flag = false;
                    break;
                }
            }
            if(flag) aSet.add(i);
        }

        for(int j = 0;j < B[0].length;j++){
            boolean flag = true;
            for(int i = 0;i < B.length;i++){
                if(B[i][j] != 0){
                    flag = false;
                    break;
                }
            }
            if(flag) bSet.add(j);
        }

        for (int row = 0; row < A.length; row++) {
            if(aSet.contains(row)) continue;
            for(int col = 0;col < B[0].length;col++){
                if(bSet.contains(col)) continue;
                int sum = 0;
                for(int Brow = 0;Brow < B.length;Brow++){
                    sum += A[row][Brow] * B[Brow][col];
                }
                res[row][col] = sum;
            }
        }
        return res;
}