СЛАУ Гаусс

#include <iostream>
#include <iomanip>
#include <cmath>
#include <stdexcept>

using namespace std;

// Функция для выделения памяти под матрицу
double** allocate_matrix(int n, int m) {
    double** matrix = new double* [n];
    for (int i = 0; i < n; ++i) {
        matrix[i] = new double[m];
    }
    return matrix;
}

// Функция для освобождения памяти матрицы
void free_matrix(double** matrix, int n) {
    for (int i = 0; i < n; ++i) {
        delete[] matrix[i];
    }
    delete[] matrix;
}

// Функция ввода матрицы
void input(double** matrix, int* n, int* m) {
    cin >> *n >> *m;
    if (*n <= 0 || *m <= 0) {
        throw invalid_argument("Invalid matrix dimensions");
    }

    for (int i = 0; i < *n; ++i) {
        for (int j = 0; j < *m; ++j) {
            cin >> matrix[i][j];
        }
    }
}

// Функция вывода матрицы (для отладки)
void output(double** matrix, int n, int m) {
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cout << fixed << setprecision(6) << matrix[i][j];
            if (j < m - 1) cout << " ";
        }
        cout << endl;
    }
}

// Функция вывода корней
void output_roots(double* roots, int n) {
    for (int i = 0; i < n; ++i) {
        cout << fixed << setprecision(6) << roots[i];
        if (i < n - 1) cout << " ";
    }
    cout << endl;
}

// Функция решения СЛАУ методом Гаусса
int sle(double** matrix, int n, int m, double* roots) {
    // Прямой ход метода Гаусса
    for (int col = 0; col < n; ++col) {
        // Поиск ведущего элемента
        int max_row = col;
        for (int i = col + 1; i < n; ++i) {
            if (fabs(matrix[i][col]) > fabs(matrix[max_row][col])) {
                max_row = i;
            }
        }

        // Перестановка строк
        if (max_row != col) {
            for (int j = col; j < m; ++j) {
                swap(matrix[col][j], matrix[max_row][j]);
            }
        }

        // Проверка на нулевой ведущий элемент
        if (fabs(matrix[col][col]) < 1e-10) {
            return 0; // Система вырождена
        }

        // Нормализация текущей строки
        for (int j = col + 1; j < m; ++j) {
            matrix[col][j] /= matrix[col][col];
        }
        matrix[col][col] = 1.0;

        // Исключение переменной из других уравнений
        for (int i = 0; i < n; ++i) {
            if (i != col && fabs(matrix[i][col]) > 1e-10) {
                double factor = matrix[i][col];
                for (int j = col; j < m; ++j) {
                    matrix[i][j] -= matrix[col][j] * factor;
                }
            }
        }
    }

    // Проверка на совместность системы
    for (int i = 0; i < n; ++i) {
        bool all_zero = true;
        for (int j = 0; j < m - 1; ++j) {
            if (fabs(matrix[i][j]) > 1e-10) {
                all_zero = false;
                break;
            }
        }
        if (all_zero && fabs(matrix[i][m - 1]) > 1e-10) {
            return 0; // Система несовместна
        }
    }

    // Проверка на бесконечное количество решений
    if (n < m - 1) {
        return 0; // Бесконечное количество решений
    }

    // Обратный ход - получение решения
    for (int i = 0; i < n; ++i) {
        roots[i] = matrix[i][m - 1];
    }

    return 1; // Успешное решение
}

int main() {
    int n, m;
    double** matrix = nullptr;
    double* roots = nullptr;

    try {
        cin >> n >> m;
        if (n <= 0 || m <= 0 || m != n + 1) {
            throw runtime_error("Invalid input");
        }

        matrix = allocate_matrix(n, m);
        roots = new double[n];

        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                cin >> matrix[i][j];
            }
        }

        if (sle(matrix, n, m, roots)) {
            output_roots(roots, n);
        }
        else {
            cout << "n/a" << endl;
        }
    }
    catch (...) {
        cout << "n/a" << endl;
    }

    if (matrix) free_matrix(matrix, n);
    if (roots) delete[] roots;

    return 0;
}
Входные данные
3 4
1 1 1 2
4 5 3 7
2 7 7 9
Выходные данные
1.000000 0.000000 1.000000