Minimum number of steps to convert a given matrix into Diagonally Dominant Matrix
Given a matrix of order NxN, the task is to find the minimum number of steps to convert given matrix into Diagonally Dominant Matrix. In each step, the only operation allowed is to decrease or increase any element by 1.
Examples:
Input: mat[][] = {{3, 2, 4}, {1, 4, 4}, {2, 3, 4}}
Output: 5
Sum of the absolute values of elements of row 1 except
the diagonal element is 3 more than abs(arr[0][0]).
1 more than abs(arr[1][1]) in the second row
and 1 more than abs(arr[2][2]) in the third row.
Hence, 3 + 1 + 1 = 5
Input: mat[][] = {{1, 2, 4, 0}, {1, 3, 4, 2}, {3, 3, 4, 2}, {-1, 0, 1, 4}}
Output: 13
Approach:
- A square matrix is said to be diagonally dominant matrix if for every row of the matrix, the magnitude of the diagonal entry in a row is larger than or equal to the sum of the magnitudes of all the other (non-diagonal) entries in that row.
- The minimum number of steps required to convert a given matrix into the diagonally dominant matrix can be calculated depending upon two case:
- If the sum of the absolute value of all elements of a row except diagonal element is greater than the absolute value of diagonal element then the difference between these two values will be added to the result.
- Else no need to add anything in the result as in that case row satisfies the condition for a diagonally dominant matrix.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
#define N 3
int findStepsForDDM( int arr[][N])
{
int result = 0;
for ( int i = 0; i < N; i++) {
int sum = 0;
for ( int j = 0; j < N; j++)
sum += abs (arr[i][j]);
sum -= abs (arr[i][i]);
if ( abs (arr[i][i]) < abs (sum))
result += abs ( abs (arr[i][i]) - abs (sum));
}
return result;
}
int main()
{
int arr[N][N] = { { 3, -2, 1 },
{ 1, -3, 2 },
{ -1, 2, 4 } };
cout << findStepsForDDM(arr);
return 0;
}
|
Java
class GFG
{
final static int N = 3 ;
static int findStepsForDDM( int arr[][])
{
int result = 0 ;
for ( int i = 0 ; i < N; i++)
{
int sum = 0 ;
for ( int j = 0 ; j < N; j++)
sum += Math.abs(arr[i][j]);
sum -= Math.abs(arr[i][i]);
if (Math.abs(arr[i][i]) < Math.abs(sum))
result += Math.abs(Math.abs(arr[i][i]) - Math.abs(sum));
}
return result;
}
public static void main (String[] args)
{
int arr[][] = { { 3 , - 2 , 1 },
{ 1 , - 3 , 2 },
{ - 1 , 2 , 4 } };
System.out.println(findStepsForDDM(arr));
}
}
|
Python3
N = 3
def findStepsForDDM(arr):
result = 0
for i in range (N):
sum = 0
for j in range (N):
sum + = abs (arr[i][j])
sum - = abs (arr[i][i])
if ( abs (arr[i][i]) < abs ( sum )):
result + = abs ( abs (arr[i][i]) - abs ( sum ))
return result
arr = [ [ 3 , - 2 , 1 ],
[ 1 , - 3 , 2 ],
[ - 1 , 2 , 4 ] ]
print (findStepsForDDM(arr))
|
C#
using System;
class GFG
{
static int N = 3 ;
static int findStepsForDDM( int [,]arr)
{
int result = 0;
for ( int i = 0; i < N; i++)
{
int sum = 0;
for ( int j = 0; j < N; j++)
sum += Math.Abs(arr[i,j]);
sum -= Math.Abs(arr[i,i]);
if (Math.Abs(arr[i,i]) < Math.Abs(sum))
result += Math.Abs(Math.Abs(arr[i,i]) - Math.Abs(sum));
}
return result;
}
static public void Main ()
{
int [,]arr = { { 3, -2, 1 },
{ 1, -3, 2 },
{ -1, 2, 4 } };
Console.WriteLine(findStepsForDDM(arr));
}
}
|
Javascript
<script>
let N = 3 ;
function findStepsForDDM(arr)
{
let result = 0;
for (let i = 0; i < N; i++)
{
let sum = 0;
for (let j = 0; j < N; j++)
sum += Math.abs(arr[i][j]);
sum -= Math.abs(arr[i][i]);
if (Math.abs(arr[i][i]) < Math.abs(sum))
result += Math.abs(Math.abs(arr[i][i]) - Math.abs(sum));
}
return result;
}
let arr = [[ 3, -2, 1 ],
[ 1, -3, 2 ],
[ -1, 2, 4 ]];
document.write(findStepsForDDM(arr));
</script>
|
Time complexity: O(N2)
Auxiliary Space: O(1)
Last Updated :
31 Mar, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...