Ndtyjky

I used this pseudo-code:

 h := 1 /* Initialization of the pivot row */

 k := 1 /* Initialization of the pivot column */

 while h ≤ m and k ≤ n

   /* Find the k-th pivot: */

   i_max := argmax (i = h ... m, abs(A[i, k]))

   if A[i_max, k] = 0

     /* No pivot in this column, pass to next column */

     k := k+1

   else

      swap rows(h, i_max)

      /* Do for all rows below pivot: */

      for i = h + 1 ... m:

         f := A[i, k] / A[h, k]

         /* Fill with zeros the lower part of pivot column: */

         A[i, k]  := 0

         /* Do for all remaining elements in current row: */

         for j = k + 1 ... n:

            A[i, j] := A[i, j] - A[h, j] * f

      /* Increase pivot row and column */

      h := h+1 

      k := k+1

To write this code (Gaussian Elimination):

#include <iostream>

#include <vector>

#include <algorithm>

#include <cmath>



typedef std::vector<std::vector<int>> matrix;

typedef long long ll;



void inverse_matrix(matrix &mat)

{

    ll h = 1, k =1;

    auto m = mat.size(), n = mat[0].size();





    while (h <= m && k <= n)

    {

        ll i_max = 0;

        for (ll i = h; i <= m; ++i)

        {

            i_max = std::fmax(i, std::abs(mat[i][k]));

        }



        if (mat[i_max][k] == 0)

        {

            ++k;

        }



        auto temp = mat[h];

        mat[h] = mat[i_max];

        mat[i_max] = temp;



        for (auto j = h + 1; j <= m; ++j)

        {

            auto f = mat[j][k] / mat[h][k];

            mat[j][k] = 0;



            for (auto v = k + 1; v <= n; ++v)

            {

                mat[j][v] = mat[j][v] - mat[h][j] * f;

            }

        }



        ++h;

        ++k;

    }

}



int main() {

    matrix mat = {{2, 2}, {4, 5}};

    inverse_matrix(mat);



    return 0;

}

But I get this error:

terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc

This application has requested the Runtime to terminate it in an unusual way.
Please contact the application's support team for more information.

What's wrong? I copied the pseudo-code to a tee.

You have a few issues here.

First of, you did not copy the code correctly (for instance, line 5 of the pseudo-code - that's including the comment line). What you should be looking for is the index of the maximal value, instead you are comparing the value with the index. To make matters worse, you do it in a way that only ends up storing the final comparison, because you overwrite all of the other results.

Second, the pseudo-code runs indices from 1-n, as you know C++ does not, instead we use 0-based indexing. As for the error, std::bad_alloc suggests an allocation failed, that's most likely the line: auto temp = mat[h];, where h is out of bounds due to your 1-based counting approach.

Perhaps as a side note, you could also replace your swap with std::swap, this might improve the performance slightly as it will probably avoid copying and rely on moving instead.