Skip to content
Related Articles
Find number of transformation to make two Matrix Equal
• Difficulty Level : Hard
• Last Updated : 17 Jun, 2020

Given two matrices A and B of order n*m. The task is to find the required number of transformation steps so that both matrices became equal, print -1 if it is not possible.
Transformation step is as:
i) Select any one matrix out of two matrices.
ii) Choose either row/column of the selected matrix.
iii) Increment every element of select row/column by 1.

Examples :

```Input :
A: 1 1
1 1
B: 1 2
3 4
Output : 3
Explanation :
1 1   ->   1 2   ->   1 2   ->   1 2
1 1   ->   1 2   ->   2 3   ->   3 4

Input :
A: 1 1
1 0
B: 1 2
3 4
Output : -1
Explanation : No transformation will make A and B equal.
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

The key steps behind the solution of this problem are:

-> Incrementing any row of A[][] is same as decrementing the same row of B[][]. So, we can have the solution after having the transformation on only one matrix either incrementing or decrementing.

```So make A[i][j] = A[i][j] - B[i][j].
For example,
If given matrices are,
A : 1 1
1 1
B : 1 2
3 4
After subtraction, A[][] becomes,
A : 0 -1
-2 -3
```

-> For every transformation either 1st row/ 1st column element necessarily got changed, same is true for other i-th row/column.

-> If ( A[i][j] – A[i] – A[j] + A != 0) then no solution exists.

-> Elements of 1st row and 1st column only leads to result.

```// Update matrix A[][]
// so that only A[][]
// has to be transformed
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
A[i][j] -= B[i][j];

// Check necessary condition
// For condition for
// existence of full transformation
for (i = 1; i < n; i++)
for (j = 1; j < m; j++)
if (A[i][j] - A[i] - A[j] + A != 0)
return -1;

// If transformation is possible
// calculate total transformation
result = 0;
for (i = 0; i < n; i++)
result += abs(A[i])
for (j = 0; j < m; j++)
result += abs(A[j] - A);
return abs(result);
```

## C++

 `// C++ program to find``// number of countOpsation``// to make two matrix equals``#include ``using` `namespace` `std;`` ` `const` `int` `MAX = 1000;`` ` `int` `countOps(``int` `A[][MAX], ``int` `B[][MAX], ``             ``int` `m, ``int` `n)``{``    ``// Update matrix A[][]``    ``// so that only A[][]``    ``// has to be countOpsed``    ``for` `(``int` `i = 0; i < n; i++)``        ``for` `(``int` `j = 0; j < m; j++)``            ``A[i][j] -= B[i][j];`` ` `    ``// Check necessary condition``    ``// for condition for``    ``// existence of full countOpsation``    ``for` `(``int` `i = 1; i < n; i++)``    ``for` `(``int` `j = 1; j < m; j++)``        ``if` `(A[i][j] - A[i] - ``            ``A[j] + A != 0)``        ``return` `-1;`` ` `    ``// If countOpsation is possible``    ``// calculate total countOpsation``    ``int` `result = 0;``    ``for` `(``int` `i = 0; i < n; i++)``        ``result += ``abs``(A[i]);``    ``for` `(``int` `j = 0; j < m; j++)``        ``result += ``abs``(A[j] - A);``    ``return` `(result);``}`` ` `// Driver code``int` `main()``{``    ``int` `A[MAX][MAX] = { {1, 1, 1},``                        ``{1, 1, 1},``                        ``{1, 1, 1}};``    ``int` `B[MAX][MAX] = { {1, 2, 3},``                        ``{4, 5, 6},``                        ``{7, 8, 9}};``    ``cout << countOps(A, B, 3, 3) ;``    ``return` `0;``}`

## Java

 `// Java program to find number of``// countOpsation to make two matrix``// equals``import` `java.io.*;`` ` `class` `GFG ``{``     ` `    ``static` `int` `countOps(``int` `A[][], ``int` `B[][],``                        ``int` `m, ``int` `n)``    ``{``         ` `        ``// Update matrix A[][] so that only``        ``// A[][] has to be countOpsed``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``for` `(``int` `j = ``0``; j < m; j++)``                ``A[i][j] -= B[i][j];``     ` `        ``// Check necessary condition for ``        ``// condition for existence of full``        ``// countOpsation``        ``for` `(``int` `i = ``1``; i < n; i++)``            ``for` `(``int` `j = ``1``; j < m; j++)``                ``if` `(A[i][j] - A[i][``0``] - ``                    ``A[``0``][j] + A[``0``][``0``] != ``0``)``                    ``return` `-``1``;``     ` `        ``// If countOpsation is possible``        ``// calculate total countOpsation``        ``int` `result = ``0``;``         ` `        ``for` `(``int` `i = ``0``; i < n; i++)``            ``result += Math.abs(A[i][``0``]);``             ` `        ``for` `(``int` `j = ``0``; j < m; j++)``            ``result += Math.abs(A[``0``][j] - A[``0``][``0``]);``             ` `        ``return` `(result);``    ``}``     ` `    ``// Driver code``    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `A[][] = { {``1``, ``1``, ``1``},``                      ``{``1``, ``1``, ``1``},``                      ``{``1``, ``1``, ``1``} };``                     ` `        ``int` `B[][] = { {``1``, ``2``, ``3``},``                      ``{``4``, ``5``, ``6``},``                      ``{``7``, ``8``, ``9``} };``                     ` `        ``System.out.println(countOps(A, B, ``3``, ``3``)) ;`` ` `    ``}``}`` ` `// This code is contributed by KRV.`

## Python3

 `# Python3 program to find number of``# countOpsation to make two matrix``# equals``def` `countOps(A, B, m, n):`` ` `    ``# Update matrix A[][] so that only``    ``# A[][] has to be countOpsed``    ``for` `i ``in` `range``(n):``        ``for` `j ``in` `range``(m):``            ``A[i][j] ``-``=` `B[i][j];`` ` `    ``# Check necessary condition for ``    ``# condition for existence of full``    ``# countOpsation``    ``for` `i ``in` `range``(``1``, n):``        ``for` `j ``in` `range``(``1``, n):``            ``if` `(A[i][j] ``-` `A[i][``0``] ``-``                ``A[``0``][j] ``+` `A[``0``][``0``] !``=` `0``):``                ``return` `-``1``;`` ` `    ``# If countOpsation is possible``    ``# calculate total countOpsation``    ``result ``=` `0``;`` ` `    ``for` `i ``in` `range``(n):``        ``result ``+``=` `abs``(A[i][``0``]);`` ` `    ``for` `j ``in` `range``(m):``        ``result ``+``=` `abs``(A[``0``][j] ``-` `A[``0``][``0``]);`` ` `    ``return` `(result);`` ` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ``A ``=` `[[``1``, ``1``, ``1``],``         ``[``1``, ``1``, ``1``],``         ``[``1``, ``1``, ``1``]];`` ` `    ``B ``=` `[[``1``, ``2``, ``3``],``         ``[``4``, ``5``, ``6``],``         ``[``7``, ``8``, ``9``]];``          ` `    ``print``(countOps(A, B, ``3``, ``3``));`` ` `# This code is contributed by Rajput-Ji`

## C#

 `// C# program to find number of``// countOpsation to make two matrix``// equals``using` `System;`` ` `class` `GFG ``{``     ` `    ``static` `int` `countOps(``int` `[,]A, ``int` `[,]B,``                        ``int` `m, ``int` `n)``    ``{``         ` `        ``// Update matrix A[][] so that only``        ``// A[][] has to be countOpsed``        ``for` `(``int` `i = 0; i < n; i++)``            ``for` `(``int` `j = 0; j < m; j++)``                ``A[i, j] -= B[i, j];``     ` `        ``// Check necessary condition for ``        ``// condition for existence of full``        ``// countOpsation``        ``for` `(``int` `i = 1; i < n; i++)``            ``for` `(``int` `j = 1; j < m; j++)``                ``if` `(A[i, j] - A[i, 0] - ``                    ``A[0, j] + A[0, 0] != 0)``                    ``return` `-1;``     ` `        ``// If countOpsation is possible``        ``// calculate total countOpsation``        ``int` `result = 0;``         ` `        ``for` `(``int` `i = 0; i < n; i++)``            ``result += Math.Abs(A[i, 0]);``             ` `        ``for` `(``int` `j = 0; j < m; j++)``            ``result += Math.Abs(A[0, j] - A[0, 0]);``             ` `        ``return` `(result);``    ``}``     ` `    ``// Driver code``    ``public` `static` `void` `Main ()``    ``{``        ``int` `[,]A = { {1, 1, 1},``                     ``{1, 1, 1},``                     ``{1, 1, 1} };``                         ` `        ``int` `[,]B = { {1, 2, 3},``                     ``{4, 5, 6},``                     ``{7, 8, 9} };``                         ` `    ``Console.Write(countOps(A, B, 3, 3)) ;`` ` `    ``}``}`` ` `// This code is contributed by nitin mittal.`

## PHP

 ``

Output:
```12
```

Time Complexity: O (n*m)

This article is contributed by Shivam Pradhan (anuj_charm). If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up