E125. Метод Гаусса решения системы линейных уравнений

Источник: e-maxx.ru/algo, страница PDF 409.

Дана система

линейных алгебраических уравнений (СЛАУ) с

неизвестными. it is required решить эту

систему: определить, сколько решений она имеет (ни одного, одно или бесконечно много), а если она имеет хотя бы одно 해법, то find любое из них. Формально 문제 ставится следующим образом: решить систему:

где коэффициенты

и

известны, а

переменные

— искомые неизвестные. Удобно матричное представление этой задачи:

где

— матрица

, составленная из коэффициентов

,

и

— векторы-столбцы высоты

. Стоит отметить, что СЛАУ может быть не над полем действительных чисел, а над полем по модулю какого-

либо числа

, т.е.: — 알고리즘 Гаусса работает и для таких систем тоже (но этот случай будет рассмотрен ниже в отдельном разделе).

알고리즘 Гаусса

Строго говоря, описываемый ниже метод правильно называть методом "Гаусса-Жордана" (Gauss-Jordan elimination), поскольку он является вариацией метода Гаусса, описанной геодезистом Вильгельмом Жорgivenм в 1887 г. (стоит отметить, что Вильгельм Жордан не является автором ни теоремы Жордана о кривых, ни жорgivenвой алгебры — всё это три разных учёных-однофамильца; кроме того, по всей видимости, более правильной является транскрипция "Йордан", но написание "Жордан" уже закрепилось в русской литературе). Также интересно заметить, что одновременно с Жорgivenм (а по некоторым данным даже раньше него) этот 알고리즘 придумал Класен (B.-I. Clasen).

Базовая схема

Кратко говоря, 알고리즘 заключается в последовательном исключении переменных из каждого уравнения до тех пор, пока в каждом уравнении не останется только по одной переменной. Если

, то

можно говорить, что 알고리즘 Гаусса-Жордана стремится привести матрицу

системы к единичной матрице —

ведь после того как матрица стала единичной, 해법 системы очевидно — 해법 единственно и

задаётся получившимися коэффициентами

. При этом 알고리즘 основывается на двух простых эквивалентных преобразованиях системы: во-первых, можно обменивать два уравнения, а во-вторых, любое уравнение можно заменить линейной комбинацией этой строки (с ненулевым коэффициентом) и других строк (с произвольными коэффициентами). На первом шаге 알고리즘 Гаусса-Жордана делит первую строку на коэффициент

. Затем 알고리즘

прибавляет первую строку к остальным 문자열м с такими коэффициентами, чтобы их коэффициенты в первом столбце обращались в нули — для этого, очевидно, при прибавлении первой строки к

-ой надо домножать её на

. При каждой операции с матрицей

(деление на number, прибавление к одной строке другой)

соответствующие операции производятся и с вектором

; в некотором смысле, он ведёт себя, как если бы он был

-ым столбцом матрицы

.

В итоге, по окончании первого шага первый столбец матрицы

станет единичным (т.е. будет содержать единицу в

первой строке и нули в остальных). Аналогично производится второй шаг 알고리즘а, только теперь рассматривается второй столбец и вторая 문자열:

сначала вторая 문자열 делится на

, а затем отнимается от всех остальных строк с такими коэффициентами,

чтобы обнулять второй столбец матрицы

. И так далее, пока мы не обработаем все строки или все столбцы матрицы

. Если

, то по построению

알고리즘а очевидно, что матрица

получится единичной, что нам и требовалось.

Поиск опорного elementа (pivoting)

Разумеется, описанная выше схема неполна. Она работает только в том случае, если на каждом

-ом шаге element

отличен от нуля — иначе мы просто не сможем добиться обнуления остальных коэффициентов в текущем

столбце путём прибавления к ним

-ой строки. Чтобы сделать 알고리즘 работающим в таких случаях, как раз и существует процесс выбора опорного elementа (на английском языке это называется одним словом "pivoting"). Он заключается в том, что производится перестановка строк и/или столбцов матрицы, чтобы в нужном elementе оказалось ненулевое number. Заметим, что перестановка строк значительно проще реализуется на компьютере, чем перестановка столбцов: ведь при обмене местами двух каких-то столбцов надо запомнить, что эти две переменных обменялись местами, чтобы затем, при восстановлении ответа, правильно восстановить, какой ответ к какой переменной относится. При перестановке строк никаких таких дополнительных действий производить не надо. К счастью, для корректности метода достаточно одних только обменов строк (т.н. "partial pivoting", в отличие от "full pivoting", когда обмениваются и строки, и столбцы). Но какую же именно строку следует выбирать для обмена? И правда ли, что поиск опорного elementа надо делать только тогда, когда текущий element

нулевой?

Общего ответа на этот вопрос не существует. Есть разнообразные эвристики, однако самой эффективной из них (по соотношению простоты и отдачи) является такая эвристика: в качестве опорного elementа следует брать наибольший по модулю element, причём производить поиск опорного elementа и обмен с ним надо всегда, а

не только когда это необходимо (т.е. не только тогда, когда

).

Иными словами, перед выполнением

-ой фазы 알고리즘а Гаусса-Жордана с эвристикой partial pivoting необходимо

find в

-ом столбце среди elementов с индексами от

до

maximum по модулю, и обменять строку с

этим elementом с

-ой строкой. Во-первых, эта эвристика позволит решить СЛАУ, даже если по ходу решения будет случаться так, что element . Во-вторых, что весьма немаловажно, эта эвристика улучшает численную устойчивость 알고리즘а Гаусса-Жордана.

Без этой эвристики, даже если система такова, что на каждой

-ой фазе

— 알고리즘 Гаусса-

Жордана отработает, но в итоге накапливающаяся погрешность может оказаться настолько огромной, что даже

для матриц размера около

погрешность будет превосходить сам ответ.

Вырожденные случаи

Итак, если останавливаться на 알고리즘е Гаусса-Жордана с partial pivoting, то, утверждается, если

и

система неврождена (т.е. имеет ненулевой определитель, что означает, что она имеет единственное 해법), то описанный выше 알고리즘 полностью отработает и придёт к единичной матрице

(증명 этого, т.е. того,

что ненулевой опорный element всегда будет находиться, здесь не приводится).

Рассмотрим теперь общий случай — когда

и

не обязательно равны. Предположим, что опорный element на

-ом шаге не нашёлся. Это означает, что в

-ом столбце все строки, начиная с текущей, содержат нули. Утверждается,

что в этом случае эта

-ая переменная не может быть определена, и является независимой

переменной (может принимать произвольное значение). Чтобы 알고리즘 Гаусса-Жордана продолжил свою работу для всех последующих переменных, в такой ситуации надо просто пропустить текущий

-ый столбец,

не увеличивая при этом номер текущей строки (можно сказать, что мы виртуально удаляем -ый столбец матрицы). Итак, некоторые переменные в процессе работы 알고리즘а могут оказываться независимыми. Понятно, что

когда количество

переменных больше количества

уравнений, то как минимум

переменных

обнаружатся независимыми. В целом, если обнаружилась хотя бы одна независимая переменная, то она может принимать произвольное значение, в то время как остальные (зависимые) переменные будут выражаться через неё. Это означает, что, когда мы работаем в поле действительных чисел, система потенциально имеет бесконечно много решений (если мы рассматриваем СЛАУ по модулю, то number решений будет равно этому модулю в степени количества независимых переменных). Впрочем, следует быть аккуратным: надо помнить о том, что даже если были обнаружены независимые переменные, тем не менее СЛАУ может не иметь решений вовсе. Это происходит, когда в оставшихся необработанными уравнениях (тех, до которых 알고리즘 Гаусса-Жордана не дошёл, т.е. это уравнения, в которых остались только независимые переменные) есть хотя бы один ненулевой свободный член. Впрочем, проще это проверить явной подстановкой найденного решения: всем независимыми переменным присвоить нулевые значения, зависимым переменным присвоить найденные значения, и подставить это 해법 в текущую СЛАУ.

구현

Приведём здесь реализацию 알고리즘а Гаусса-Жордана с эвристикой partial pivoting (выбором опорного elementа как максимума по столбцу).

На 입력 функции

передаётся сама матрица системы

. Последний столбец матрицы

— это в наших

старых обозначениях столбец

свободных коэффициентов (так сделано для удобства программирования — т.к. в

самом 알고리즘е все операции со свободными коэффициентами

повторяют операции с матрицей

).

Функция returns number решений системы (

,

или

) (бесконечность обозначена в коде специальной

константой

, которой можно задать любое большое значение). Если хотя бы одно 해법 существует, то

оно returnsся в векторе

.

int gauss (vector < vector<double> > a, vector<double> & ans) {

int n = (int) a.size();

int m = (int) a[0].size() - 1;

vector<int> where (m, -1);

for (int col=0, row=0; col<m && row<n; ++col) {

int sel = row;

for (int i=row; i<n; ++i)

if (abs (a[i][col]) > abs (a[sel][col]))

sel = i;

if (abs (a[sel][col]) < EPS)

continue;

for (int i=col; i<=m; ++i)

swap (a[sel][i], a[row][i]);

where[col] = row;

for (int i=0; i<n; ++i)

if (i != row) {

double c = a[i][col] / a[row][col];

for (int j=col; j<=m; ++j)

a[i][j] -= a[row][j] * c;

}

++row;

}

ans.assign (m, 0);

for (int i=0; i<m; ++i)

if (where[i] != -1)

ans[i] = a[where[i]][m] / a[where[i]][i];

for (int i=0; i<n; ++i) {

double sum = 0;

for (int j=0; j<m; ++j)

sum += ans[j] * a[i][j];

if (abs (sum - a[i][m]) > EPS)

return 0;

}

for (int i=0; i<m; ++i)

if (where[i] == -1)

return INF;

return 1;

}

В функции поддерживаются два указателя — на текущий столбец

и текущую строку

.

Также заводится вектор

, в котором для каждой переменной записано, в какой строке должна она получиться (иными словами, для каждого столбца записан номер строки, в которой этот столбец отличен от нуля). Этот вектор нужен, поскольку некоторые переменные могли не "определиться" в ходе решения (т.е. это независимые переменные, которым можно присвоить произвольное значение — на예제, в приведённой реализации это нули). 구현 использует технику partial pivoting, производя поиск строки с максимальным по модулю elementом,

и переставляя затем эту строку в позицию

(хотя явную перестановку строк можно заменить обменом двух индексов в некотором 배열е, на практике это не даст реального выигрыша, т.к. на обмены тратится операций). В реализации в целях простоты текущая 문자열 не делится на опорный element — так что в итоге по окончании работы 알고리즘а матрица становится не единичной, а диагональной (впрочем, по-видимому, деление строки на ведущий element позволяет несколько уменьшить возникающие погрешности). После нахождения решения оно подставляется обратно в матрицу — чтобы проверить, имеет ли система хотя бы одно 해법 или нет. Если проверка найденного решения прошла успешно, то функция returns

или

—

в зависимости от того, есть ли хотя бы одна независимая переменная или нет.

Asymptotic complexity

Оценим асимптотику полученного 알고리즘а. 알고리즘 состоит из

фаз, на каждой из которых происходит:

● поиск и перестановка опорного elementа — за время

при использовании эвристики "partial

pivoting" (поиск максимума в столбце)

● если опорный element в текущем столбце был найден — то прибавление текущего уравнения ко всем

остальным уравнениям — за время

Очевидно, первый пункт имеет меньшую асимптотику, чем второй. Заметим также, что второй пункт выполняется не

более

раз — столько, сколько может быть зависимых переменных в СЛАУ.

Таким образом, итоговая Asymptotic complexity 알고리즘а принимает вид

.

При

эта оценка превращается в

. Заметим, что когда СЛАУ рассматривается не в поле действительных чисел, а в поле по модулю два, то систему можно решать гораздо быстрее — об этом см. ниже в разделе "해법 СЛАУ по модулю".

Более точная оценка числа действий

Для простоты выкладок будем считать, что

. Как мы уже знаем, 실행 시간 всего 알고리즘а фактически определяется временем, затрачиваемым на исключение текущего уравнения из остальных.

Это может происходить на каждом из

шагов, при этом текущее уравнение прибавляется ко всем

остальным. При прибавлении работа идёт только со столбцами, начиная с текущего. Таким образом, в сумме получается операций.

Дополнения

Ускорение 알고리즘а: разделение его на прямой и обратный ход

Добиться двукратного ускорения 알고리즘а можно, рассмотрев другую его версию, более классическую, когда 알고리즘 разбивается на фазы прямого и обратного хода. В целом, в отличие от описанного выше 알고리즘а, можно приводить матрицу не к диагональному виду, а к треугольному виду — когда все elementы строго ниже главной диагонали равны нулю. Система с треугольной матрицей решается тривиально — сначала из последнего уравнения сразу находится значение последней переменной, затем найденное значение подставляется в предпоследнее уравнение и находится значение предпоследней переменной, и так далее. Этот процесс и называется обратным ходом 알고리즘а Гаусса. Прямой ход 알고리즘а Гаусса — это 알고리즘, аналогичный описанному выше 알고리즘у Гаусса-Жордана, за одним исключением: текущая переменная исключается не из всех уравнений, а только из уравнений после текущего. В результате этого действительно получается не диагональная, а треугольная матрица. Разница в том, что прямой ход работает быстрее 알고리즘а Гаусса-Жордана — поскольку в среднем он делает в два раза меньше прибавлений одного уравнения к другому. Обратный ход работает за

, что в любом

случае асимптотически быстрее прямого хода.

Таким образом, если

, то данный 알고리즘 будет делать уже

операций — что в два раза

меньше 알고리즘а Гаусса-Жордана.

해법 СЛАУ по модулю

Для решения СЛАУ по модулю можно применять описанный выше 알고리즘, он сохраняет свою корректность. Разумеется, теперь становится ненужным использовать какие-то хитрые техники выбора опорного elementа — достаточно find любой ненулевой element в текущем столбце. Если модуль простой, то никаких сложностей вообще не возникает — происходящие по ходу работы 알고리즘а Гаусса деления не создают особых проблем. Особенно замечателен модуль, равный двум: для него все операции с матрицей можно производить очень эффективно. На예제, отнимание одной строки от другой по модулю два — это на самом деле их симметрическая разность ("xor"). Таким образом, весь 알고리즘 можно значительно ускорить, сжав всю матрицу в битовые маски и оперируя только ими. Приведём здесь новую реализацию основной части 알고리즘а Гаусса- Жордана, используя стандартный контейнер C++ "bitset":

int gauss (vector < bitset<N> > a, int n, int m, bitset<N> & ans) {

vector<int> where (m, -1);

for (int col=0, row=0; col<m && row<n; ++col) {

for (int i=row; i<n; ++i)

if (a[i][col]) {

swap (a[i], a[row]);

break;

}

if (! a[row][col])

continue;

where[col] = row;

for (int i=0; i<n; ++i)

if (i != row && a[i][col])

a[i] ^= a[row];

++row;

} Как можно заметить, 구현 стала даже немного короче, при том, что она значительно быстрее старой реализации

— а именно, быстрее в

раза за счёт битового сжатия. Также следует отметить, что 해법 систем по модулю два на практике работает очень быстро, поскольку случаи, когда от одной строки надо отнимать другую, происходят достаточно редко (на разреженных матрицах этот 알고리즘 может работать за время скорее порядка квадрата от размера, чем куба). Если модуль произвольный (не обязательно простой), то всё становится несколько сложнее. Понятно, что пользуясь Китайской теоремой об остатках, мы сводим задачу с произвольным модулем только к модулям вида "степень простого". [ дальнейший текст был скрыт, т.к. это непроверенная информация — возможно,

неправильный способ решения ]

Наконец, рассмотрим вопрос числа решений СЛАУ по модулю. Ответ на него достаточно прост:

number решений равно

, где

— модуль,

— number независимых переменных.

Немного о различных способах выбора опорного elementа

Как уже говорилось выше, однозначного ответа на этот вопрос нет. Эвристика "partial pivoting", которая заключалась в поиске максимального elementа в текущем столбце, работает на практике весьма неплохо. Также оказывается, что она даёт практически тот же результат, что и "full pivoting" — когда опорный element ищется среди elementов целой подматрицы — начиная с текущей строки и с текущего столбца. Но интересно отметить, что обе эти эвристики с поиском максимального elementа, фактически, очень зависят от того, насколько были промасштабированы исходные уравнения. На예제, если одно из уравнений системы умножить на миллион, то это уравнение почти наверняка будет выбрано в качестве ведущего на первом же шаге. Это кажется достаточно странным, поэтому логичен переход к немного более сложной эвристике — так называемому "implicit pivoting". Эвристика implicit pivoting заключается в том, что elementы различных строк сравниваются так, как если бы обе строки были пронормированы таким образом, что maximum по модулю element в них был бы равен единице. Для реализации этой техники надо просто поддерживать текущий максимум в каждой строке (либо поддерживать каждую строку так, чтобы максимум в ней был равен единице по модулю, но это может привести к увеличению накапливаемой погрешности).

Улучшение найденного ответа

Поскольку, несмотря на различные эвристики, 알고리즘 Гаусса-Жордана всё равно может приводить к

большим погре

...

using System;
using System.Collections.Generic;
using System.Linq;

public static class AlgorithmDraft
{
    // Auto-generated C# draft from the original e-maxx C/C++ listing. Review before production use.
    int gauss (vector < vector<double> > a, vector<double> & ans) {
            int n = (int) a.size();
            int m = (int) a[0].size() - 1;
            List<int> where (m, -1);
            for (int col=0, row=0; col<m && row<n; ++col) {
                    int sel = row;
                    for (int i=row; i<n; ++i)
                            if (abs (a[i][col]) > abs (a[sel][col]))
                                    sel = i;
                    if (abs (a[sel][col]) < EPS)
                            continue;
                    for (int i=col; i<=m; ++i)
                            swap (a[sel][i], a[row][i]);
                    where[col] = row;
                    for (int i=0; i<n; ++i)
                            if (i != row) {
                                    double c = a[i][col] / a[row][col];
                                    for (int j=col; j<=m; ++j)
                                            a[i][j] -= a[row][j] * c;
                            }
                    ++row;
            }
            ans.assign (m, 0);
            for (int i=0; i<m; ++i)
                    if (where[i] != -1)
                            ans[i] = a[where[i]][m] / a[where[i]][i];
            for (int i=0; i<n; ++i) {
                    double sum = 0;
                    for (int j=0; j<m; ++j)
                            sum += ans[j] * a[i][j];
                    if (abs (sum - a[i][m]) > EPS)
                            return 0;
            }
            for (int i=0; i<m; ++i)
                    if (where[i] == -1)
                            return INF;
            return 1;
    }
    int gauss (vector < bitset<N> > a, int n, int m, bitset<N> & ans) {
            List<int> where (m, -1);
            for (int col=0, row=0; col<m && row<n; ++col) {
                    for (int i=row; i<n; ++i)
                            if (a[i][col]) {
                                    swap (a[i], a[row]);
                                    break;
                            }
                    if (! a[row][col])
                            continue;
                    where[col] = row;
                    for (int i=0; i<n; ++i)
                            if (i != row && a[i][col])
                                    a[i] ^= a[row];
                    ++row;
            }
}

int gauss (vector < vector<double> > a, vector<double> & ans) {
        int n = (int) a.size();
        int m = (int) a[0].size() - 1;
        vector<int> where (m, -1);
        for (int col=0, row=0; col<m && row<n; ++col) {
                int sel = row;
                for (int i=row; i<n; ++i)
                        if (abs (a[i][col]) > abs (a[sel][col]))
                                sel = i;
                if (abs (a[sel][col]) < EPS)
                        continue;
                for (int i=col; i<=m; ++i)
                        swap (a[sel][i], a[row][i]);
                where[col] = row;
                for (int i=0; i<n; ++i)
                        if (i != row) {
                                double c = a[i][col] / a[row][col];
                                for (int j=col; j<=m; ++j)
                                        a[i][j] -= a[row][j] * c;
                        }
                ++row;
        }
        ans.assign (m, 0);
        for (int i=0; i<m; ++i)
                if (where[i] != -1)
                        ans[i] = a[where[i]][m] / a[where[i]][i];
        for (int i=0; i<n; ++i) {
                double sum = 0;
                for (int j=0; j<m; ++j)
                        sum += ans[j] * a[i][j];
                if (abs (sum - a[i][m]) > EPS)
                        return 0;
        }
        for (int i=0; i<m; ++i)
                if (where[i] == -1)
                        return INF;
        return 1;
}
int gauss (vector < bitset<N> > a, int n, int m, bitset<N> & ans) {
        vector<int> where (m, -1);
        for (int col=0, row=0; col<m && row<n; ++col) {
                for (int i=row; i<n; ++i)
                        if (a[i][col]) {
                                swap (a[i], a[row]);
                                break;
                        }
                if (! a[row][col])
                        continue;
                where[col] = row;
                for (int i=0; i<n; ++i)
                        if (i != row && a[i][col])
                                a[i] ^= a[row];
                ++row;
        }

import java.util.*;
import java.math.*;

public class AlgorithmDraft {
    // Auto-generated Java draft from the original e-maxx C/C++ listing. Review before production use.
    int gauss (vector < vector<double> > a, vector<double> & ans) {
            int n = (int) a.size();
            int m = (int) a[0].size() - 1;
            ArrayList<Integer> where (m, -1);
            for (int col=0, row=0; col<m && row<n; ++col) {
                    int sel = row;
                    for (int i=row; i<n; ++i)
                            if (abs (a[i][col]) > abs (a[sel][col]))
                                    sel = i;
                    if (abs (a[sel][col]) < EPS)
                            continue;
                    for (int i=col; i<=m; ++i)
                            swap (a[sel][i], a[row][i]);
                    where[col] = row;
                    for (int i=0; i<n; ++i)
                            if (i != row) {
                                    double c = a[i][col] / a[row][col];
                                    for (int j=col; j<=m; ++j)
                                            a[i][j] -= a[row][j] * c;
                            }
                    ++row;
            }
            ans.assign (m, 0);
            for (int i=0; i<m; ++i)
                    if (where[i] != -1)
                            ans[i] = a[where[i]][m] / a[where[i]][i];
            for (int i=0; i<n; ++i) {
                    double sum = 0;
                    for (int j=0; j<m; ++j)
                            sum += ans[j] * a[i][j];
                    if (abs (sum - a[i][m]) > EPS)
                            return 0;
            }
            for (int i=0; i<m; ++i)
                    if (where[i] == -1)
                            return INF;
            return 1;
    }
    int gauss (vector < bitset<N> > a, int n, int m, bitset<N> & ans) {
            ArrayList<Integer> where (m, -1);
            for (int col=0, row=0; col<m && row<n; ++col) {
                    for (int i=row; i<n; ++i)
                            if (a[i][col]) {
                                    swap (a[i], a[row]);
                                    break;
                            }
                    if (! a[row][col])
                            continue;
                    where[col] = row;
                    for (int i=0; i<n; ++i)
                            if (i != row && a[i][col])
                                    a[i] ^= a[row];
                    ++row;
            }
}