Оптимизация алгоритма вычисления определителя матрицы

//Определитель вычисляется по формуле det( A ) = a( i, j ) * ( -1 )^( i + j ) * M( i, j ) ( a^b - "а" в степени "b" )
//Минор ищется рекурсивно до тех пор, пока его порядок не стал равен 2 ( тогда в силу вступает формула a( 1, 1 ) * a( 2, 2 ) - a( 1, 2 ) * a( 2, 1 ) )
//На каждом шаге определитель находится путем разложения по наиболее "оптимизированной" строке ( в которой больше всего нулей ) данной на вход матрицы
 
//Примечание: в этих комментариях считается, что коэф. пробегают значения от 1 до n ( в самой программе они пробегают значения от 0 до n-1 )
 
#include <time.h>
#include <iostream>
#include <math.h>
 
using namespace std;
 
//Функция нахождения у матрицы порядка size минора M( str, stb ) ( возвращает минор в матричном представлении )
int **FIND_Minor( int **matrix, int size, int str, int stb )
{
    int **minor = new int *[ size - 1 ];
    
    //m_str, m_stb - коэффициенты, с помощью которых строится сам минор
    int m_str = 0;
    int m_stb;
    for( int i = 0; i < size; i++ )
    {
        //Элементы из строки с номером str не записываются в минор
        if( i != str )
        {
            m_stb = 0;
            minor[ m_str ] = new int[ size - 1 ];
            for( int j = 0; j < size; j++ )
            {
                //Элементы из столбца с номером stb не записываются в минор
                if( j != stb )
                {
                    minor[ m_str ][ m_stb ] = matrix[ i ][ j ];
                    m_stb++;
                }
            }
            m_str++;
        }
    }
 
    return minor;
}
 
int FIND_Det( int **matrix, int size )
{
    //Проверка условия выхода из рекурсии
    if( size == 2 )
    {
        return matrix[ 0 ][ 0 ] * matrix[ 1 ][ 1 ] - matrix[ 0 ][ 1 ] * matrix[ 1 ][ 0 ];
    }
    else if( size == 1 )
    {
        return matrix[ 0 ][ 0 ];
    }
 
    //Момент оптимизации - ищем строку, в которой больше всего нулей, чтобы по ней находить определитель
    //Работает в связи с условием разложения по строке, которое пояснено ниже
    int max_0, str_0 = 0, max_0_b = 0;
    for( int i = 0; i < size; i++ )
    {
        max_0 = 0;
        for( int j = 0; j < size; j++ )
        {
            if( matrix[ i ][ j ] == 0 )
            {
                max_0++;
            }
        }
        if( max_0 > max_0_b )
        {
            str_0 = i;
            max_0_b = max_0;
        }
    }
 
    //Само рекурсивное разложение по строке
    int result = 0;
    for( int j = 0; j < size; j++ )
    {
        //Небольшой момент оптимизации - если текущий элемент в строке равен нулю, то дальше продолжать рекурсию нету смысла 
        //( т.к. произведение будет равно нулю в любом случае )
        if( matrix[ str_0 ][ j ] )
        {
            result += matrix[ str_0 ][ j ] * ( unsigned )pow( -1.f, ( unsigned )j ) * FIND_Det( FIND_Minor( matrix, size, str_0, j ), size - 1 );
        }
    }
 
    return result;
}
 
int main()
{
    srand( ( unsigned )time( NULL ) );
 
    float begin, end;
 
    int size;
    cout << "Enter size: ";
    cin >> size;
    int **matrix = new int*[ size ];
 
    char sw;
    cout << "\n1 - Typing automatically\n2 - Typing manually\n";
    cin >> sw;
 
    switch( sw )
    {
    case '1':
        cout << "\nMatrix:\n";
        for( int i = 0; i < size; i++ )
        {
            matrix[ i ] = new int[ size ];
            for( int j = 0; j < size; j++ )
            {
                matrix[ i ][ j ] = rand()%10;
                cout << matrix[ i ][ j ] << " ";
            }
            cout << "\n";
        }
        break;
 
    case '2':
        cout << "\nYour matrix:\n";
        for( int i = 0; i < size; i++ )
        {
            matrix[ i ] = new int[ size ];
            for( int j = 0; j < size; j++ )
            {
                cin >> matrix[ i ][ j ];
            }
        }
        break;
 
    default:
        cout << "\n";
        system( "pause" );
        return 0;
    }
 
    cout << "\nDeterminant = ";
    begin = clock();
    cout << FIND_Det( matrix, size ) << endl;
    end = clock();
 
    cout << "\nTask time - ";
    cout << ( end - begin ) / 1000 << " seconds" << endl;
 
    system( "pause" );
    return 0;
}

#include <iostream>
#include <cstdlib>
#include <cmath>
#include <ctime>
 
double**  Minor(double** matrix, int size, int i, int j)
{
    double** minor = new double*[size-1];
    for (int k = 0; k < size-1; k++)
        minor[k] = new double[size-1];
    for (int x = 0; x < size; x++)
        for (int y = 0; y < size; y++)
            {
                if (x < i && y < j)
                    minor[x][y] = matrix[x][y];
                else if (x > i && y > j)
                    minor[x-1][y-1] = matrix[x][y];
                else if (x > i)
                    minor[x-1][y] = matrix[x][y];
                else if (y > j)
                    minor[x][y-1] = matrix[x][y];
            }
    return minor;
}
 
double Determinant(double** matrix, int size)
{
    if (size == 1)
        return matrix[0][0];
    else if  (size == 2)
        return matrix[0][0]*matrix[1][1] - matrix[0][1]*matrix[1][0];
    double determinant = 0;
    for (int j = 0; j < size; j++)
    {
        if(!matrix[0][j]) continue;
        double** minor = Minor(matrix,size-1, 0, j);
        determinant += pow(-1.f,(j+1))*matrix[0][j]*Determinant(minor, size);
        for (int k = 0; k < size-1; k++)
        {
            delete[] minor[k];
            minor[k] = 0;
        }
        delete[] minor;
    }
    
    return determinant;
}
 
int main()
{
    setlocale(LC_ALL, "");
    srand(unsigned(time(NULL)));
    int size;
    std::cout << "Введите размер массива: ";
    std::cin >> size;
    double** arr = new double*[size];
    for (int i = 0; i < size; i++)
        arr[i] = new double[size];
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < size; j++)
        {
            arr[i][j] = rand() % 10;
            std::cout << arr[i][j] << " ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
    std::cout << "Определитель матрицы: " << Determinant(arr, size) << std::endl;
    for (int i = 0; i < size; i++)
    {
        delete[] arr[i];
        arr[i] = 0;
    }
    delete[] arr;
    
    return 0;
}

determinant += pow(-1.f,(j+1))*matrix[0][j]*Determinant(minor, size);