java分治递归矩阵乘法

Question

我开始学习分治的概念，我遇到了矩阵乘法。我可以使用for循环完成下面的代码，但对于递归练习，我又多了一步，并尝试自己完成

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
class Codechef
{
    int bigA[][];
    int bigB[][];
    public Codechef (int bigA[][], int bigB[][]) {
        this.bigA = bigA;
        this.bigB = bigB;
    }

    public int[][] recursiveMatrixMultipy (int A[][], int B[][], int n) {
        int c[][] = new int[n][n];
        if (n == 1) {
            c[0][0] = bigA[ A[0][0] ][ A[1][0] ] * bigB[ B[0][0] ][ B[1][0] ];
        } else {
            int r_start = A[0][0];
            int r_end = A[0][1];
            int c_start = A[1][0];
            int c_end = A[1][1];
            int r_mid = r_start + (r_end - r_start) / 2;
            int c_mid = c_start + (c_end - c_start) / 2;
            int a11[][] = {{r_start, r_mid}, {c_start, c_mid}};
            int a12[][] = {{r_start, r_mid}, {c_mid + 1, c_end}};
            int a21[][] = {{r_mid + 1, r_end}, {c_start, c_mid}};
            int a22[][] = {{r_mid + 1, r_end}, {c_mid + 1, c_end}};

            int b11[][] = {{r_start, r_mid}, {c_start, c_mid}};
            int b12[][] = {{r_start, r_mid}, {c_mid + 1, c_end}};
            int b21[][] = {{r_mid + 1, r_end}, {c_start, c_mid}};
            int b22[][] = {{r_mid + 1, r_end}, {c_mid + 1, c_end}};
            System.out.println ("A " +  Arrays.deepToString(A));
            System.out.println ("B " +  Arrays.deepToString(B));
            System.out.println (n);
            System.out.println ("a11 " +  Arrays.deepToString(a11));
            System.out.println ("a12 " +  Arrays.deepToString(a12));
            System.out.println ("a21 " +  Arrays.deepToString(a21));
            System.out.println ("a22 " +  Arrays.deepToString(a22));

            int c11[][] = addMatrix(recursiveMatrixMultipy (a11, b11, n / 2),
                            recursiveMatrixMultipy (a12, b21, n / 2) );

            int c12[][] = addMatrix(recursiveMatrixMultipy (a11, b12, n / 2), 
                            recursiveMatrixMultipy (a12, b22, n / 2) );

            int c21[][] = addMatrix(recursiveMatrixMultipy (a21, b11, n / 2), 
                            recursiveMatrixMultipy (a22, b21, n / 2) );

            int c22[][] = addMatrix(recursiveMatrixMultipy (a21, b12, n / 2), 
                            recursiveMatrixMultipy (a22, b22, n / 2) );
            c = merge (c11, c12, c21, c22);
        }
        return c;
    }


    public int[][] addMatrix (int A[][], int B[][]) {
        int n = A[0].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;
    }

    public int[][] merge (int c11[][], int c12[][], int c21[][], int c22[][]) {      
        int n_C = c11[0].length;          
        int n = 2 * n_C;
        int C[][] = new int[n][n];
        for (int i = 0; i < n_C; i++) {
            for (int j = 0; j < n_C; j++) {
               C[i][j] = c11[i][j];
               C[i][j + n_C] = c12[i][j];
               C[i + n_C][j] = c21[i][j];
               C[i + n_C][j + n_C] = c22[i][j];
            }
        }
        return C;
    }

    public static void main (String[] args) throws java.lang.Exception
    {

        int matrix[][] = {{1,2,3,4},{1,2,3,4},{1,2,3,4},{1,2,3,4}};
        int n = matrix[0].length;

        //checks if power of 2
        if ((n > 0) && ( ( n & ( n - 1 ) ) == 0 ) ) {
            Codechef matrixDivAndConquer = new Codechef (matrix, matrix);
            int A[][] = {{0, n - 1},{0, n  - 1}};
            int B[][] = {{0, n - 1},{0, n  - 1}};
            int C[][] = matrixDivAndConquer.recursiveMatrixMultipy (A, B, n);
            System.out.println (Arrays.deepToString(C));
        }
    }
}



A [[0, 3], [0, 3]]
B [[0, 3], [0, 3]]
4
a11 [[0, 1], [0, 1]]
a12 [[0, 1], [2, 3]]
a21 [[2, 3], [0, 1]]
a22 [[2, 3], [2, 3]]
A [[0, 1], [0, 1]]
B [[0, 1], [0, 1]]
2
a11 [[0, 0], [0, 0]]
a12 [[0, 0], [1, 1]]
a21 [[1, 1], [0, 0]]
a22 [[1, 1], [1, 1]]
A [[0, 1], [2, 3]]
B [[2, 3], [0, 1]]
2
a11 [[0, 0], [2, 2]]
a12 [[0, 0], [3, 3]]
a21 [[1, 1], [2, 2]]
a22 [[1, 1], [3, 3]]
A [[0, 1], [0, 1]]
B [[0, 1], [2, 3]]
2
a11 [[0, 0], [0, 0]]
a12 [[0, 0], [1, 1]]
a21 [[1, 1], [0, 0]]
a22 [[1, 1], [1, 1]]
A [[0, 1], [2, 3]]
B [[2, 3], [2, 3]]
2
a11 [[0, 0], [2, 2]]
a12 [[0, 0], [3, 3]]
a21 [[1, 1], [2, 2]]
a22 [[1, 1], [3, 3]]
A [[2, 3], [0, 1]]
B [[0, 1], [0, 1]]
2
a11 [[2, 2], [0, 0]]
a12 [[2, 2], [1, 1]]
a21 [[3, 3], [0, 0]]
a22 [[3, 3], [1, 1]]
A [[2, 3], [2, 3]]
B [[2, 3], [0, 1]]
2
a11 [[2, 2], [2, 2]]
a12 [[2, 2], [3, 3]]
a21 [[3, 3], [2, 2]]
a22 [[3, 3], [3, 3]]
A [[2, 3], [0, 1]]
B [[0, 1], [2, 3]]
2
a11 [[2, 2], [0, 0]]
a12 [[2, 2], [1, 1]]
a21 [[3, 3], [0, 0]]
a22 [[3, 3], [1, 1]]
A [[2, 3], [2, 3]]
B [[2, 3], [2, 3]]
2
a11 [[2, 2], [2, 2]]
a12 [[2, 2], [3, 3]]
a21 [[3, 3], [2, 2]]
a22 [[3, 3], [3, 3]]

这似乎并没有给我正确的答案。我错过了什么

我在输出之间粘贴了一些，以便更容易理解我在做什么。 我的输出：

[[24, 34, 24, 34], [24, 34, 24, 34], [24, 34, 24, 34], [24, 34, 24, 34]]

以上矩阵的正确答案：

[[10, 20, 30, 40], [10, 20, 30, 40], [10, 20, 30, 40], [10, 20, 30, 40]]