# Find number of transformation to make two Matrix Equal

• Difficulty Level : Hard
• Last Updated : 07 Jul, 2022

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:

1. Select any one matrix out of two matrices.
2.  Choose either row/column of the selected matrix.
3.  Increment every element of select row/column by 1.

Examples :

```Input :
A[2][2]: 1 1
1 1
B[2][2]: 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[2][2]: 1 1
1 0
B[2][2]: 1 2
3 4
Output : -1
Explanation : No transformation will make A and B equal.```

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[2][2] : 1 1
1 1
B[2][2] : 1 2
3 4
After subtraction, A[][] becomes,
A[2][2] : 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][0] – A[0][j] + A[0][0] != 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][0] - A[0][j] + A[0][0] != 0)
return -1;

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

Implementation:

## 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][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 += ``abs``(A[i][0]);``    ``for` `(``int` `j = 0; j < m; j++)``        ``result += ``abs``(A[0][j] - A[0][0]);``    ``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;``}`

## C

 `// C program to find``// number of countOpsation``// to make two matrix equals``#include ` `#define MAX 1000` `int` `abs``(``int` `a)``{``  ``int` `abs` `= a;``  ``if``(``abs` `< 0)``    ``abs` `= ``abs` `* (-1);``  ``return` `abs``;``}` `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][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 += ``abs``(A[i][0]);``    ``for` `(``int` `j = 0; j < m; j++)``        ``result += ``abs``(A[0][j] - A[0][0]);``    ``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}};``    ``printf``(``"%d"``,countOps(A, B, 3, 3));``    ``return` `0;``}` `// This code is contributed by kothavvsaakash.`

## 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

``````
<?php
// PHP program to find
// number of countOpsation
// to make two matrix equals

function countOps(\$A, \$B,
\$m, \$n)
{
\$MAX = 1000;

// Update matrix A[][]
// so that only A[][]
// has to be countOpsed
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 countOpsation
for (\$i = 1; \$i < \$n; \$i++)
for (\$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
\$result = 0;
for (\$i = 0; \$i < \$n; \$i++)
\$result += abs(\$A[\$i][0]);
for (\$j = 0; \$j < \$m; \$j++)
\$result += abs(\$A[0][\$j] - \$A[0][0]);
return (\$result);
}

// Driver code
\$A = array(array(1, 1, 1),
array(1, 1, 1),
array(1, 1, 1));

\$B = array(array(1, 2, 3),
array(4, 5, 6),
array(7, 8, 9));
echo countOps(\$A, \$B, 3, 3) ;

// This code is contributed by nitin mittal.
?>

``````

## Javascript

 ``

Output

`12`

Time Complexity: O (n*m)
Auxiliary Space: O(1)

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

My Personal Notes arrow_drop_up