如何在计算矩阵和时提高性能

Question

I was given a task during an interview, where I was given a matrix, now I need to generate another matrix out of it using below formula:

Given matrix A[R][C], generate B[R][C]

val = 0;
for (i = 0; i ≤ xPosition; i += 1) {
    for (j = 0; j ≤ yPosition; j += 1) {
        val = val + a(i, j);
    }
}

B(xPosition,yPosition) = val;

I have come up with below code:

public List<List<Integer>> generate(List<List<Integer>> A) {
        List<List<Integer>> top = new ArrayList<>();

        for (int i = 0; i < A.size(); i++) {
            List<Integer> inner = new ArrayList<>();
            for (int j = 0; j < A.get(0).size(); j++) {
                inner.add(generateValue(A, i, j));
            }
            top.add(inner);
        }
        return top;
    }

    int generateValue(List<List<Integer>> A, int xPosition, int yPosition) {
        int val = 0;
        for (int i = 0; i <= xPosition; i++) {
            for (int j = 0; j <= yPosition; j++) {
                int value = A.get(i).get(j);
                val += value;
            }
        }
        return val;
    }

Sample input :

1 2 3
4 5 6

Output :

1 3 6
5 12 21

How to improve the performance of this logic?

Answer 1

mathematicaly for your solution in array b,each element is related to it's previous one.

to improve your code / optimise it you need to see this relation. so for every B[i][j] is related to it's previous element and value from the array A.

below is solution mathematically,

b[i][j] = b[i-1][j] + a[i][0]+a[i][1] + a[i][2]+...+a[i][y-1] 

for so if you able to implement this, your code will pass all test cases

i am not a java dev, but if you want code, i can write it for you in python

Answer 2

The key is to think of this as a dynamic programming problem, assuming that we have already calculated B[x][y] for all 0 <= x < i , 0 <= y < j when we go to calculate B[i][j] .

B[i][j] contains the sum of all elements in the submatrix of A that starts at 0, 0 and ends at i, j . Thus B[i-1][j] will contain the sum of the all the elements in this submatrix except the ones in the i th row. Similarly, B[i][j-1] will contain the sum of the all the elements in this submatrix except the ones in the j th column. Adding these two together, we get the sum of all the elements in the submatrix except for element A[i][j] . However, while doing this we count all the elements from 0, 0 to i-1, j-1 twice, and we have to subtract their sum (which is B[i-1][j-1] ) once so that we only sum them up once in total. Then we add the missing element, A[i][j] . Hence

B[i][j] = B[i-1][j] + B[i][j-1] - B[i-1][j-1] + A[i][j]

This recursion can now be implemented as a O(RC) dynamic programming algorithm.

To help understand this further, consider the following figure representing the submatrix for which we have to find the sum of the elements. The figure is a matrix C[i][j] , where the x, y th element is the number of times we have summed A[x][y] . In terms of C[i][j] , our end goal ( B[i][j] ) is

1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

B[i-1][j] corresponds to the matrix C[i-1][j] , which is

1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
0 0 0 0 0

B[i][j-1] corresponds to the matrix C[i][j-1] , which is

1 1 1 1 0
1 1 1 1 0
1 1 1 1 0
1 1 1 1 0

B[i-1][j] + B[i][j-1] corresponds to the matrix C[i-1][j] + C[i][j-1] , which is

2 2 2 2 1
2 2 2 2 1
2 2 2 2 1
1 1 1 1 0

B[i-1][j] + B[i][j-1] - B[i-1][j-1] corresponds to the matrix C[i-1][j] + C[i][j-1] - C[i-1][j-1] , which is

1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 0

Now B[i-1][j] + B[i][j-1] - B[i-1][j-1] + A[i][j] corresponds to

1 1 1 1 1
1 1 1 1 1
1 1 1 1 1
1 1 1 1 1

which is the same as B[i][j] .