Skip to content
Related Articles

Related Articles

Minimum steps required to convert the matrix into lower hessenberg matrix
  • Last Updated : 27 Apr, 2021

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: 
 

  • For a matrix to be Lower Hessenberg matrix all of its elements above super-diagonal must be equal zero, i.e Aij = 0 for all j > i+1..
  • The minimum number of steps required to convert a given matrix in the lower Hessenberg matrix is equal to the sum of the absolute values of all Aij for all j > i + 1.
  • The modulus value of the element is taken into account because both the increase and decrease of the element count as a single step.

Below is the implementation of the above approach: 
 

C++




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




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




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




// 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..

Javascript




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




My Personal Notes arrow_drop_up
Recommended Articles
Page :