Skip to content
Related Articles

Related Articles

Calculate determinant of a Matrix using Pivotal Condensation Method
  • Last Updated : 02 Mar, 2021

Given a square matrix mat[][] of dimension N, the task is to find the determinant of the matrix using the pivot condensation method.

Examples:

Input: mat[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}
Output: 0
Explanation:
Performing R3 = R3 – R2 modifies the matrix mat[][] to {{1, 2, 3}, {4, 5, 6}, {1, 1, 1}}.
Performing R2 = R2 – R1 modifies the matrix mat[][] to {{1, 2, 3}, {1, 1, 1}, {1, 1, 1}}.
Now, the rows R2 and R3 are equal.
Therefore, the determinant will of the matrix becomes equal to zero (using the property of matrix).

Input: mat[][] = {{1, 0, 2, -1}, {3, 0, 0, 5}, {2, 1, 4, -3}, {1, 0, 5, 0}}
Output: 30

Approach: The idea is to use the Pivotal Condensation method to calculate the determinant of the matrix mat[][]. Below is the detailed explanation of the proposed method:



In this method of calculating the determinant of dimension N × N, square matrix:

  • First the matrix A[][] of dimension N*N is reduced to matrix B[][] of dimension (N – 1)*(N – 1) such that:

B_{(i, j)} = A_{(1, 1)} \times A_{(i+1, j+1)} - A_{(1, j+1)} \times B_{(i+1, 1)}

  • Then the determinant value of A[][] can be found out from matrix B[][] using the formula,

det(A) = det(B)\div A_{(1, 1)}^{N-2}

  • Now further reduce the matrix to (N – 2)*(N – 2) and calculate the determinant of matrix B[][].
  • And repeat the above process until the matrix becomes of dimension 2*2.
  • Then the determinant of the matrix of dimension 2×2 is calculated using formula det(A) = ad-bc for a matrix say A[][] as {{a, b}, {c, d}}.

Follow the steps below to solve the problem:

  • Initialize a variable, say D, to store the determinant of the matrix.
  • Iterate while N is greater than 2 and check for the follwoing:
    • Check if mat[0][0] is 0, then swap the current row with the next row such that mat[i][0] > 0 using the property of matrix.
    • Otherwise, if no row is found such that mat[i][0] > 0, then print zero.
    • Now, multiply D by pow(1 / mat[0][0], N – 2).
    • Calculate the next matrix, say B[][], of dimension (N – 1) x (N – 1) using the formula b[i – 1][j – 1] = mat[0][0 * mat[i][i] – mat[0][j] * mat[i][0].
    • Assign mat = B.
  • Multiply D by the determinant of the matrix mat[][] of dimension 2×2, i.e mat[0][0] * mat[1][1] – mat[0][j] * mat[i][0].
  • Finally, print the value stored in D.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to swap values
void swap(float& i, float& j)
{
    float temp = i;
    i = j;
    j = temp;
}
 
// Function to find the determinant
// of matrix M[][]
float determinantOfMatrix(
    vector<vector<float> > mat, int N)
{
    float mul = 1;
 
    // Iterate over N while N > 2
    while (N > 2) {
 
        // Store the reduced matrix
        // of dimension (N-1)x(N-1)
        float M[N - 1][N - 1];
 
        int next_index = 1;
 
        // Check if first element
        // of first row is zero
        while (mat[0][0] == 0) {
 
            if (mat[next_index][0] > 0) {
 
                // For swapping
                for (int k = 0; k < N; k++) {
                    swap(mat[0][k],
                         mat[next_index][k]);
                }
 
                // Update mul
                mul = mul * pow((-1),
                                (next_index));
            }
 
            else if (next_index == (N - 1))
                return 0;
            next_index++;
        }
 
        // Store the first element
        // of the matrix
        float p = mat[0][0];
 
        // Multiply the mul by
        // (1/p) to the power n-2
        mul = mul * pow(1 / p, N - 2);
 
        // Calculate the next matrix
        // of dimension (N-1) x (N-1)
        for (int i = 1; i < N; i++) {
            for (int j = 1; j < N; j++) {
 
                // Calculate each element of
                // the matrix from previous
                // matrix
                M[i - 1][j - 1] = mat[0][0]
                                      * mat[i][j]
                                  - mat[i][0]
                                        * mat[0][j];
            }
        }
 
        // Copy elements of the matrix
        // M into mat to use it in
        // next iteration
        for (int i = 0;
             i < (N - 1); i++) {
 
            for (int j = 0;
                 j < (N - 1); j++) {
 
                mat[i][j] = M[i][j];
            }
        }
 
        // Decrement N by one
        N--;
    }
 
    // Calculate the determinant
    // of reduced 2x2 matrix and
    // multiply it with factor mul
    float D = mul * (mat[0][0]
                         * mat[1][1]
                     - mat[0][1]
                           * mat[1][0]);
 
    // Print the determinant
    cout << D;
}
 
// Driver Code
int main()
{
    // Given matrix
    vector<vector<float> > mat = { { 1, 0, 2, -1 },
                                   { 3, 0, 0, 5 },
                                   { 2, 1, 4, -3 },
                                   { 1, 0, 5, 0 } };
 
    // Size of the matrix
    int N = mat.size();
 
    // Function Call
    determinantOfMatrix(mat, N);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
class GFG
{
 
// Function to find the determinant
// of matrix M[][]
static void determinantOfMatrix(int[][] mat, int N)
{
    int mul = 1;
 
    // Iterate over N while N > 2
    while (N > 2)
    {
 
        // Store the reduced matrix
        // of dimension (N-1)x(N-1)
        int [][]M = new int[N - 1][N - 1];
        int next_index = 1;
 
        // Check if first element
        // of first row is zero
        while (mat[0][0] == 0)
        {
            if (mat[next_index][0] > 0)
            {
 
                // For swapping
                for (int k = 0; k < N; k++)
                {
                    int temp = mat[0][k];
                    mat[0][k] = mat[next_index][k];
                    mat[next_index][k] = temp;
 
                }
 
                // Update mul
                mul = (int) (mul * Math.pow((-1),
                                (next_index)));
            }
            else if (next_index == (N - 1))
                return;
            next_index++;
        }
 
        // Store the first element
        // of the matrix
        int p = mat[0][0];
 
        // Multiply the mul by
        // (1/p) to the power n-2
        mul = (int) (mul * Math.pow(1 / p, N - 2));
 
        // Calculate the next matrix
        // of dimension (N-1) x (N-1)
        for (int i = 1; i < N; i++)
        {
            for (int j = 1; j < N; j++)
            {
 
                // Calculate each element of
                // the matrix from previous
                // matrix
                M[i - 1][j - 1] = mat[0][0]
                                      * mat[i][j]
                                  - mat[i][0]
                                        * mat[0][j];
            }
        }
 
        // Copy elements of the matrix
        // M into mat to use it in
        // next iteration
        for (int i = 0;
             i < (N - 1); i++)
        {
            for (int j = 0;
                 j < (N - 1); j++)
            {
                mat[i][j] = M[i][j];
            }
        }
 
        // Decrement N by one
        N--;
    }
 
    // Calculate the determinant
    // of reduced 2x2 matrix and
    // multiply it with factor mul
    int D = mul * (mat[0][0]
                         * mat[1][1]
                     - mat[0][1]
                           * mat[1][0]);
 
    // Print the determinant
    System.out.print(D);
}
 
// Driver Code
public static void main(String[] args)
{
   
    // Given matrix
    int[][] mat = { { 1, 0, 2, -1 },
                                   { 3, 0, 0, 5 },
                                   { 2, 1, 4, -3 },
                                   { 1, 0, 5, 0 } };
 
    // Size of the matrix
    int N = mat.length;
 
    // Function Call
    determinantOfMatrix(mat, N);
}
}
 
// This code is contributed by 29AjayKumar

Python3




# Pyhton 3 program for the above approach
 
# Function to find the determinant
# of matrix M[][]
def determinantOfMatrix(mat, N):
    mul = 1
 
    # Iterate over N while N > 2
    while (N > 2):
        # Store the reduced matrix
        # of dimension (N-1)x(N-1)
        M = [[0 for i in range(N-1)] for j in range(N-1)]
 
        next_index = 1
 
        # Check if first element
        # of first row is zero
        while (mat[0][0] == 0):
            if (mat[next_index][0] > 0):
                # For swapping
                for k in range(N):
                    temp = mat[0][k]
                    mat[0][k] = mat[next_index][k]
                    mat[next_index][k] = temp
 
                # Update mul
                mul = mul * pow((-1),(next_index))
 
            elif (next_index == (N - 1)):
                return 0;
            next_index += 1
 
        # Store the first element
        # of the matrix
        p = mat[0][0]
 
        # Multiply the mul by
        # (1/p) to the power n-2
        mul = mul * pow(1 / p, N - 2)
 
        # Calculate the next matrix
        # of dimension (N-1) x (N-1)
        for i in range(1,N):
            for j in range(1,N,1):
                # Calculate each element of
                # the matrix from previous
                # matrix
                M[i - 1][j - 1] = mat[0][0] * mat[i][j] - mat[i][0] * mat[0][j]
 
        # Copy elements of the matrix
        # M into mat to use it in
        # next iteration
        for i in range(N - 1):
            for j in range(N - 1):
                mat[i][j] = M[i][j]
 
        # Decrement N by one
        N -= 1
 
    # Calculate the determinant
    # of reduced 2x2 matrix and
    # multiply it with factor mul
    D = mul * (mat[0][0] * mat[1][1] - mat[0][1] * mat[1][0])
 
    # Print the determinant
    print(int(D))
 
# Driver Code
if __name__ == '__main__':
    # Given matrix
    mat = [[1, 0, 2, -1],[3, 0, 0, 5], [2, 1, 4, -3], [1, 0, 5, 0]]
 
    # Size of the matrix
    N = len(mat)
 
    # Function Call
    determinantOfMatrix(mat, N)
     
    # This code is contributed by bgangwar59.

C#




// C# program for the above approach
using System;
 
public class GFG
{
 
// Function to find the determinant
// of matrix [,]M
static void determinantOfMatrix(int[,] mat, int N)
{
    int mul = 1;
 
    // Iterate over N while N > 2
    while (N > 2)
    {
 
        // Store the reduced matrix
        // of dimension (N-1)x(N-1)
        int [,]M = new int[N - 1,N - 1];
        int next_index = 1;
 
        // Check if first element
        // of first row is zero
        while (mat[0,0] == 0)
        {
            if (mat[next_index,0] > 0)
            {
 
                // For swapping
                for (int k = 0; k < N; k++)
                {
                    int temp = mat[0,k];
                    mat[0,k] = mat[next_index,k];
                    mat[next_index,k] = temp;
 
                }
 
                // Update mul
                mul = (int) (mul * Math.Pow((-1),
                                (next_index)));
            }
            else if (next_index == (N - 1))
                return;
            next_index++;
        }
 
        // Store the first element
        // of the matrix
        int p = mat[0,0];
 
        // Multiply the mul by
        // (1/p) to the power n-2
        mul = (int) (mul * Math.Pow(1 / p, N - 2));
 
        // Calculate the next matrix
        // of dimension (N-1) x (N-1)
        for (int i = 1; i < N; i++)
        {
            for (int j = 1; j < N; j++)
            {
 
                // Calculate each element of
                // the matrix from previous
                // matrix
                M[i - 1,j - 1] = mat[0,0]
                                      * mat[i,j]
                                  - mat[i,0]
                                        * mat[0,j];
            }
        }
 
        // Copy elements of the matrix
        // M into mat to use it in
        // next iteration
        for (int i = 0;
             i < (N - 1); i++)
        {
            for (int j = 0;
                 j < (N - 1); j++)
            {
                mat[i,j] = M[i,j];
            }
        }
 
        // Decrement N by one
        N--;
    }
 
    // Calculate the determinant
    // of reduced 2x2 matrix and
    // multiply it with factor mul
    int D = mul * (mat[0,0]
                         * mat[1,1]
                     - mat[0,1]
                           * mat[1,0]);
 
    // Print the determinant
    Console.Write(D);
}
 
// Driver Code
public static void Main(String[] args)
{
   
    // Given matrix
    int[,] mat = { { 1, 0, 2, -1 },
                                   { 3, 0, 0, 5 },
                                   { 2, 1, 4, -3 },
                                   { 1, 0, 5, 0 } };
 
    // Size of the matrix
    int N = mat.GetLength(0);
 
    // Function Call
    determinantOfMatrix(mat, N);
}
}
 
// This code is contributed by Rajput-Ji

 
 

Output: 
30

 

Time Complexity: O(N3)
Auxiliary Space: O(N2) 

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :