Efficient method to store a Lower Triangular Matrix using Column-major mapping

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 = N² – (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:

Array to store Lower Triangular Elements

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

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

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

Output

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(N²)
Auxiliary Space: O(N²)