Given a lower triangular matrix Mat[][], the task is to store the matrix using column-major mapping.
Lower Triangular Matrix: A Lower Triangular Matrix is a square matrix in which the lower triangular part of a matrix consists of non-zero elements and the upper triangular part consists of 0s. The Lower Triangular Matrix for a 2D matrix Mat[][] is mathematically defined as:
- If i < j, set Mat[i][j] = 0.
- If i >= j, set Mat[i][j] > 0.
Illustration:
Below is a 5×5 lower triangular matrix. In general, such matrices can be stored in a 2D array, but when it comes to matrices of large size, it is not a good choice because of its high memory consumption due to the storage of unwanted 0s.
Such a matrix can be implemented in an optimized manner.
The efficient way to store the lower triangular matrix of size N:
- Count of non-zero elements = 1 + 2 + 3 + … + N = N * (N + 1) /2.
- Count of 0s = N2 – (N * (N + 1) /2 = (N * (N – 1)/2.
Now let see how to represent lower triangular matrices in the program. Notice that storing 0s must be avoided to reduce memory consumption. As calculated, for storing non-zero elements, N*(N + 1)/2 space is needed. Taking the above example, N = 5. Array of size 5 * (5 + 1)/2 = 15 is required to store the non-zero elements.
Now, elements of the 2D matrix can be stored in a 1D array, column by column, as shown below:
Apart from storing the elements in an array, a procedure for extracting the element corresponding to the row and column number is also required. Using Column-Major-Mapping for storing a lower triangular matrix, the element at index Mat[i][j] can be represented as:
Index of Mat[i][j] matrix in the array A[] = [n*(j-1)-(((j-2)*(j-1))/2)+ (i-j))]
Below is the implementation of the above article:
// C++ program for the above approach #include <bits/stdc++.h> #include<stdio.h> using namespace std;
// Dimensions of the matrix const int N = 5;
// Structure of a memory // efficient matrix struct Matrix {
int * A;
int size;
}; // Function to set the // values in the Matrix void Set( struct Matrix* m, int i,
int j, int x)
{ if (i >= j)
m->A[((m->size)*(j-1)-(((j-2)
*(j-1))/2)+(i-j))] = x;
} // Function to store the // values in the Matrix int Get( struct Matrix m, int i, int j)
{ if (i >= j)
return m.A[((m.size)*(j-1)-(((j-2)
*(j-1))/2)+(i-j))];
else
return 0;
} // Function to display the // elements of the matrix void Display( struct Matrix m)
{ // Traverse the matrix
for ( int i = 1; i <= m.size; i++)
{
for ( int j = 1; j <= m.size; j++)
{
if (i >= j)
cout<< m.A[((m.size)*(j-1)-(((j-2)
*(j-1))/2)+(i-j))] << " " ;
else
cout<< "0 " ;
}
cout<<endl;
}
} // Function to generate an efficient matrix struct Matrix createMat( int Mat[N][N])
{ // Declare efficient Matrix
struct Matrix mat;
// Initialize the Matrix
mat.size = N;
mat.A = ( int *) malloc (
mat.size * (mat.size + 1) / 2
* sizeof ( int ));
// Set the values in matrix
for ( int i = 1; i <= mat.size; i++) {
for ( int j = 1; j <= mat.size; j++) {
Set(&mat, i, j, Mat[i - 1][j - 1]);
}
}
// Return the matrix
return mat;
} // Driver Code int main()
{ // Given Input
int Mat[5][5] = { { 1, 0, 0, 0, 0 },
{ 1, 2, 0, 0, 0 },
{ 1, 2, 3, 0, 0 },
{ 1, 2, 3, 4, 0 },
{ 1, 2, 3, 4, 5 } };
// Function call to create a memory
// efficient matrix
struct Matrix mat = createMat(Mat);
// Function call to
// print the Matrix
Display(mat);
return 0;
} // This code is contributed by rrrtnx. |
// C program for the above approach #include <stdio.h> #include <stdlib.h> // Dimensions of the matrix const int N = 5;
// Structure of a memory // efficient matrix struct Matrix {
int * A;
int size;
}; // Function to set the // values in the Matrix void Set( struct Matrix* m, int i,
int j, int x)
{ if (i >= j)
m->A[((m->size)*(j-1)-(((j-2)
*(j-1))/2)+(i-j))] = x;
} // Function to store the // values in the Matrix int Get( struct Matrix m, int i, int j)
{ if (i >= j)
return m.A[((m.size)*(j-1)-(((j-2)
*(j-1))/2)+(i-j))];
else
return 0;
} // Function to display the // elements of the matrix void Display( struct Matrix m)
{ // Traverse the matrix
for ( int i = 1; i <= m.size; i++)
{
for ( int j = 1; j <= m.size; j++)
{
if (i >= j)
printf ( "%d " ,
m.A[((m.size)*(j-1)-(((j-2)
*(j-1))/2)+(i-j))]);
else
printf ( "0 " );
}
printf ( "\n" );
}
} // Function to generate an efficient matrix struct Matrix createMat( int Mat[N][N])
{ // Declare efficient Matrix
struct Matrix mat;
// Initialize the Matrix
mat.size = N;
mat.A = ( int *) malloc (
mat.size * (mat.size + 1) / 2
* sizeof ( int ));
// Set the values in matrix
for ( int i = 1; i <= mat.size; i++) {
for ( int j = 1; j <= mat.size; j++) {
Set(&mat, i, j, Mat[i - 1][j - 1]);
}
}
// Return the matrix
return mat;
} // Driver Code int main()
{ // Given Input
int Mat[5][5] = { { 1, 0, 0, 0, 0 },
{ 1, 2, 0, 0, 0 },
{ 1, 2, 3, 0, 0 },
{ 1, 2, 3, 4, 0 },
{ 1, 2, 3, 4, 5 } };
// Function call to create a memory
// efficient matrix
struct Matrix mat = createMat(Mat);
// Function call to
// print the Matrix
Display(mat);
return 0;
} |
import java.util.Arrays;
class Matrix {
// Structure of a memory
// efficient matrix
int size;
int [][] matrix;
public Matrix( int size) {
this .size = size;
this .matrix = new int [size][size];
}
// Function to set the
// values in the Matrix
public void set( int i, int j, int x) {
if (i >= j) {
matrix[i][j] = x;
}
}
// Function to store the
// values in the Matrix
public int get( int i, int j) {
if (i >= j) {
return matrix[i][j];
} else {
return 0 ;
}
}
// Function to display the
// elements of the matrix
public void display() {
// Traverse the matrix
for ( int [] row : matrix) {
System.out.println(Arrays.toString(row));
}
}
} public class Main {
// Function to generate an efficient matrix
public static Matrix createMat( int [][] mat) {
int n = mat.length;
Matrix matrix = new Matrix(n);
// Set the values in matrix
for ( int i = 0 ; i < n; i++) {
for ( int j = 0 ; j < n; j++) {
matrix.set(i, j, mat[i][j]);
}
}
// Return the matrix
return matrix;
}
public static void main(String[] args) {
// Driver Code
int [][] mat = {
{ 1 , 0 , 0 , 0 , 0 },
{ 1 , 2 , 0 , 0 , 0 },
{ 1 , 2 , 3 , 0 , 0 },
{ 1 , 2 , 3 , 4 , 0 },
{ 1 , 2 , 3 , 4 , 5 }
};
// Function call to create a memory
// efficient matrix
Matrix m = createMat(mat);
// Function call to
// print the Matrix
m.display();
}
} |
class Matrix:
def __init__( self , size):
self .size = size
self .matrix = [[ 0 for _ in range (size)] for __ in range (size)]
def set ( self , i, j, x):
if i > = j:
self .matrix[i][j] = x
def get( self , i, j):
if i > = j:
return self .matrix[i][j]
else :
return 0
def display( self ):
for row in self .matrix:
print (row)
def create_mat(mat):
n = len (mat)
matrix = Matrix(n)
for i in range (n):
for j in range (n):
matrix. set (i, j, mat[i][j])
return matrix
if __name__ = = '__main__' :
mat = [[ 1 , 0 , 0 , 0 , 0 ],
[ 1 , 2 , 0 , 0 , 0 ],
[ 1 , 2 , 3 , 0 , 0 ],
[ 1 , 2 , 3 , 4 , 0 ],
[ 1 , 2 , 3 , 4 , 5 ]]
m = create_mat(mat)
m.display()
|
using System;
class Matrix
{ // Structure of a memory
// efficient matrix
private int size;
private int [,] matrix;
public Matrix( int size)
{
this .size = size;
this .matrix = new int [size, size];
}
// Function to set the
// values in the Matrix
public void Set( int i, int j, int x)
{
if (i >= j)
{
matrix[i, j] = x;
}
}
// Function to store the
// values in the Matrix
public int Get( int i, int j)
{
if (i >= j)
{
return matrix[i, j];
}
else
{
return 0;
}
}
// Function to display the
// elements of the matrix
public void Display()
{
// Traverse the matrix
for ( int i = 0; i < size; i++)
{
for ( int j = 0; j < size; j++)
{
if (i >= j)
{
Console.Write(matrix[i, j] + " " );
}
else
{
Console.Write( "0 " );
}
}
Console.WriteLine();
}
}
} class Program
{ // Function to generate an efficient matrix
public static Matrix CreateMat( int [,] mat)
{
int n = mat.GetLength(0);
Matrix matrix = new Matrix(n);
// Set the values in matrix
for ( int i = 0; i < n; i++)
{
for ( int j = 0; j < n; j++)
{
matrix.Set(i, j, mat[i, j]);
}
}
// Return the matrix
return matrix;
}
static void Main( string [] args)
{
// Driver Code
int [,] mat = {
{1, 0, 0, 0, 0},
{1, 2, 0, 0, 0},
{1, 2, 3, 0, 0},
{1, 2, 3, 4, 0},
{1, 2, 3, 4, 5}
};
// Function call to create a memory
// efficient matrix
Matrix m = CreateMat(mat);
// Function call to
// print the Matrix
m.Display();
}
} |
// Dimensions of the matrix const N = 5; // Structure of a memory // efficient matrix class Matrix { constructor() {
this .A = new Array();
this .size = 0;
}
} // Function to set the // values in the Matrix function Set(m, i, j, x) {
if (i >= j) {
m.A[m.size * (j - 1) - ((j - 2) * (j - 1)) / 2 + (i - j)] = x;
}
} // Function to store the // values in the Matrix function Get(m, i, j) {
if (i >= j) {
return m.A[m.size * (j - 1) - ((j - 2) * (j - 1)) / 2 + (i - j)];
} else {
return 0;
}
} // Function to display the // elements of the matrix function Display(m) {
// Traverse the matrix
for (let i = 1; i <= m.size; i++) {
let row = "" ;
for (let j = 1; j <= m.size; j++) {
if (i >= j) {
row += m.A[m.size * (j - 1) - ((j - 2) * (j - 1)) / 2 + (i - j)] + " " ;
} else {
row += "0 " ;
}
}
console.log(row);
}
} // Function to generate an efficient matrix function createMat(Mat) {
// Declare efficient Matrix
let mat = new Matrix();
// Initialize the Matrix
mat.size = N;
mat.A = new Array(mat.size * (mat.size + 1) / 2).fill(0);
// Set the values in matrix
for (let i = 1; i <= mat.size; i++) {
for (let j = 1; j <= mat.size; j++) {
Set(mat, i, j, Mat[i - 1][j - 1]);
}
}
// Return the matrix
return mat;
} // Driver Code let Mat = [ [1, 0, 0, 0, 0],
[1, 2, 0, 0, 0],
[1, 2, 3, 0, 0],
[1, 2, 3, 4, 0],
[1, 2, 3, 4, 5],
]; // Function call to create a memory // efficient matrix let mat = createMat(Mat); // Function call to // print the Matrix Display(mat); |
1 0 0 0 0 1 2 0 0 0 1 2 3 0 0 1 2 3 4 0 1 2 3 4 5
Time Complexity: O(N2)
Auxiliary Space: O(N2)