JAVA写出1、输入两个n×n的矩阵A和B,实现乘积运算,并输出运算结果和计算时间;2、逐渐增大矩阵A和B的规模,分析运算时间的变化。3、用分治法的实现矩阵乘积运算,比较使用分治法前后的计算量差异。
时间: 2024-05-05 07:22:35 浏览: 8
1. 输入两个n×n的矩阵A和B,实现乘积运算,并输出运算结果和计算时间:
```java
import java.util.Scanner;
public class MatrixMultiplication {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter the value of n: ");
int n = sc.nextInt();
int[][] A = new int[n][n];
int[][] B = new int[n][n];
int[][] C = new int[n][n];
// Initializing matrices A and B
System.out.println("Enter the elements of matrix A:");
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
A[i][j] = sc.nextInt();
System.out.println("Enter the elements of matrix B:");
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
B[i][j] = sc.nextInt();
// Matrix multiplication
long startTime = System.nanoTime();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}
long endTime = System.nanoTime();
long totalTime = endTime - startTime;
// Printing the result
System.out.println("Resultant matrix C = ");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.print(C[i][j] + " ");
}
System.out.println();
}
// Printing the time taken for calculation
System.out.println("Time taken for calculation: " + totalTime + " nanoseconds");
}
}
```
2. 逐渐增大矩阵A和B的规模,分析运算时间的变化:
```java
import java.util.Scanner;
public class MatrixMultiplication {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter the maximum value of n: ");
int max_n = sc.nextInt();
// Running matrix multiplication for different values of n
for (int n = 2; n <= max_n; n++) {
int[][] A = new int[n][n];
int[][] B = new int[n][n];
int[][] C = new int[n][n];
// Initializing matrices A and B
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
A[i][j] = 1;
B[i][j] = 1;
}
}
// Matrix multiplication
long startTime = System.nanoTime();
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
C[i][j] += A[i][k] * B[k][j];
}
}
}
long endTime = System.nanoTime();
long totalTime = endTime - startTime;
// Printing the time taken for calculation
System.out.println("Time taken for calculation of n = " + n + ": " + totalTime + " nanoseconds");
}
}
}
```
3. 用分治法的实现矩阵乘积运算,比较使用分治法前后的计算量差异:
```java
import java.util.Scanner;
public class MatrixMultiplication {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.print("Enter the value of n: ");
int n = sc.nextInt();
int[][] A = new int[n][n];
int[][] B = new int[n][n];
int[][] C = new int[n][n];
// Initializing matrices A and B
System.out.println("Enter the elements of matrix A:");
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
A[i][j] = sc.nextInt();
System.out.println("Enter the elements of matrix B:");
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
B[i][j] = sc.nextInt();
// Matrix multiplication using divide and conquer
long startTime = System.nanoTime();
C = divideAndConquer(A, B);
long endTime = System.nanoTime();
long totalTime = endTime - startTime;
// Printing the result
System.out.println("Resultant matrix C = ");
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
System.out.print(C[i][j] + " ");
}
System.out.println();
}
// Printing the time taken for calculation
System.out.println("Time taken for calculation: " + totalTime + " nanoseconds");
}
// Divide and conquer function for matrix multiplication
public static int[][] divideAndConquer(int[][] A, int[][] B) {
int n = A.length;
int[][] C = new int[n][n];
if (n == 1) {
C[0][0] = A[0][0] * B[0][0];
return C;
}
// Divide
int[][] A11 = new int[n/2][n/2];
int[][] A12 = new int[n/2][n/2];
int[][] A21 = new int[n/2][n/2];
int[][] A22 = new int[n/2][n/2];
int[][] B11 = new int[n/2][n/2];
int[][] B12 = new int[n/2][n/2];
int[][] B21 = new int[n/2][n/2];
int[][] B22 = new int[n/2][n/2];
for (int i = 0; i < n/2; i++) {
for (int j = 0; j < n/2; j++) {
A11[i][j] = A[i][j];
A12[i][j] = A[i][j+n/2];
A21[i][j] = A[i+n/2][j];
A22[i][j] = A[i+n/2][j+n/2];
B11[i][j] = B[i][j];
B12[i][j] = B[i][j+n/2];
B21[i][j] = B[i+n/2][j];
B22[i][j] = B[i+n/2][j+n/2];
}
}
// Conquer
int[][] C11 = addMatrix(divideAndConquer(A11, B11), divideAndConquer(A12, B21));
int[][] C12 = addMatrix(divideAndConquer(A11, B12), divideAndConquer(A12, B22));
int[][] C21 = addMatrix(divideAndConquer(A21, B11), divideAndConquer(A22, B21));
int[][] C22 = addMatrix(divideAndConquer(A21, B12), divideAndConquer(A22, B22));
// Combine
for (int i = 0; i < n/2; i++) {
for (int j = 0; j < n/2; j++) {
C[i][j] = C11[i][j];
C[i][j+n/2] = C12[i][j];
C[i+n/2][j] = C21[i][j];
C[i+n/2][j+n/2] = C22[i][j];
}
}
return C;
}
// Function for adding two matrices
public static int[][] addMatrix(int[][] A, int[][] B) {
int n = A.length;
int[][] C = new int[n][n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
C[i][j] = A[i][j] + B[i][j];
}
}
return C;
}
}
```