# Calculate determinant of a Matrix using Pivotal Condensation Method

Last Updated : 04 Jul, 2022

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:

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

• 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 following:
• 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 using namespace std; // Function to swap valuesvoid swap(float& i, float& j){    float temp = i;    i = j;    j = temp;} // Function to find the determinant// of matrix M[][]float determinantOfMatrix(    vector > 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 Codeint main(){    // Given matrix    vector > 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 approachimport 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 Codepublic 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

 # Python 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 Codeif __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 approachusing System; public class GFG{ // Function to find the determinant// of matrix [,]Mstatic 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 Codepublic 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

## Javascript

 

Output:
30

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

Previous
Next