Question

我有一个作业，我必须打开一个文本文件（matrix.txt），并从文件中获取两个矩阵A和B。一旦获得这些矩阵，我就必须将它们变成等于或接近四个的四个矩阵。大小相等的矩阵。

例如。

A = [{A_00, A_01}, {A_10, A_11}]

我必须对从文本文件中获得的两个矩阵进行此操作，然后将它们加在一起以获得新的矩阵C。

例如。

C = [{A_00+B_00, A_01+B_01}, {A_10+B_10, A_11+B_11}]

我能够从文本文件中正确获取矩阵，但是现在有了矩阵A和B，我不知道如何将它们转换为各自的子矩阵。如果有人能指出我正确的方向，将不胜感激！如有需要，我可以提供作业文件以帮助提供更多说明。

给出的文本文件示例

4 7
2 3 1 2 5 1 2
3 1 2 2 2 4 4
1 2 3 2 7 2 1
3 6 1 5 1 3 5
6 5 4 1 4 3 1
3 3 2 2 1 1 2
7 5 4 3 2 5 3
2 1 8 4 8 4 4

到目前为止，这是我的代码

    import java.io.File;
    import java.io.IOException;
    import java.util.Scanner;
    import java.util.ArrayList;
    
    public class MatrixThread {
            
        public static Scanner scan;
        
        public static void main(String[] args) {
            
                if(args.length == 0){
                System.out.println("File name not specified");
                System.exit(1);
            }
            
            try{
                File matrix = new File(args[0]);
                scan = new Scanner(matrix);
            } catch (IOException ioException) {
                System.err.println("Cannot open file.");
                System.exit(1);
            }
            ThreadOperation Operation = new ThreadOperation();
            Operation.executeOperation();
            
        }
    }
-----------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------
class ThreadOperation extends MatrixThread {
    
    
    void executeOperation(){
        
        int N = scan.nextInt();
        int M = scan.nextInt();
            
        int A[][] = new int [N][M];
        int B[][] = new int [N][M];
    
        for(int i = 0; i < N; ++i)
        {
            for(int j = 0; j < M; ++j)
            {               
                if(scan.hasNextInt())
                {
                    A[i][j] = scan.nextInt();
                }
            }
        }
                
        for(int i = 0; i < N; ++i)
        {
            for(int j = 0; j < M; ++j)
            {               
                if(scan.hasNextInt())
                {
                    B[i][j] = scan.nextInt();
                }
            }
        }
        
        /*int C[][] = new int [N][M];
        for (int i = 0; i < N; i++){
            for(int j = 0; j < M; j++){
                C[i][j] = A[i][j] + B[i][j];
                System.out.print(C[i][j] + " ");
            }
            System.out.print("\r\n");*/
        }
    }
}

给出示例文件的期望输出为：

     N = 4, M = 7
    
    Matrix A:
    2 3 1 2 5 1 2
    3 1 2 2 2 4 4
    1 2 3 2 7 2 1
    3 6 1 5 1 3 5 
    
    Matrix B:
    6 5 4 1 4 3 1 
    3 3 2 2 1 1 2 
    7 5 4 3 2 5 3 
    2 1 8 4 8 4 4
    
    Submatrix A_00:
    2 3 1 2
    3 1 2 2 
    Submatrix A_01:
    5 1 2
    2 4 4
    Submatrix A_10:
    1 2 3 2
    3 6 1 5
    Submatrix A_11:
    7 2 1
    1 3 5
    Submatrix B_00:
    6 5 4 1 
    3 3 2 2
    Submatrix B_01:
    4 3 1
    1 1 2
    Submatrix B_10:
    7 5 4 3 
    2 1 8 4
    Submatrix B_11:
    2 5 3
    8 4 4
    Submatrix C_00:
    8 8 5 3
    6 4 4 4 
    Submatrix C_01:
    9 4 3
    3 5 6 
    Submatrix C_10:
    8 7 7 5
    5 7 9 9
    Submatrix C_11:
    9 7 4 
    9 7 9

    Matrix C:
    8 8 5 3 9 4 3
    6 4 4 4 3 5 6
    8 7 7 5 9 7 4 
    5 7 9 9 9 7 9

Answer 1

怎么样

A00[][] = new int[N / 2][M / 2];
for (int i = 0; i < A00.length; i++) {
    for (int j = 0; j < A00[0].length; j++) {
        A00[i][j] = A[i][j];
    }
}

A01[][] = new int[N / 2][M - M/2];
for (int i = 0; i < A01.length; i++) {
    for (int j = 0; j < A01[0].length; j++) {
        A01[i][j] = A[i][M/2 + j];
    }
}

并进行类似的计算以获得其他子矩阵。

如何从矩阵中获得子矩阵？

1 个答案: