两个矩阵相乘的Java程序

给定两个矩阵，将它们相乘的任务。矩阵可以是正方形或矩形。

例子：

Input : mat1[][] = {{1, 2}, 
                   {3, 4}}
        mat2[][] = {{1, 1}, 
                    {1, 1}}
Output : {{3, 3}, 
          {7, 7}}
Input : mat1[][] = {{2, 4}, 
                    {3, 4}}
        mat2[][] = {{1, 2}, 
                    {1, 3}}       
Output : {{6, 16}, 
          {7, 18}}

平方矩阵的乘法：
下面的程序将两个大小为 4*4 的方阵相乘，我们可以将 N 更改为不同的维度。

Java

// Java program to multiply two square
// matrices.
import java.io.*;
  
class GFG {
  
    static int N = 4;
  
    // This function multiplies mat1[][]
    // and mat2[][], and stores the result
    // in res[][]
    static void multiply(int mat1[][],
                         int mat2[][], int res[][])
    {
        int i, j, k;
        for (i = 0; i < N; i++) {
            for (j = 0; j < N; j++) {
                res[i][j] = 0;
                for (k = 0; k < N; k++)
                    res[i][j] += mat1[i][k]
                                 * mat2[k][j];
            }
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
        int mat1[][] = { { 1, 1, 1, 1 },
                         { 2, 2, 2, 2 },
                         { 3, 3, 3, 3 },
                         { 4, 4, 4, 4 } };
  
        int mat2[][] = { { 1, 1, 1, 1 },
                         { 2, 2, 2, 2 },
                         { 3, 3, 3, 3 },
                         { 4, 4, 4, 4 } };
  
        // To store result
        int res[][] = new int[N][N];
        int i, j;
        multiply(mat1, mat2, res);
  
        System.out.println("Result matrix"
                           + " is ");
        for (i = 0; i < N; i++) {
            for (j = 0; j < N; j++)
                System.out.print(res[i][j]
                                 + " ");
            System.out.println();
        }
    }
}
  
// This code is contributed by anuj_67.

输出

Result matrix is 
10 10 10 10 
20 20 20 20 
30 30 30 30 
40 40 40 40

时间复杂度： O(n ³ )。可以使用 Strassen 的矩阵乘法进行优化

辅助空间： O(n ² )

矩形矩阵的乘法：
我们在 C 中使用指针来乘以矩阵。请参阅以下帖子作为代码的先决条件。
如何在C中将二维数组作为参数传递？

Java

// Java program to multiply two matrices.
  
public class GFG 
{
  
    /**
     * to find out matrix multiplication
     *
     * @param matrix1 First matrix
     * @param rows1   Number of rows in matrix 1
     * @param cols1   Number of columns in matrix 1
     * @param matrix2 Second matrix
     * @param rows2   Number of rows in matrix 2
     * @param cols2   Number of columns in matrix 2
     * @return the result matrix (matrix 1 and matrix 2
     * multiplication)
     */
    public static int[][] matrixMultiplication(
        int[][] matrix1, int rows1, int cols1,
        int[][] matrix2, int rows2, int cols2)
        throws Exception
    {
  
        // Required condition for matrix multiplication
        if (cols1 != rows2) {
            throw new Exception("Invalid matrix given.");
        }
  
        // create a result matrix
        int resultMatrix[][] = new int[rows1][cols2];
  
        // Core logic for 2 matrices multiplication
        for (int i = 0; i < resultMatrix.length; i++) 
        {
            for (int j = 0; 
                 j < resultMatrix[i].length;
                 j++) 
            {
                for (int k = 0; k < cols1; k++) 
                {
                    resultMatrix[i][j]
                        += matrix1[i][k] * matrix2[k][j];
                }
            }
        }
        return resultMatrix;
    }
  
    // Driver code
    public static void main(String[] args) throws Exception
    {
  
        // Initial matrix 1 and matrix 2
        int matrix1[][] = { { 2, 4 }, { 3, 4 } };
        int matrix2[][] = { { 1, 2 }, { 1, 3 } };
  
        // Function call to get a matrix multiplication
        int resultMatrix[][] = matrixMultiplication(
            matrix1, 2, 2, matrix2, 2, 2);
  
        // Display result matrix
        System.out.println("Result Matrix is:");
        for (int i = 0; i < resultMatrix.length; i++) 
        {
            for (int j = 0; 
                 j < resultMatrix[i].length;
                 j++)
            {
                System.out.print(resultMatrix[i][j] + "    ");
            }
            System.out.println();
        }
    }
    // This code is contributed by darshatandel1998 (Darshan
    // Tandel)
}

输出

6 16 
7 18

时间复杂度： O(n ³ )。可以使用 Strassen 的矩阵乘法进行优化

辅助空间： O(m1 * n2)

有关更多详细信息，请参阅有关将两个矩阵相乘的完整文章！