Related Articles
Maximum increase in value of Matrix to keep maximum rows and columns unchanged
• Last Updated : 30 Sep, 2020

Given a matrix mat[][] of dimensionM*N, the task is to find the total maximum possible value must be increased to each cell(say mat[i][j]) such that maximum element of row i and column j remains unchanged.

Examples:

Input: N = 3, M = 3, mat[][] = { {4, 1, 3}, {3, 1, 1}, {2, 2, 0} }
Output:
Explanation: The given matrix is:
4 1 3
3 1 1
2 2 0
Row-wise maximum values are: {4, 3, 2}
Column-wise maximum values are: {4, 2, 3}
After increasing the elements without affecting the row-wise and column-wise maximum values:
4 2 3
3 2 3
2 2 2
The total increase in corresponding cells of the two matrix is ((0 + 1 + 0) + (0 + 1 + 2) + (0 + 0 + 2)) = 6.

Input: M = 4, N = 4, mat[][] = { {3, 0, 8, 4}, {2, 4, 5, 7}, {9, 2, 6, 3}, {0, 3, 1, 0} }
Output: 35
Explanation:
The given matrix is:
3 0 8 4
2 4 5 7
9 2 6 3
0 3 1 0
Row-wise maximum values are: {8, 7, 9, 3}
Column-wise maximum values are: {9, 4, 8, 7}
After increasing the elements without affecting the row-wise and column-wise maximum values:
8 4 8 7
7 4 7 7
9 4 8 7
3 3 3 3
The total increase in corresponding cells of the two matrix is ((5 + 4 + 0 + 3) + (5 + 0 + 2 + 0) + (0 + 2 + 2 + 4) + (3 + 0 + 2 + 3)) = 35.

Approach:

• Traverse along each row and column of the given matrix to store the maximum values for each row and column.
• Traverse the given matrix mat[][] and for each cell(say mat[i][j]) and add the difference between the current element and the minimum value of the maximum values along its corresponding row and column as:

difference = min(row[i], cols[j]) – mat[i][j]

• The total values added in the above operations is the required result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to find the maximum increment` `// in each cell of the given matrix such` `// that maximum and minimum value remains` `// unaffected` `int` `maxIncrease(vector >& matrix)` `{` `    ``// Get the row of matrix as M` `    ``int` `M = matrix.size();`   `    ``// Get the column of matrix as N` `    ``int` `N = matrix.size();`   `    ``// To store the row-wise` `    ``// maximum values` `    ``vector<``int``> maxRowVal(M, 0);`   `    ``// To store the column-wise` `    ``// maximum values` `    ``vector<``int``> maxColVal(N, 0);`   `    ``// Traverse along the matrix` `    ``// to store the maximum values` `    ``// of each row and column` `    ``for` `(``int` `i = 0; i < M; i++) {`   `        ``for` `(``int` `j = 0; j < N; j++) {`   `            ``// Store the row-wise` `            ``// maximum values` `            ``maxRowVal[i] = max(maxRowVal[i],` `                               ``matrix[i][j]);`   `            ``// Store the column-wise` `            ``// maximum values` `            ``maxColVal[j] = max(maxColVal[j],` `                               ``matrix[i][j]);` `        ``}` `    ``}`   `    ``// Calculate the total amount` `    ``// of increment` `    ``int` `totalIncrease = 0;`   `    ``// Traverse matrix mat[][]` `    ``for` `(``int` `i = 0; i < M; i++) {`   `        ``for` `(``int` `j = 0; j < N; j++) {`   `            ``// The maximum possible` `            ``// amount to increase` `            ``int` `needToIncrease` `                ``= min(maxRowVal[i],` `                      ``maxColVal[j])` `                  ``- matrix[i][j];`   `            ``// Total increased value` `            ``totalIncrease += needToIncrease;` `        ``}` `    ``}`   `    ``// Return the total` `    ``// increased value` `    ``return` `totalIncrease;` `}`   `// Driver Code` `int` `main()` `{` `    ``// Given matrix` `    ``vector > matrix{ { 3, 0, 8, 4 },` `                                 ``{ 2, 4, 5, 7 },` `                                 ``{ 9, 2, 6, 3 },` `                                 ``{ 0, 3, 1, 0 } };`   `    ``// Function Call` `    ``cout << maxIncrease(matrix)` `         ``<< endl;` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;` `class` `GFG{`   `// Function to find the maximum increment` `// in each cell of the given matrix such` `// that maximum and minimum value remains` `// unaffected` `static` `int` `maxIncrease(``int` `[][] matrix)` `{` `    ``// Get the row of matrix as M` `    ``int` `M = matrix.length;`   `    ``// Get the column of matrix as N` `    ``int` `N = matrix[``0``].length;`   `    ``// To store the row-wise` `    ``// maximum values` `    ``int` `[]maxRowVal = ``new` `int``[M];`   `    ``// To store the column-wise` `    ``// maximum values` `    ``int` `[]maxColVal = ``new` `int``[N];` `    `  `    ``// Traverse along the matrix` `    ``// to store the maximum values` `    ``// of each row and column` `    ``for` `(``int` `i = ``0``; i < M; i++) ` `    ``{` `        ``for` `(``int` `j = ``0``; j < N; j++) ` `        ``{`   `            ``// Store the row-wise` `            ``// maximum values` `            ``maxRowVal[i] = Math.max(maxRowVal[i],` `                                    ``matrix[i][j]);`   `            ``// Store the column-wise` `            ``// maximum values` `            ``maxColVal[j] = Math.max(maxColVal[j],` `                                    ``matrix[i][j]);` `        ``}` `    ``}`   `    ``// Calculate the total amount` `    ``// of increment` `    ``int` `totalIncrease = ``0``;`   `    ``// Traverse matrix mat[][]` `    ``for` `(``int` `i = ``0``; i < M; i++) ` `    ``{` `        ``for` `(``int` `j = ``0``; j < N; j++) ` `        ``{`   `            ``// The maximum possible` `            ``// amount to increase` `            ``int` `needToIncrease = Math.min(maxRowVal[i],` `                                          ``maxColVal[j]) - ` `                                          ``matrix[i][j];`   `            ``// Total increased value` `            ``totalIncrease += needToIncrease;` `        ``}` `    ``}`   `    ``// Return the total` `    ``// increased value` `    ``return` `totalIncrease;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``// Given matrix` `    ``int` `[][] matrix = { { ``3``, ``0``, ``8``, ``4` `},` `                        ``{ ``2``, ``4``, ``5``, ``7` `},` `                        ``{ ``9``, ``2``, ``6``, ``3` `},` `                        ``{ ``0``, ``3``, ``1``, ``0` `} };`   `    ``// Function Call` `    ``System.out.print(maxIncrease(matrix) + ``"\n"``);` `}` `}`   `// This code is contributed by gauravrajput1`

## Python3

 `# Python3 program for the above approach`   `# Function to find the maximum increment` `# in each cell of the given matrix such` `# that maximum and minimum value remains` `# unaffected` `def` `maxIncrease(matrix):` `    `  `    ``# Get the row of matrix as M` `    ``M ``=` `len``(matrix)`   `    ``# Get the column of matrix as N` `    ``N ``=` `len``(matrix[``0``])`   `    ``# To store the row-wise` `    ``# maximum values` `    ``maxRowVal ``=` `[``0``] ``*` `M`   `    ``# To store the column-wise` `    ``# maximum values` `    ``maxColVal ``=` `[``0``] ``*` `(N)`   `    ``# Traverse along the matrix` `    ``# to store the maximum values` `    ``# of each row and column` `    ``for` `i ``in` `range``(M):` `        ``for` `j ``in` `range``(N):`   `            ``# Store the row-wise` `            ``# maximum values` `            ``maxRowVal[i] ``=` `max``(maxRowVal[i],` `                               ``matrix[i][j])`   `            ``# Store the column-wise` `            ``# maximum values` `            ``maxColVal[j] ``=` `max``(maxColVal[j],` `                               ``matrix[i][j])`   `    ``# Calculate the total amount` `    ``# of increment` `    ``totalIncrease ``=` `0`   `    ``# Traverse matrix mat[][]` `    ``for` `i ``in` `range``(M):` `        ``for` `j ``in` `range``(N):`   `            ``# The maximum possible` `            ``# amount to increase` `            ``needToIncrease ``=` `(``min``(maxRowVal[i],` `                                  ``maxColVal[j]) ``-` `                                  ``matrix[i][j])`   `            ``# Total increased value` `            ``totalIncrease ``+``=` `needToIncrease`   `    ``# Return the total` `    ``# increased value` `    ``return` `totalIncrease`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    `  `    ``# Given matrix` `    ``matrix ``=` `[ [ ``3``, ``0``, ``8``, ``4` `],` `               ``[ ``2``, ``4``, ``5``, ``7` `],` `               ``[ ``9``, ``2``, ``6``, ``3` `],` `               ``[ ``0``, ``3``, ``1``, ``0` `] ]`   `    ``# Function call` `    ``print``(maxIncrease(matrix))`   `# This code is contributed mohit kumar 29`

## C#

 `// C# program for the above approach` `using` `System;`   `class` `GFG{`   `// Function to find the maximum increment` `// in each cell of the given matrix such` `// that maximum and minimum value remains` `// unaffected` `static` `int` `maxIncrease(``int` `[,] matrix)` `{` `    `  `    ``// Get the row of matrix as M` `    ``int` `M = matrix.GetLength(0);`   `    ``// Get the column of matrix as N` `    ``int` `N = matrix.GetLength(1);`   `    ``// To store the row-wise` `    ``// maximum values` `    ``int` `[]maxRowVal = ``new` `int``[M];`   `    ``// To store the column-wise` `    ``// maximum values` `    ``int` `[]maxColVal = ``new` `int``[N];` `    `  `    ``// Traverse along the matrix` `    ``// to store the maximum values` `    ``// of each row and column` `    ``for``(``int` `i = 0; i < M; i++) ` `    ``{` `       ``for``(``int` `j = 0; j < N; j++)` `       ``{` `          `  `          ``// Store the row-wise` `          ``// maximum values` `          ``maxRowVal[i] = Math.Max(maxRowVal[i],` `                                  ``matrix[i, j]);` `          `  `          ``// Store the column-wise` `          ``// maximum values` `          ``maxColVal[j] = Math.Max(maxColVal[j],` `                                  ``matrix[i, j]);` `       ``}` `    ``}`   `    ``// Calculate the total amount` `    ``// of increment` `    ``int` `totalIncrease = 0;`   `    ``// Traverse matrix [,]mat` `    ``for``(``int` `i = 0; i < M; i++) ` `    ``{` `       ``for``(``int` `j = 0; j < N; j++)` `       ``{` `           `  `          ``// The maximum possible` `          ``// amount to increase` `          ``int` `needToIncrease = Math.Min(maxRowVal[i],` `                                        ``maxColVal[j]) - ` `                                        ``matrix[i, j];` `          `  `          ``// Total increased value` `          ``totalIncrease += needToIncrease;` `       ``}` `    ``}` `    `  `    ``// Return the total` `    ``// increased value` `    ``return` `totalIncrease;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    `  `    ``// Given matrix` `    ``int` `[,] matrix = { { 3, 0, 8, 4 },` `                       ``{ 2, 4, 5, 7 },` `                       ``{ 9, 2, 6, 3 },` `                       ``{ 0, 3, 1, 0 } };`   `    ``// Function call` `    ``Console.Write(maxIncrease(matrix) + ``"\n"``);` `}` `}`   `// This code is contributed by 29AjayKumar`

Output:

```35

```

Time Complexity: O(M*N) My Personal Notes arrow_drop_up
Recommended Articles
Page :