Open In App

Minimum steps required to convert the matrix into lower hessenberg matrix

Given a matrix of order NxN, Find the minimum number of steps to convert given matrix into Lower Hessenberg matrix. In each step, the only operation allowed is to decrease or increase any element value by 1.
Examples:
 

Input: mat[][] = { 
{1, 2, 8}, 
{1, 3, 4}, 
{2, 3, 4}} 
Output:
Decrease the element a[0][2] 8 times. 
Now the matrix is lower Hessenberg.
Input: mat[][] = { 
{9, 2, 5, 5}, 
{12, 3, 4, 5}, 
{13, -3, 4, 2}, 
{-1, 10, 1, 4}} 
Output: 15 
 

 

Approach: 
 

Below is the implementation of the above approach: 
 




// C++ implementation of above approach
#include <bits/stdc++.h>
#define N 4
using namespace std;
 
// Function to count steps in
// conversion of matrix into upper
// Hessenberg matrix
int stepsRequired(int arr[][N])
{
    int result = 0;
    for (int i = 0; i < N; i++) {
 
        for (int j = 0; j < N; j++) {
            if (j > i + 1)
                result += abs(arr[i][j]);
        }
    }
    return result;
}
 
int main()
{
    int arr[N][N] = { 1, 2, 3, 2,
                      3, 1, 0, 3,
                      3, 2, 1, 3,
                      -3, 4, 2, 1 };
 
    cout << stepsRequired(arr);
    return 1;
}




// Java implementation of above approach
import java.io.*;
 
class GFG
{
     
static int N = 4;
 
// Function to count steps in
// conversion of matrix into upper
// Hessenberg matrix
static int stepsRequired(int arr[][])
{
    int result = 0;
    for (int i = 0; i < N; i++)
    {
 
        for (int j = 0; j < N; j++)
        {
            if (j > i + 1)
                result += Math.abs(arr[i][j]);
        }
    }
    return result;
}
 
// Driver code
public static void main (String[] args)
{
 
    int [][]arr = { {1, 2, 3, 2},
                    {3, 1, 0, 3},
                    {3, 2, 1, 3},
                    {-3, 4, 2, 1}
                    };
 
    System.out.println (stepsRequired(arr));
}
}
 
// The code is contributed by ajit.




# Python3 implementation of above approach
N = 4
 
# Function to count steps in
# conversion of matrix into upper
# Hessenberg matrix
def stepsRequired(arr):
    result = 0
    for i in range(N):
        for j in range(N):
            if (j > i + 1):
                result += abs(arr[i][j])
    return result
 
 
# Driver code
arr = [[1, 2, 3, 2],
        [3, 1, 0, 3],
        [3, 2, 1, 3],
        [-3, 4, 2, 1]]
 
print(stepsRequired(arr))
 
# This code is contributed by mohit kumar 29




// C# implementation of above approach
using System;
 
class GFG
{
 
static int N = 4;
 
// Function to count steps in
// conversion of matrix into upper
// Hessenberg matrix
static int stepsRequired(int [,]arr)
{
    int result = 0;
    for (int i = 0; i < N; i++)
    {
 
        for (int j = 0; j < N; j++)
        {
            if (j > i + 1)
                result += Math.Abs(arr[i,j]);
        }
    }
    return result;
}
 
// Driver code
static public void Main ()
{
     
    int [,]arr = { {1, 2, 3, 2},
                    {3, 1, 0, 3},
                    {3, 2, 1, 3},
                    {-3, 4, 2, 1}
                    };
 
    Console.Write(stepsRequired(arr));
}
}
 
// The code is contributed by Tushil..




<script>
// Java script implementation of above approach
let N = 4;
 
// Function to count steps in
// conversion of matrix into upper
// Hessenberg matrix
function stepsRequired(arr)
{
    let result = 0;
    for (let i = 0; i < N; i++)
    {
 
        for (let j = 0; j < N; j++)
        {
            if (j > i + 1)
                result += Math.abs(arr[i][j]);
        }
    }
    return result;
}
 
// Driver code
    let arr= [[1, 2, 3, 2],
                    [3, 1, 0, 3],
                    [3, 2, 1, 3],
                    [-3, 4, 2, 1]
                    ];
 
    document.write (stepsRequired(arr));
 
// This code is contributed by mohan pavan
 
</script>

Output: 
8

 

Time complexity: O(N*N)
 Auxiliary Space: O(1)


Article Tags :