Викиконспекты - Вклад участника [ru]

Стохастический градиентный спуск

2019-01-28T12:30:29Z

Nikitaevg:

'''Стохастический градиентный спуск''' (англ. ''stochastic gradient descent'') $-$ оптимизационный алгоритм, отличающийся от обычного [https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA градиентного спуска] тем, что градиент оптимизируемой функции считается на каждом шаге не как сумма градиентов от каждого элемента выборки, а как градиент от одного, случайно выбранного элемента.

== Обычный градиентный спуск ==
Для начала вспомним, как работает обычный градиентный спуск. Пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ $-$ конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>\{(x_1,y_1),\dots,(x_l,y_l)\}.</tex> Пусть семейство алгоритмов $a(x, {\bf w})$ имеет параметр вектор весов $\bf w$. И пускай мы выбрали какую-нибудь функцию потерь. Для $i$-го объекта выборки для алгоритма с весами ${\bf w}$ обозначим ее <tex> \mathscr{L}_i({\bf w}) </tex>. Необходимо минимизировать эмпирический риск, т.е. <tex>Q(w) = \sum\limits_{i=1}^l \mathscr{L}_i(w) \,\to\, \min\limits_{\bf w}</tex>. Если функция потерь принадлежит классу $C_1(X)$, то можно применить метод градиентного спуска. Выберем ${\bf w}^{(0)}$ $-$ начальное приближение. Тогда каждый следующий вектор параметров будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} - h\sum\limits_{i=1}^{l}\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $h$ - градиентный шаг, смысл которого заключается в том, насколько сильно менять вектор весов в направлении градиента. Остановка алгоритма будет определяться сходимостью $Q$ или $\bf w$.

== Стохастический градиентный спуск ==
Проблема предыдущего алгоритма заключается в том, что чтобы определить новое приближение вектора весов необходимо вычислить градиент от каждого элемента выборки, что может сильно замедлять алгоритм. Идея ускорения алгоритма заключается в использовании только одного элемента, либо некоторой подвыборки для подсчета нового приближения весов. То есть теперь новое приближение будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} $-$ h\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $i$ $-$ случайно выбранный индекс. Так как теперь направление изменения $\bf w$ будет определяться за $O(1)$, подсчет $Q$ на каждом шаге будет слишком дорогостоящим. Для того, чтобы ускорить оценку $Q$, будем использовать приближенную рекуррентную формулу. Можно выбрать одну из следующих формул:
* среднее арифметическое: $\overline{Q}_m = \dfrac{1}{m}\varepsilon_m + \dfrac{1}{m}\varepsilon_{m - 1} + \dfrac{1}{m}\varepsilon_{m - 2} + \dots = \dfrac{1}{m}\varepsilon_m + (1 - \dfrac{1}{m})\overline{Q}_{m-1}$
* экспоненциальное скользящее среднее: $\overline{Q}_m = \lambda\varepsilon_m + (1 - \lambda)\varepsilon_{m - 1} + (1 - \lambda)^2\varepsilon_{m - 2} + \dots = \lambda\varepsilon_m + (1-\lambda)\overline{Q}_{m - 1},$ где $\lambda$ $-$ темп забывания предыстории ряда.

== Псевдокод ==
'''def''' SGD(X, h, $\lambda$)''':''' # где X $-$ выборка, h $-$ градиентный шаг, а $\lambda$ $-$ темп забывания 
${\bf w} =$ initialize_weights() # инициализировать веса 
$\overline{Q} = \frac{1}{l} \sum_{i=1}^{l}\mathscr{L}_i({\bf w})$ # инициализировать оценку функционала 
'''while''' $Q$ not converges '''or''' ${\bf w}$ not converges''':'''
$i =$ rand() % $l$ # случайно выбрать элемент, по которому будет считаться градиент 
$\varepsilon = \mathscr{L}_i({\bf w})$ # вычислить потерю 
${\bf w} = {\bf w} - h \nabla \mathscr{L}_i({\bf w})$ # обновить вектор весов в направлении градиента
$\overline{Q} = \lambda\varepsilon + (1 - \lambda)\overline{Q}$ # оценить функционал
'''return''' w

== Эвристики ==
Существует несколько способов инициализировать веса:
* ${\bf w} = {\bf 0}$
* $w_j = random(-\dfrac{1}{2n}, \dfrac{1}{2n})$. Стоит брать небольшие случайные веса, так как если выбрать их слишком большими, в некоторых случаях (к примеру в случае нейрона с [[Нейронные_сети,_перцептрон|функцией активациии]] равной арктангенсу) большие начальные значения веса могут привести в область с малыми по модулю производными, в связи с чем из такой области будет трудно выбраться.
* $w_j = \dfrac{\langle y, f_j \rangle}{\langle f_j, f_j \rangle}$, где $f_j = (f_j(x_i))_{i=1}^l$. Оценка оптимальная в случае, если функция потерь квадратична и признаки нескоррелированы, то есть $\langle f_j, f_k \rangle = 0, j \neq k$
Так же можно запустить спуск несколько раз с разными начальными приближениями и выбрать лучшее решение.

При выборе случайного элемента можно использовать следующие эвристики:
* брать объекты из разных классов;
* брать объекты, на которых ошибка больше, то есть чем меньше отступ (в метрических классификаторах расстояние от разделяющей поверхности до объекта) i-го объекта $M_i$, тем больше вероятность взять этот объект;
* брать объекты, на которых уверенность меньше, то есть чем меньше $|M_i|$, тем больше вероятность взять этот объект;
* не брать объекты, на которых уже высокая уверенность ($M_i > \mu_+$) либо не брать объекты-выбросы ($M_i<\mu_i$);

Выбирать величину градиентного шага можно следующими способами:
* $h_t = \dfrac{1}{t}$;
* метод скорейшего градиентного спуска: $\mathscr{L}_i({\bf w} - h\nabla \mathscr{L}_i({\bf w})) \rightarrow \min\limits_h$;
* при квадратичной функции потерь можно использовать $h = ||x_i||^2$;
* иногда можно выполнять пробные шаги, а именно увеличивать $h$ для выбивания процесса из локальных минимумов;
* [https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D0%B1%D0%B5%D1%80%D0%B3%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%80%D0%BA%D0%B2%D0%B0%D1%80%D0%B4%D1%82%D0%B0 метод Левенберга-Марквардта];

== Регуляризация ==
Основным способом уменьшить переобучение является [[Регулярищация|регуляризация]][на 28.01.19 не создан], т.е. сокращение весов. Будем штрафовать за увеличение нормы вектора весов, для этого перепишем функцию потерь $\tilde{\mathscr{L}}_i({\bf w}) = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2}||w||^2 = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2} \sum\limits_{j=1}^nw_j^2 \rightarrow \min\limits_w$, где $\tau$ $-$ коэффициент регуляризации.

Тогда градиент будет следующим: $\nabla \tilde{\mathscr{L}}_i({\bf w}) = \nabla \mathscr{L}_i({\bf w}) + \tau {\bf w}$, а градиентный шаг будет выглядеть так: ${\bf w} = {\bf w}(1 - h\tau) - h\nabla \mathscr{L}_i({\bf w})$.

== Достоинства и недостатки ==
'''Достониства:'''
* легко реализуется;
* функция потерь и семейство алгоритмов могут быть любыми (если функция потерь не дифференцируема, ее можно аппроксимировать дифференцируемой);
* легко добавить регуляризацию;
* возможно потоковое обучение;
* подходит для задач с большими данными, иногда можно получить решение даже не обработав всю выборку;
'''Недостатки'''
* нет универсального набора эвристик, их нужно выбирать для конкретной задачи отдельно;

== Пример кода scikit-learn ==
Классификатор [https://scikit-learn.org/stable/modules/sgd.html sklearn.linear_model.'''SGDClassifier'''] имеет несколько параметров, например:

'''loss''' $-$ функция потерь. По умолчанию используется "hinge", дающая алгоритм линейного SVM;

'''penalty''' $-$ метод регуляризации. По умолчанию "l2";

'''alpha''' $-$ $\tau$, коэффициент регуляризации;

'''learning_rate''' $-$ алгоритм изменения градиентного шага;

'''eta0''' $-$ начальный градиентный шаг;

'''shuffle''' перемешивать тренировочную выборку после каждой итерации;

* Импортируем нужные библиотеки:
'''from''' sklearn.linear_model '''import''' SGDClassifier
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split

* Выберем тренировочное и тестовое множества:
iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

* Обучение:
clf = SGDClassifier(shuffle = True)
model = clf.'''fit'''(X_train, y_train)

* Предсказание:
y_pred = model.'''predict'''(X_test)
model.'''score'''(X_test, y_test)

== См. также ==
* [[Общие понятия]]
* [[Обзор библиотек для машинного обучения на Python]]

== Источники информации ==
#[http://www.machinelearning.ru/wiki/images/5/53/Voron-ML-Lin-SG.pdf Метод стохастического градиента] $-$ презентация Воронцова
#[https://www.youtube.com/watch?v=4BKQ3GZR32w&list=PLJOzdkh8T5kp99tGTEFjH_b9zqEQiiBtC&index=4 Метод стохастического градиента] $-$ запись лекции Воронцова
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html#sklearn.linear_model.SGDClassifier.decision_function sklearn.linear_model.SGDClassifier] $-$ описание алгоритма на scikit-learn.org

[[Категория: Машинное обучение]]

Стохастический градиентный спуск

2019-01-28T12:14:27Z

Nikitaevg:

'''Стохастический градиентный спуск''' (англ. ''stochastic gradient descent'') $-$ оптимизационный алгоритм, отличающийся от обычного [https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA градиентного спуска] тем, что градиент оптимизируемой функции считается на каждом шаге не как сумма градиентов от каждого элемента выборки, а как градиент от одного, случайно выбранного элемента.

== Обычный градиентный спуск ==
Для начала вспомним, как работает обычный градиентный спуск. Пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ $-$ конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>\{(x_1,y_1),\dots,(x_l,y_l)\}.</tex> Пусть семейство алгоритмов $a(x, {\bf w})$ имеет параметр вектор весов $\bf w$. И пускай мы выбрали какую-нибудь функцию потерь. Для $i$-го объекта выборки для алгоритма с весами ${\bf w}$ обозначим ее <tex> \mathscr{L}_i({\bf w}) </tex>. Необходимо минимизировать эмпирический риск, т.е. <tex>Q(w) = \sum\limits_{i=1}^l \mathscr{L}_i(w) \,\to\, \min\limits_{\bf w}</tex>. Если функция потерь принадлежит классу $C_1(X)$, то можно применить метод градиентного спуска. Выберем ${\bf w}^{(0)}$ $-$ начальное приближение. Тогда каждый следующий вектор параметров будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} - h\sum\limits_{i=1}^{l}\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $h$ - градиентный шаг, смысл которого заключается в том, насколько сильно менять вектор весов в направлении градиента. Остановка алгоритма будет определяться сходимостью $Q$ или $\bf w$.

== Стохастический градиентный спуск ==
Проблема предыдущего алгоритма заключается в том, что чтобы определить новое приближение вектора весов необходимо вычислить градиент от каждого элемента выборки, что может сильно замедлять алгоритм. Идея ускорения алгоритма заключается в использовании только одного элемента, либо некоторой подвыборки для подсчета нового приближения весов. То есть теперь новое приближение будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} $-$ h\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $i$ $-$ случайно выбранный индекс. Так как теперь направление изменения $\bf w$ будет определяться за $O(1)$, подсчет $Q$ на каждом шаге будет слишком дорогостоящим. Для того, чтобы ускорить оценку $Q$, будем использовать приближенную рекуррентную формулу. Можно выбрать одну из следующих формул:
* среднее арифметическое: $\overline{Q}_m = \dfrac{1}{m}\varepsilon_m + \dfrac{1}{m}\varepsilon_{m - 1} + \dfrac{1}{m}\varepsilon_{m - 2} + \dots = \dfrac{1}{m}\varepsilon_m + (1 - \dfrac{1}{m})\overline{Q}_{m-1}$
* экспоненциальное скользящее среднее: $\overline{Q}_m = \lambda\varepsilon_m + (1 - \lambda)\varepsilon_{m - 1} + (1 - \lambda)^2\varepsilon_{m - 2} + \dots = \lambda\varepsilon_m + (1-\lambda)\overline{Q}_{m - 1},$ где $\lambda$ $-$ темп забывания предыстории ряда.

== Псевдокод ==
'''def''' SGD(X, h, $\lambda$)''':''' # где X $-$ выборка, h $-$ градиентный шаг, а $\lambda$ $-$ темп забывания 
${\bf w} =$ initialize_weights() # инициализировать веса 
$\overline{Q} = \frac{1}{l} \sum_{i=1}^{l}\mathscr{L}_i({\bf w})$ # инициализировать оценку функционала 
'''while''' $Q$ not converges '''or''' ${\bf w}$ not converges''':'''
$i =$ rand() % $l$ # случайно выбрать элемент, по которому будет считаться градиент 
$\varepsilon = \mathscr{L}_i({\bf w})$ # вычислить потерю 
${\bf w} = {\bf w} - h \nabla \mathscr{L}_i({\bf w})$ # обновить вектор весов в направлении градиента
$\overline{Q} = \lambda\varepsilon + (1 - \lambda)\overline{Q}$ # оценить функционал
'''return''' w

== Эвристики ==
Существует несколько способов инициализировать веса:
* ${\bf w} = {\bf 0}$
* $w_j = random(-\dfrac{1}{2n}, \dfrac{1}{2n})$. Стоит брать небольшие случайные веса, так как если выбрать их слишком большими, в некоторых случаях (к примеру в случае нейрона с [[Нейронные_сети,_перцептрон|функцией активациии]] равной арктангенсу) большие начальные значения веса могут привести в область с малыми по модулю производными, в связи с чем из такой области будет трудно выбраться.
* $w_j = \dfrac{\langle y, f_j \rangle}{\langle f_j, f_j \rangle}$, где $f_j = (f_j(x_i))_{i=1}^l$. Оценка оптимальная в случае, если функция потерь квадратична и признаки нескоррелированы, то есть $\langle f_j, f_k \rangle = 0, j \neq k$
Так же можно запустить спуск несколько раз с разными начальными приближениями и выбрать лучшее решение.

При выборе случайного элемента можно использовать следующие эвристики:
* брать объекты из разных классов
* брать объекты, на которых ошибка больше, то есть чем меньше отступ i-го объекта $M_i$, тем больше вероятность взять этот объект
* брать объекты, на которых уверенность меньше, то есть чем меньше $|M_i|$, тем больше вероятность взять этот объект
* не брать объекты, на которых уже высокая уверенность ($M_i > \mu_+$) либо не брать объекты-выбросы ($M_i<\mu_i$)

Выбирать величину градиентного шага можно следующими способами:
* $h_t = \dfrac{1}{t}$
* метод скорейшего градиентного спуска: $\mathscr{L}_i({\bf w} - h\nabla \mathscr{L}_i({\bf w})) \rightarrow \min\limits_h$
* при квадратичной функции потерь можно использовать $h = ||x_i||^2$
* иногда можно выполнять пробные шаги, а именно увеличивать $h$ для выбивания процесса из локальных минимумов
* [https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D0%B1%D0%B5%D1%80%D0%B3%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%80%D0%BA%D0%B2%D0%B0%D1%80%D0%B4%D1%82%D0%B0 метод Левенберга-Марквардта]

== Регуляризация ==
Основным способом уменьшить переобучение является [[Регулярищация|регуляризация]][на 28.01.19 не создан], т.е. сокращение весов. Будем штрафовать за увеличение нормы вектора весов, для этого перепишем функцию потерь $\tilde{\mathscr{L}}_i({\bf w}) = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2}||w||^2 = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2} \sum\limits_{j=1}^nw_j^2 \rightarrow \min\limits_w$, где $\tau$ $-$ коэффициент регуляризации.

Тогда градиент будет следующим: $\nabla \tilde{\mathscr{L}}_i({\bf w}) = \nabla \mathscr{L}_i({\bf w}) + \tau {\bf w}$, а градиентный шаг будет выглядеть так: ${\bf w} = {\bf w}(1 - h\tau) - h\nabla \mathscr{L}_i({\bf w})$.

== Достоинства и недостатки ==
'''Достониства:'''
* легко реализуется
* функция потерь и семейство алгоритмов могут быть любыми (если функция потерь не дифференцируема, ее можно аппроксимировать дифференцируемой)
* легко добавить регуляризацию
* возможно потоковое обучение
* подходит для задач с большими данными, иногда можно получить решение даже не обработав всю выборку
'''Недостатки'''
* нет универсального набора эвристик, их нужно выбирать для конкретной задачи отдельно

== Пример кода scikit-learn ==
Классификатор [https://scikit-learn.org/stable/modules/sgd.html sklearn.linear_model.'''SGDClassifier'''] имеет несколько параметров, например:

'''loss''' $-$ функция потерь. По умолчанию используется "hinge", дающая алгоритм линейного SVM

'''penalty''' $-$ метод регуляризации. По умолчанию "l2"

'''alpha''' $-$ $\tau$, коэффициент регуляризации

'''learning_rate''' $-$ алгоритм изменения градиентного шага

'''eta0''' $-$ начальный градиентный шаг

'''shuffle''' перемешивать тренировочную выборку после каждой итерации

* Импортируем нужные библиотеки
'''from''' sklearn.linear_model '''import''' SGDClassifier
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split

* Выберем тренировочное и тестовое множества
iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

* Обучение
clf = SGDClassifier(shuffle = True)
model = clf.'''fit'''(X_train, y_train)

* Предсказание
y_pred = model.'''predict'''(X_test)
model.'''score'''(X_test, y_test)

== См. также ==
* [[Общие понятия]]
* [[Обзор библиотек для машинного обучения на Python]]

== Источники информации ==
#[http://www.machinelearning.ru/wiki/images/5/53/Voron-ML-Lin-SG.pdf Метод стохастического градиента] $-$ презентация Воронцова
#[https://www.youtube.com/watch?v=4BKQ3GZR32w&list=PLJOzdkh8T5kp99tGTEFjH_b9zqEQiiBtC&index=4 Метод стохастического градиента] $-$ запись лекции Воронцова
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html#sklearn.linear_model.SGDClassifier.decision_function sklearn.linear_model.SGDClassifier] $-$ описание алгоритма на scikit-learn.org

[[Категория: Машинное обучение]]

Стохастический градиентный спуск

2019-01-27T13:24:43Z

Nikitaevg:

'''Стохастический градиентный спуск''' - оптимизационный алгоритм, отличающийся от обычного [https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA градиентного спуска] тем, что градиент оптимизируемой функции считается на каждом шаге не как сумма градиентов от каждого элемента выборки, а как градиент от одного, случайно выбранного элемента.

== Обычный градиентный спуск ==
Для начала вспомним, как работает обычный градиентный спуск. Пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ $-$ конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>\{(x_1,y_1),\dots,(x_l,y_l)\}.</tex> Пусть семейство алгоритмов $a(x, {\bf w})$ имеет параметр вектор весов $\bf w$. И пускай мы выбрали какую-нибудь функцию потерь. Для $i$-го объекта выборки для алгоритма с весами ${\bf w}$ обозначим ее <tex> \mathscr{L}_i({\bf w}) </tex>. Необходимо минимизировать эмпирический риск, т.е. <tex>Q(w) = \sum\limits_{i=1}^l \mathscr{L}_i(w) \,\to\, \min\limits_{\bf w}</tex>. Если функция потерь принадлежит классу $C_1(X)$, то можно применить метод градиентного спуска. Выберем ${\bf w}^{(0)}$ - начальное приближение. Тогда каждый следующий вектор параметров будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} - h\sum\limits_{i=1}^{l}\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $h$ - градиентный шаг, смысл которого заключается в том, насколько сильно менять вектор весов в направлении градиента. Остановка алгоритма будет определяться сходимостью $Q$ или $\bf w$.

== Стохастический градиентный спуск ==
Проблема предыдущего алгоритма заключается в том, что чтобы определить новое приближение вектора весов необходимо вычислить градиент от каждого элемента выборки, что может сильно замедлять алгоритм. Идея ускорения алгоритма заключается в использовании только одного элемента, либо некоторой подвыборки для подсчета нового приближения весов. То есть теперь новое приближение будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} - h\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $i$ - случайно выбранный индекс. Так как теперь направление изменения $\bf w$ будет определяться за $O(1)$, подсчет $Q$ на каждом шаге будет слишком дорогостоящим. Для того, чтобы ускорить оценку $Q$, будем использовать приближенную рекуррентную формулу. Можно выбрать одну из следующих формул:
* Среднее арифметическое: $\overline{Q}_m = \dfrac{1}{m}\varepsilon_m + \dfrac{1}{m}\varepsilon_{m - 1} + \dfrac{1}{m}\varepsilon_{m - 2} + \dots = \dfrac{1}{m}\varepsilon_m + (1 - \dfrac{1}{m})\overline{Q}_{m-1}$
* Экспоненциальное скользящее среднее: $\overline{Q}_m = \lambda\varepsilon_m + (1 - \lambda)\varepsilon_{m - 1} + (1 - \lambda)^2\varepsilon_{m - 2} + \dots = \lambda\varepsilon_m + (1-\lambda)\overline{Q}_{m - 1},$ где $\lambda$ - темп забывания предыстории ряда.

== Псевдокод ==
'''def''' SG(x, h, l)''':'''
${\bf w} =$ initialize_weights() # инициализировать веса
$\overline{Q} = \frac{1}{l} \sum_{i=1}^{l}\mathscr{L}_i({\bf w})$ # инициализировать оценку функционала
'''while''' $Q$ not converges '''or''' ${\bf w}$ not converges''':'''
$i =$ rand() % $l$ # случайно выбрать элемент, по которому будет считаться градиент
$\varepsilon = \mathscr{L}_i({\bf w})$ # вычислить потерю
${\bf w} = {\bf w} - h \nabla \mathscr{L}_i({\bf w})$ # обновить вектор весов в направлении градиента
$\overline{Q} = \lambda\varepsilon + (1 - \lambda)\overline{Q}$ # оценить функционал

== Эвристики ==
Существует несколько способов инициализировать веса:
* ${\bf w} = {\bf 0}$
* $w_j = random(-\dfrac{1}{2n}, \dfrac{1}{2n})$. Стоит брать небольшие случайные веса, так как если выбрать их слишком большими, в некоторых случаях (к примеру в случае нейрона с функцией активациии равной арктангенсу) большие начальные значения веса могут привести в область с малыми по модулю производными, в связи с чем из такой области будет трудно выбраться.
* $w_j = \dfrac{\langle y, f_j \rangle}{\langle f_j, f_j \rangle}$, где $f_j = (f_j(x_i))_{i=1}^l$. Оценка оптимальная в случае, если функция потерь квадратична и признаки нескоррелированы, то есть $\langle f_j, f_k \rangle = 0, j \neq k$
Так же можно запустить спуск несколько раз с разными начальными приближениями и выбрать лучшее решение.

При выборе случайного элемента можно использовать следующие эвристики:
* брать объекты из разных классов
* брать объекты, на которых ошибка больше, то есть чем меньше отступ $M_i$, тем больше вероятность взять объект
* брать объекты, на которых уверенность меньше, то есть чем меньше $|M_i|$, тем больше вероятность взять объект
* не брать объекты, на которых уже высокая уверенность ($M_i > \mu_+$) либо не брать объекты-выбросы ($M_i<\mu_i$)

Выбирать величину градиентного шага можно следующими способами:
* $h_t = \dfrac{1}{t}$
* метод скорейшего градиентного спуска: $\mathscr{L}_i({\bf w} - h\nabla \mathscr{L}_i({\bf w})) \rightarrow \min\limits_h$.
* При квадратичной функции потерь можно использовать $h = ||x_i||^2$
* Иногда можно выполнять пробные шаги, а именно увеличивать h для выбивания процесса из локальных минимумов
* [https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D0%B1%D0%B5%D1%80%D0%B3%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%80%D0%BA%D0%B2%D0%B0%D1%80%D0%B4%D1%82%D0%B0 Метод Левенберга-Марквардта]

== Регуляризация ==
Основным способом уменьшить переобучение является регуляризация, т.е. сокращение весов. Будем штрафовать за увеличение нормы вектора весов, для этого перепишем функцию потерь $\tilde{\mathscr{L}}_i({\bf w}) = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2}||w||^2 = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2} \sum\limits_{j=1}^nw_j^2 \rightarrow \min\limits_w$, где $\tau$ - коэффициент регуляризации.

Тогда градиент будет следующим: $\nabla \tilde{\mathscr{L}}_i({\bf w}) = \nabla \mathscr{L}_i({\bf w}) + \tau {\bf w}$, а градиентный шаг будет выглядеть так: ${\bf w} = {\bf w}(1 - h\tau) - h\nabla \mathscr{L}_i({\bf w})$.

== Достоинства и недостатки ==
'''Достониства:'''
* Легко реализуется
* Функция потерь и семейство алгоритмов могут быть любыми (если функция потерь не дифференцируема, ее можно аппроксимировать дифференцируемой)
* Легко добавить регуляризацию
* Возможно потоковое обучение
* Подходит для задач с большими данными, иногда можно получить решение даже не обработав всю выборку
'''Недостатки'''
* Нет универсального набора эвристик, их нужно выбирать для конкретной задачи отдельно

== Пример кода scikit-learn ==
Классификатор [https://scikit-learn.org/stable/modules/sgd.html sklearn.linear_model.'''SGDClassifier'''] имеет несколько параметров, например:

'''loss''' - функция потерь. По умолчанию используется "hinge", дающая алгоритм линейного SVM

'''penalty''' - метод регуляризации. По умолчанию "l2"

'''alpha''' - $\tau$, коэффициент регуляризации

'''learning_rate''' - алгоритм изменения градиентного шага

'''eta0''' - начальный градиентный шаг

'''shuffle''' перемешивать тренировочную выборку после каждой итерации

* Импортируем нужные библиотеки
'''from''' sklearn.linear_model '''import''' SGDClassifier
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split

* Выберем тренировочное и тестовое множества
iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

* Обучение
clf = SGDClassifier(shuffle = True)
model = clf.'''fit'''(X_train, y_train)

* Предсказание
y_pred = model.'''predict'''(X_test)
model.'''score'''(X_test, y_test)

== См. также ==
* [[Общие понятия]]
* [[Обзор библиотек для машинного обучения на Python]]

== Источники информации ==
#[http://www.machinelearning.ru/wiki/images/5/53/Voron-ML-Lin-SG.pdf Метод стохастического градиента] $-$ презентация Воронцова
#[https://www.youtube.com/watch?v=4BKQ3GZR32w&list=PLJOzdkh8T5kp99tGTEFjH_b9zqEQiiBtC&index=4 Метод стохастического градиента] $-$ запись лекции Воронцова
#[https://en.wikipedia.org/wiki/Logistic_regression Logistic regression] $-$ Wikipedia
#[https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.SGDClassifier.html#sklearn.linear_model.SGDClassifier.decision_function sklearn.linear_model.SGDClassifier] $-$ описание алгоритма на scikit-learn.org

[[Категория: Машинное обучение]]

Стохастический градиентный спуск

2019-01-27T12:56:31Z

Nikitaevg: Init

'''Стохастический градиентный спуск''' - оптимизационный алгоритм, отличающийся от обычного [https://ru.wikipedia.org/wiki/%D0%93%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D1%8B%D0%B9_%D1%81%D0%BF%D1%83%D1%81%D0%BA градиентного спуска] тем, что градиент оптимизируемой функции считается на каждом шаге не как сумма градиентов от каждого элемента выборки, а как градиент одного, случайно выбранного элемента.

== Обычный градиентный спуск ==
Для начала вспомним, как работает обычный градиентный спуск. Пусть объекты задаются $n$ числовыми признаками $f_j : X \to R, j = 1 ... n$ и пространство признаковых описаний в таком случае $X = R^n$. Пусть $Y$ $-$ конечное множество меток классов и задана обучающая выборка пар «объект-ответ» <tex>\{(x_1,y_1),\dots,(x_l,y_l)\}.</tex> Пусть семейство алгоритмов $a(x, {\bf w})$ зависит от вектора параметров $\bf w$. И пускай мы выбрали какую-нибудь функцию потерь, для $i$-го объекта выборки для алгоритма с весами ${\bf w}$ обозначим ее <tex> \mathscr{L}_i({\bf w}) </tex>. Необходимо минимизировать эмпирический риск, т.е. <tex>Q(w) = \sum\limits_{i=1}^l \mathscr{L}_i(w) \,\to\, \min\limits_{\bf w}</tex>. Если функция потерь принадлежит классу $C_1(X)$, то можно применить метод градиентного спуска. Выберем ${\bf w}^{(0)}$ - начальное приближение. Тогда каждый следующий вектор параметров будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} - h\sum\limits_{i=1}^{l}\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $h$ - градиентный шаг, смысл которого заключается в том, насколько сильно менять вектор весов в направлении градиента. Остановка алгоритм будет определятся сходимостью $Q$ или $\bf w$.

== Стохастический градиентный спуск ==
Проблема предыдущего алгоритма заключается в том, что чтобы определить новое приближение вектора весов необходимо вычислить градиент от каждого элемента выборки, что может сильно замедлять алгоритм. Идея ускорения алгоритма заключается в использовании только одного элемента, либо некоторой подвыборки для подсчета нового приближения весов. То есть теперь новое приближение будет вычисляться как ${\bf w}^{(t+1)}={\bf w}^{(t)} - h\nabla \mathscr{L}_i({\bf w}^{(t)})$, где $i$ - случайно выбранный индекс. Так как теперь направление изменения $\bf w$ будет определяться за $O(1)$, подсчет $Q$ на каждом шаге будет слишком дорогостоящим. Для того, чтобы этого не делать, будем использовать приближенную рекуррентную формулу. Тогда оценка $Q$ на $m$-ом шаге может выполняться следующими способами:
* Среднее арифметическое: $\overline{Q}_m = \dfrac{1}{m}\varepsilon_m + \dfrac{1}{m}\varepsilon_{m - 1} + \dfrac{1}{m}\varepsilon_{m - 2} + \dots = \dfrac{1}{m}\varepsilon_m + (1 - \dfrac{1}{m})\overline{Q}_{m-1}$
* Экспоненциальное скользящее среднее: $\overline{Q}_m = \lambda\varepsilon_m + (1 - \lambda)\varepsilon_{m - 1} + (1 - \lambda)^2\varepsilon_{m - 2} + \dots = \lambda\varepsilon_m + (1-\lambda)\overline{Q}_{m - 1},$ где $\lambda$ - темп забывания предыстории ряда.

== Псевдокод ==
'''def''' SG(x, h, l)''':'''
${\bf w} =$ initialize_weights() # инициализировать веса
$\overline{Q} = \frac{1}{l} \sum_{i=1}^{l}\mathscr{L}_i({\bf w})$ # инициализировать оценку функционала
'''while''' $Q$ not converges '''or''' ${\bf w}$ not converges''':'''
$i =$ rand() % $l$ # случайно выбрать элемент, по которому будет считаться градиент
$\varepsilon = \mathscr{L}_i({\bf w})$ # вычислить потерю
${\bf w} = {\bf w} - h \nabla \mathscr{L}_i({\bf w})$ # обновить вектор весов в направлении градиента
$\overline{Q} = \lambda\varepsilon + (1 - \lambda)\overline{Q}$ # оценить функционал

== Эвристики ==
Есть несколько способов инициализировать веса:
* ${\bf w} = {\bf 0}$
* $w_j = random(-\dfrac{1}{2n}, \dfrac{1}{2n})$. Стоит брать небольшие случайные веса, так как если выбрать их слишком большими, в некоторых случаях (к примеру в случае нейрона с функцией активациии равной арктангенсу) большие начальные значения веса могут привести в область с малыми по модулю производными, в связи с чем из такой области будет трудно выбраться.
* $w_j = \dfrac{\langle y, f_j \rangle}{\langle f_j, f_j \rangle}$, где $f_j = (f_j(x_i))_{i=1}^l$. Оценка оптимальная в случае, если функция потерь квадратична и признаки нескоррелированы, то есть $\langle f_j, f_k \rangle = 0, j \neq k$
Так же можно запустить спуск несколько раз и выбрать лучшее решение.

При выборе случайного элемента можно использовать следующие эвристики:
* брать объекты из разных классов
* брать объекты, на которых ошибка больше, то есть чем меньше отступ $M_i$, тем больше вероятность взять объект
* брать объекты, на которых уверенность меньше, то есть чем меньше $|M_i|$, тем больше вероятность взять объект
* не брать объекты, на которых уже высокая уверенность ($M_i > \mu_+$) либо не брать объекты-выбросы ($M_i<\mu_i$)

Выбирать величину градиентного шага можно следующими способами:
* $h_t = \dfrac{1}{t}$
* метод скорейшего градиентного спуска: $\mathscr{L}_i({\bf w} - h\nabla \mathscr{L}_i({\bf w})) \rightarrow \min\limits_h$.
* При квадратичной функции потерь можно использовать $h = ||x_i||^2$
* Иногда можно выполнять пробные шаги с помощью увеличения h для выбивания процесса из локальных минимумов
* [https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%9B%D0%B5%D0%B2%D0%B5%D0%BD%D0%B1%D0%B5%D1%80%D0%B3%D0%B0_%E2%80%94_%D0%9C%D0%B0%D1%80%D0%BA%D0%B2%D0%B0%D1%80%D0%B4%D1%82%D0%B0 Метод Левенберга-Марквардта]

== Регуляризация ==
Основным способом уменьшить переобучение является регуляризация, т.е. сокращение весов. Будем штрафовать за увеличение нормы вектора весов, для этого перепишем функцию потерь $\tilde{\mathscr{L}}_i({\bf w}) = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2}||w||^2 = \mathscr{L}_i({\bf w}) + \dfrac{\tau}{2} \sum\limits_{j=1}^nw_j^2 \rightarrow \min\limits_w$, где $\tau$ - коэффициент регуляризации.

Тогда градиент будет следующим: $\nabla \tilde{\mathscr{L}}_i({\bf w}) = \nabla \mathscr{L}_i({\bf w}) + \tau {\bf w}$, а градиентный шаг будет выглядеть так: ${\bf w} = {\bf w}(1 - h\tau) - h\nabla \mathscr{L}_i({\bf w})$.

== Достоинства и недостатки ==
'''Достониства:'''
* Легко реализуется
* Функция потерь и семейство алгоритмов могут быть любыми (если функция потерь не дифференцируема, ее можно аппроксимировать дифференцируемой)
* Легко добавить регуляризацию
* Возможно потоковое обучение
* Подходит для задач с большими данными, иногда можно получить решение даже не обработав всю выборку
'''Недостатки'''
* Нет универсального набора эвристик, их нужно выбирать для конкретной задачи отдельно

== Пример кода scikit-learn ==
Классификатор [https://scikit-learn.org/stable/modules/sgd.html sklearn.linear_model.'''SGDClassifier'''] имеет несколько параметров, например:

'''loss''' - функция потерь. По умолчанию используется "hinge", дающая алгоритм линейного SVM

'''penalty''' - метод регуляризации. По умолчанию "l2"

'''alpha''' - $\tau$, коэффициент регуляризации

'''learning_rate''' - алгоритм изменения градиентного шага

'''eta0''' - начальный градиентный шаг

'''shuffle''' перемешивать тренировочную выборку после каждой итерации

* Импортируем нужные библиотеки
'''from''' sklearn.linear_model '''import''' SGDClassifier
'''from''' sklearn '''import''' datasets
'''from''' sklearn.model_selection '''import''' train_test_split

* Выберем тренировочное и тестовое множества
iris = datasets.'''load_iris()'''

X = iris.data
y = iris.target
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size='''0.3''')

* Обучение
clf = SGDClassifier(shuffle = True)
model = clf.'''fit'''(X_train, y_train)

* Предсказание
y_pred = model.'''predict'''(X_test)
model.'''score'''(X_test, y_test)

Теорема о декомпозиционном барьере

2017-01-04T18:55:37Z

Nikitaevg:

{{Теорема
|about=
о декомпозиционном барьере
|statement=
Существуют положительные вещественные числа <tex>c_{1}</tex> и <tex>c_{2}</tex>, такие что для любых натуральных <tex>V</tex> и <tex>E</tex>, удовлетворяющих неравенствам <tex>c_{1}V \leqslant E \leqslant c_{2}V^2</tex>, существует [[Определение сети, потока|сеть]] <tex>G</tex> с <tex>V</tex> вершинами и <tex>E</tex> ребрами, такая что для любого максимального потока <tex>f</tex> в <tex>G</tex>, любая его остаточная декомпозиция должна содержать <tex>\Omega (E)</tex> слагаемых (т.е. путей или циклов), причем каждый из путей (циклов) в декомпозиции должен иметь длину <tex>\Omega (V)</tex>.
|proof=
[[Файл:DecompositionBarierExample.png|300px|thumb|right|Пример для <tex>V = 16</tex>, в который надо добавить нужное количество ребер]]
<div>Возьмем <tex>c_{1} = \dfrac{11}{10}</tex> и <tex>c_{2} = \dfrac{1}{9}</tex>. Константа <tex>c_1</tex> выбрана таким образом, чтобы между <tex>A</tex> и <tex>B</tex> было <tex>\Omega(E)</tex> ребер, а константа <tex>c_2</tex> выбрана такой, потому что в рассматриваемой сети нельзя провести большее количество ребер. Чтобы получить искомую сеть, строится сеть, изображенная на рисунке, после чего добавляется нужное количество ребер из <tex>A</tex> в <tex>B</tex>. Пропускные способности ребер из <tex>A</tex> в <tex>B</tex> равны <tex>1</tex>, остальных — <tex>+\infty</tex> (или просто достаточно большое число, например, <tex>V^2</tex>).</div>
Теперь докажем саму теорему:
* Максимальный поток по модулю равен потоку через разрез, который разделяет <tex>A</tex> и <tex>B</tex> (т.е. пересекает все ребра с пропускной способностью <tex>1</tex>). Поток по каждому пути в декомпозиции не превышает 1, а значит, этих путей не меньше, чем ребер между <tex>A</tex> и <tex>B</tex>, а их <tex>\Omega (E)</tex>.
* По построению сети, любой путь из <tex>s</tex> в <tex>t</tex> содержит хотя бы <tex>(\dfrac{V}{3} + 3)</tex> ребер, что является <tex>\Omega (V)</tex>.
}}

'''Следствие:''' Алгоритмы, которые могут выписать декомпозицию потока вместе с поиском самого потока ([[Схема алгоритма Диница| Алгоритм Диница]], [[Алгоритм Эдмондса-Карпа]], [[Алгоритм Форда-Фалкерсона, реализация с помощью поиска в глубину| Алгоритм Форда-Фалкерсона]] и подобные) не могут работать быстрее чем за <tex>O(VE)</tex>, так как декомпозиция может быть сама по себе большой.

==См. также==
*[[Алгоритм Форда-Фалкерсона, реализация с помощью поиска в глубину| Алгоритм Форда-Фалкерсона]]
*[[Алгоритм Эдмондса-Карпа]]
*[[Схема алгоритма Диница| Алгоритм Диница]]
*[[Алгоритм поиска блокирующего потока в ациклической сети]]

==Источники информации==
[https://youtu.be/PMqO0UCezqo?t=1h39m57s Андрей Станкевич: Лекториум, дополнительные главы алгоритмов, лекция 11]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о максимальном потоке ]]

Алгоритм Эдмондса-Карпа

2017-01-04T18:36:33Z

Nikitaevg: переименовал Алоритм Эдмондса-Карпа в Алгоритм Эдмондса-Карпа: Опечатка

== Алгоритм ==

Алгоритм Эдмондса-Карпа является реализацией метода [[Алгоритм Форда-Фалкерсона для поиска максимального паросочетания|Форда-Фалкерсона]], в которой в качестве дополняющего пути выбирается [[Обход в ширину |кратчайший по ребрам путь]] в остаточной сети (длины всех ребер равны <tex>1</tex>).

=== Описание ===

# Положим все потоки равными нулю. Остаточная сеть изначально совпадает с исходной сетью.
# В остаточной сети находим кратчайший путь из источника в сток. Если такого пути нет, останавливаемся.
# Пускаем через найденный путь (он называется '''увеличивающим путём''' или '''увеличивающей цепью''') максимально возможный поток:
## На найденном пути в остаточной сети ищем ребро с минимальной пропускной способностью <tex>\mathrm{c_{min}}</tex>.
## Для каждого ребра на найденном пути увеличиваем поток на <tex>\mathrm{c_{min}}</tex>, а в противоположном ему — уменьшаем на <tex>\mathrm{c_{min}}</tex>.
## Модифицируем остаточную сеть. Для всех рёбер на найденном пути, а также для противоположных им рёбер, вычисляем новую пропускную способность. Если она стала ненулевой, добавляем ребро к остаточной сети, а если обнулилась, стираем его.
# Возвращаемся на шаг 2.

===Сложность===
Сложность алгоритма Эдмондса-Карпа равна <tex>O(VE^2)</tex>.

== Псевдокод ==

'''function''' EdmondsKarp(G, s, t):
'''for''' (для) каждого ребра <tex>(u,v) \in E[G]</tex>
<tex>f[u,v] \leftarrow 0</tex>
<tex>f[v,u] \leftarrow 0</tex>
'''while''' существует ''кратчайший'' путь <tex>p</tex> из <tex>s</tex> в <tex>t</tex> в остаточной сети <tex>G_f</tex>
<tex>c_f(p) \leftarrow min\{c_f(u,v) : (u,v) \in p\}</tex>
'''for''' <tex>(u,v) \in p</tex>
<tex>f[u,v] \leftarrow f[u,v] + c_f(p)</tex>
<tex>f[v,u] \leftarrow -f[u,v]</tex>

== Корректность алгоритма Эдмондса-Карпа ==

На каждой итерации цикла <tex>\mathrm {while}</tex> поток в графе <tex>G</tex> увеличивается вдоль одного из кратчайших путей в <tex>G_f</tex> из истока <tex>s</tex> в сток <tex>t</tex>. Этот процесс повторяется до тех пор пока существует кратчайший <tex>s \leadsto t</tex> путь в <tex>G_f</tex>. Если в <tex>G_f</tex> не существует кратчайшего пути из <tex>s</tex> в <tex>t</tex>, значит, не существует никакого вообще никакого <tex>s \leadsto t</tex> пути в <tex>G_f</tex> следовательно по [[Теорема Форда-Фалкерсона|теореме Форда-Фалкерсона]] найденный поток <tex>f</tex> максимальный.

== Оценка быстродействия ==

{{Лемма
|id=lemma1
|statement=
Если в сети <tex>G(V,E)</tex> с истоком <tex>s</tex> и стоком <tex>t</tex> увеличение потока производится вдоль кратчайших <tex>s \leadsto t</tex> путей в <tex>G_f</tex>, то для всех вершин <tex>v \in V\backslash\{s,t\}</tex> длина кратчайшего пути <tex>\delta_f(s, v)</tex> в остаточной сети <tex>G_f</tex> не убывает после каждого увеличения потока.
|proof=
Предположим противное, пусть существует вершина <tex>v \in V \backslash\{s,t\}</tex>, что после какого-то увеличения потока длина кратчайшего пути из <tex>s</tex> в <tex>v</tex> уменьшилась. Обозначим потоки до и после увеличения соответственно за <tex>f</tex> и <tex>f'</tex>. Пусть <tex>v</tex> {{---}} вершина, расстояние <tex>\delta'_f(s,v)</tex> от <tex>s</tex> до которой минимально и уменьшилось с увеличением потока. Имеем <tex>\delta'_f(s,v) < \delta_f(s,v)</tex>. Рассмотрим путь <tex>p = s \leadsto u \rightarrow v</tex>, являющийся кратчайшим от <tex>s</tex> к <tex>v</tex> в <tex>G'_f</tex>. Тогда верно, что <tex>\delta'_f(s, u) = \delta'_f(s,v) - 1</tex>.

По выбору <tex>v</tex> и из предыдущего утверждения получаем, что <tex>\delta'_f (s, u) \geqslant\delta_f(s,u)</tex>.

Предположим <tex>(u, v) \in E_f</tex>, тогда <tex>\delta_f(s,v) \leqslant \delta_f(s, u) + 1 \leqslant \delta'_f(s,u) + 1 = \delta'_f(s, v)</tex>. Это противоречит <tex>\delta'_f(s,v) < \delta_f(s,v)</tex>.

Пусть <tex>(u,v) \notin E_f</tex>, но известно, что <tex>(u,v) \in E_f'</tex>. Появление ребра <tex>(u,v)</tex> после увеличения потока означает увеличение потока по обратному ребру <tex>(v, u)</tex>. Увеличение потока производится вдоль кратчайшего пути, поэтому кратчайший путь из <tex>s</tex> в <tex>u</tex> вдоль которого происходило увеличения выглядит как <tex>s \leadsto v \rightarrow u</tex>, из чего получаем <tex>\delta_f(s, v) = \delta_f(s, u) - 1 \leqslant \delta'_f(s, u) - 1 = \delta'(s, v) - 2</tex>. Данное утверждение противоречит <tex>\delta'_f(s,v) < \delta_f(s,v)</tex>. Итак мы пришли к противоречию с существованием вершины <tex>v</tex>, кратчайшее расстояние до которой уменьшилось с увеличением потока.
}}

Опираясь на предшествующую лемму, докажем следующую теорему, которая ограничивает сверху число итераций цикла <tex>\mathrm {while}</tex> в алгоритме Эдмондса-Карпа.

{{Теорема
|statement=Пусть для некоторой сети <tex>G(V,E)</tex> с источником <tex>s</tex> и стоком <tex>t</tex> выполняется алгоритм Эдмондса-Карпа, тогда общее число итераций цикла <tex>\mathrm {while}</tex> составляет <tex>O(V E)</tex>.
|proof=
Рассмотрим множество ребер <tex>(u,v)</tex> остаточной сети <tex>G_f</tex>, принадлежащих увеличивающему пути <tex>p</tex>, таких что <tex>c_f(p) = c_f(u,v)</tex>. Назовем данные ребра критическими. Покажем, что каждое из <tex>|E|</tex> ребер может становиться критическим не более, чем <tex>|V| - 1</tex> раз. Заметим, что после увеличения потока вдоль пути <tex>p</tex> все критические ребра исчезают из остаточной сети, кроме того по определению остаточной пропускной способности пути хотя бы одно ребро увеличивающего пути {{---}} критическое.

Рассмотрим две вершины <tex>u</tex> и <tex>v</tex> принадлежащие <tex>V</tex>, соединенные некоторым ребром из <tex>E</tex>. Увеличение производится вдоль кратчайших путей, поэтому если ребро <tex>(u,v)</tex> становиться критическим в первый раз, верно, что <tex>\delta_f(s,v) = \delta_f(s,u) + 1</tex>. После увеличения потока ребро <tex>(u, v)</tex> исчезает из сети. Оно не появится в другом увеличивающем пути до тех, пор пока не будет уменьшен по обратному ребру <tex>(v, u)</tex>. Это может произойти только в том случае, если ребро <tex>(v, u)</tex> встретится на некотором увеличивающем пути. Пусть в момент перед увеличением поток в сети <tex>G</tex> составлял <tex>f'</tex>, то поскольку увеличение производиться вдоль кратчайших путей, верно: <tex>\delta'_f(s,u) = \delta'_f(s, v) + 1</tex>. Согласно [[#lemma1|лемме]] <tex>\delta_f(s,v) \leqslant \delta'_f(s,v)</tex>, откуда <tex>\delta'_f(s,u) = \delta'(s,v) + 1 \geqslant \delta_f(s,v) + 1 = \delta_f(s,u) + 2</tex>.

Итак в промежуток времени между тем, когда ребро <tex>(u,v)</tex> становится критическим в первый раз, до момента, когда оно становится критическим в следующий раз, расстояние от <tex>s</tex> до <tex>u</tex> увеличивается минимум на <tex>2</tex>. Расстояние <tex>\delta(s,u)</tex> в начальный момент времени больше либо равно <tex>0</tex>. Среди промежуточных вершин на кратчайшем пути <tex>s \leadsto u</tex> не могут находиться <tex>s</tex>, <tex>u</tex> или <tex>t</tex>. Следовательно к тому моменту, когда вершина <tex>u</tex> станет недостижимой из источника расстояние до нее не превысит <tex>|V| - 2</tex>. Получаем, что ребро <tex>(u, v)</tex> могло стать критическим не более <tex>\dfrac{(|V| -2)}{2} = \dfrac{|V|}{2} - 1</tex> раз. Поскольку в графе не более <tex>O(E)</tex> пар вершин, между которыми могут существовать ребра в остаточной сети, то общее количество критических ребер в ходе выполнения алгоритма Эдмондса-Карпа равно <tex>O(V E)</tex>.

Так как каждый увеличивающий путь содержит по крайней мере одно критическое ребро, следовательно число кратчайших путей составляет <tex>O(V E)</tex>. На каждой итерации цикла <tex>\mathrm {while}</tex> рассматривается ровно один увеличивающий путь, а поскольку в случае отсутствия такого пути выполнение цикла прерывается, то число итераций цикла <tex>\mathrm {while}</tex> также составляет <tex>O(V E)</tex>.
}}

Если увеличивающий путь находить поиском в ширину, то каждую итерацию цикла <tex>\mathrm {while}</tex> можно выполнить за время <tex>O(E)</tex>. Инициализация в процедуре '''Edmonds_Karp''' производится за <tex>O(E)</tex>, следовательно время работы алгоритма алгоритма Эдмондса-Карпа составляет <tex>O(V E^2)</tex>. Заметим также, что сущетсвует сеть "грибок"<ref>[https://www.topcoder.com/community/data-science/data-science-tutorials/maximum-flow-augmenting-path-algorithms-comparison/#! Cтатья на TopCoder.com ]</ref> на которой нижняя граница времени работы алгоритмы Эдмондса-Карпа также составляет <tex>\Omega(V E^2)</tex>.

==Примечания==

<references />

== Источники информации ==
* ''Кормен, Томас Х., Лейзерсон, Чарльз И., Ривест, Рональд Л., Штайн Клиффорд'' '''Алгоритмы: построение и анализ''', 2-е издание. Пер. с англ. — М.:Издательский дом "Вильямс", 2010. — 1296 с.: ил. — Парал. тит. англ. — ISBN 978-5-8459-0857-5 (рус.)
*[https://ru.wikipedia.org/wiki/Алгоритм_Эдмондса_—_Карпа Википедия: Алоритм Эдмондса-Карпа]
* [https://en.wikipedia.org/wiki/Edmonds–Karp_algorithm Википедия: Алоритм Эдмондса-Карпа (англ.)]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Задача о максимальном потоке]]

Алоритм Эдмондса-Карпа

2017-01-04T18:36:33Z

Nikitaevg: переименовал Алоритм Эдмондса-Карпа в Алгоритм Эдмондса-Карпа: Опечатка

#перенаправление [[Алгоритм Эдмондса-Карпа]]

Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями

2017-01-04T17:29:35Z

Nikitaevg: /* Обозначения */

==Обозначения==
Введём следующие обозначения:
* <tex>N = (V,E,s,t,c)</tex> {{---}} [[Определение сети, потока|сеть]] с целочисленными пропускными способностями,
* обозначим <tex>C = \max\limits_{uv \in E} c_{uv}</tex> и <tex>F</tex> как максимальный поток,
*<tex>c^{+}(v) = \sum\limits_{uv \in E} c_{uv}</tex>,
*<tex>c^{-}(v) = \sum\limits_{vu \in E} c_{vu}</tex>,
*<tex>p(v) = \min(c^{+}(v), c^{-}(v))</tex> {{---}} потенциал вершины <tex>v</tex>,
*<tex>P = \sum\limits_{v \in V, v \neq s,t}p(v)</tex> {{---}} общий потенциал,
*<tex>G_f</tex> {{---}} [[Дополняющая сеть, дополняющий путь|остаточная сеть]].

==Теоремы==
{{Лемма
|about = 1
|statement=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex> в исходной сети, максимальный поток в этой сети равен <tex>F</tex>.

Тогда <tex>l \leqslant \dfrac{P}{F} + 1</tex>

|proof=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex>, а <tex>V_i</tex> {{---}} набор вершин, удаленных от <tex>s</tex> на <tex>i</tex> <tex>(i \leqslant l)</tex>.
<tex>V_i</tex> {{---}} разъединяющее множество узлов: при его удалении исчезают все пути из <tex>s</tex> в <tex>t</tex>.
Следуя закону [[Определение сети, потока|сохранения потока]], если <tex>f</tex> обозначить как любой допустимый поток, то <tex>|f|</tex> единиц потока должно проходить через <tex>V_i</tex>.
Но суммарное количество потока, которое может проходить через любую вершину не превосходит ее потенциала.
Отсюда, если обозначить <tex>P_i</tex> как общий потенциал вершин из <tex>V_i</tex>, то мы имеем:

<tex>|f| \leqslant P_i</tex>

для любого допустимого потока <tex>f</tex>. В частности, <tex>F \leqslant P_i</tex>, таким образом получаем:

<tex>(l - 1)F \leqslant \displaystyle \sum_{i = 1}^{l - 1} P_i \leqslant P</tex>
}}

{{Лемма
|about = 2
|statement=
Пусть <tex> N </tex> {{---}} сеть, а <tex>f</tex> {{---}} допустимый поток в этой сети. Тогда общий потенциал в остаточной сети <tex>G_f</tex> равен общему потенциалу <tex>N</tex>.
|proof=
По [[Теорема_о_декомпозиции | теореме о декомпозиции]] поток можно разбить на множество простых путей из <tex>s</tex> в <tex>t</tex> и циклов. Рассмотрим каждый путь (цикл) и убедимся, что, пуская по нему поток <tex>f_i</tex>, потенциал вершины не изменится. Действительно, рассмотрим вершину <tex>v</tex>, поток <tex>f_i</tex> в нее течет по ребру <tex>uv</tex>, а из нее по ребру <tex>vw</tex>. Пусть <tex>c_{f_i}</tex> {{---}} функция пропускных способностей в остаточной сети после пропускания потока по <tex>i</tex>-ому пути (циклу). Рассмотрим <tex>c^+_{f_1}(v) = c_{f_1}(uv) + c_{f_1}(wv)</tex>. <tex>c_{f_1}(uv) = c(uv) - f_i</tex>, а <tex>c_{f_1}(wv) = c(wv) + f_i</tex>, сложив эти два значения, получим, что <tex>c^+(v)</tex> остается неизменной. Применив такое же рассуждение для <tex>c^-(v)</tex>, получим, что потенциал каждой вершины остается неизменным.
}}
{{Теорема
|id=th1.
|about=Первая теорема Карзанова
|statement=Число итераций [[Схема алгоритма Диница|алгоритма Диница]] в сети <tex>N</tex> (<tex>s</tex> — исток, <tex>t</tex> — сток) с целочисленными пропускными способностями — <tex>O(\sqrt{P})</tex>.
|proof=
Пусть <tex>F</tex> {{---}} максимальный поток в сети <tex>N</tex>. Теорема верна для <tex>F \leqslant \sqrt{P}</tex>, так как после каждой фазы поток увеличивается хотя бы на <tex>1</tex>. Если <tex>F > \sqrt{P}</tex>, рассмотрим последнюю фазу, на момент начала выполнения которой поток в сети был меньше, чем <tex>F - \sqrt{P}</tex>. После этого потребуется не больше <tex>\sqrt{P}</tex> фаз, чтобы найти максимальный поток. На предыдущей фазе поток (<tex>f</tex>) в <tex>N</tex> был не больше <tex>F-\sqrt{P}</tex>, таким образом <tex>F-|f| \geqslant \sqrt{P}</tex>.

<tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F-|f|</tex> и потенциалом <tex>P</tex> (по Лемме(2)). Поэтому можно воспользоваться Леммой(1), чтобы оценить расстояние между <tex>s</tex> и <tex>t</tex> в <tex>G_f</tex>, и получить оценку длины <tex>l</tex> слоистой сети:

<tex>l \leqslant \dfrac{P}{F-|f|} + 1</tex>

Так как каждая фаза увеличивает длину слоистой сети минимум на один, то осуществляется не больше <tex>\sqrt{P}</tex> фаз. Таким образом происходит не более <tex>2\sqrt{P}</tex> фаз.
}}

{{Лемма
|about = 3
|statement=
Пусть в сети <tex>N</tex> нет [[Основные определения теории графов#def1|параллельных ребер]]. Пусть <tex>F</tex> {{---}} максимальный поток в <tex>N</tex>. Тогда расстояние <tex>l</tex> между <tex>s</tex> и <tex>t</tex> в <tex>N</tex> таково: <tex>l \leqslant |V|\sqrt{\dfrac{2C}{F}} - 1</tex>.
|proof=
Обозначим <tex>V_i</tex> как набор вершин на расстоянии <tex>i</tex> от <tex>s</tex>. Множества <tex>X = \bigcup\limits_{i = 0}^k V_i</tex> и <tex>Y = V - X</tex> определяют разрез <tex>(X, Y)</tex>. Пропускная способность этого разреза не больше <tex>2C|V_k||V_{k + 1}|</tex>, так как все ребра между <tex>X</tex> и <tex>Y</tex> также являются ребрами между <tex>V_k</tex> и <tex>V_{k+1}</tex> и не более чем двумя параллельными ребрами, исходящими из какой-то вершины в остаточной сети. По теореме о максимальном потоке/минимальном разрезе, <tex>F \leqslant 2C|V_k||V_{k+1}|</tex>.
Таким образом <tex>F</tex> ограничен наименьшим из <tex>|V_k||V_{k+1}|</tex>. Но эта величина максимальна, когда <tex>|V_i| = \dfrac{|V|}{(l+1)}</tex> для <tex>0 \leqslant i \leqslant n</tex>, таким образом <tex>F \leqslant 2C\dfrac{|V|^2 }{ (l+1)^2}</tex>, из чего следует необходимое неравенство.
}}

{{Теорема
|id=th2
|about=Вторая теорема Карзанова
|statement=Число итераций алгоритма Диница с целочисленными пропускными способностями {{---}} <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex>.
|proof=
Если <tex>F \leqslant C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>, то теорема очевидна.
Положим, что <tex>F > C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>, и рассмотрим последнюю фазу, в которой поток <tex>f</tex> не превышает <tex>F - C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>. В этот момент осталось не более <tex>C^{\frac{1}{3}}|V|^{\frac{2}{3}} + 1</tex> фаз, и <tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F - |f| \geqslant C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>. Мы можем применить Лемму(3), чтобы оценить длину <tex>l</tex> слоистой сети, и, соответственно, количество выполненных фаз:

<tex>l \leqslant |V|{(\dfrac{2C}{F-|f|})}^{\frac{1}{2}} - 1 \leqslant 2^{\frac{1}{2}}C^{\frac{1}{3}}|V|^{\frac{2}{3}} - 1</tex>.

Таким образом, прошло <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex> фаз, и <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex> фаз осталось.
}}

== См. также ==
*[[Схема алгоритма Диница]]

== Источники информации ==
* [http://www.springerlink.com/content/w0q006u3631gg124/fulltext.pdf On the efficiency of Maximum-Flow Algorithms on Networks with Small Integer Capacities. David Fernandez-Baca and Charles U.Martel]
* [https://www.youtube.com/watch?v=sEwp5ZAJJps&feature=youtu.be&t=26m41s Андрей Станкевич: Лекториум, дополнительные главы алгоритмов, лекция 12]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о максимальном потоке]]

Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями

2017-01-04T17:26:57Z

Nikitaevg: /* Теоремы */

==Обозначения==
Введём следующие обозначения:
* <tex>N = (V,E,s,t,c)</tex> {{---}} [[Определение сети, потока|сеть]] с целочисленными пропускными способностями,
* обозначим <tex>C = \max\limits_{uv \in E} c_{uv}</tex> и <tex>F</tex> как максимальный поток,
*<tex>c^{+}(v) = \sum\limits_{uv \in E} c_{uv}</tex>,
*<tex>c^{-}(v) = \sum\limits_{vu \in E} c_{vu}</tex>,
*<tex>p(v) = \min\big\{c^{+}(v), c^{-}(v)\big\}</tex> {{---}} потенциал вершины <tex>v</tex>,
*<tex>P = \sum\limits_{v \in V, v \neq s,t}p(v)</tex> {{---}} общий потенциал,
*<tex>G_f</tex> {{---}} [[Дополняющая сеть, дополняющий путь|остаточная сеть]].

==Теоремы==
{{Лемма
|about = 1
|statement=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex> в исходной сети, максимальный поток в этой сети равен <tex>F</tex>.

Тогда <tex>l \leqslant \dfrac{P}{F} + 1</tex>

|proof=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex>, а <tex>V_i</tex> {{---}} набор вершин, удаленных от <tex>s</tex> на <tex>i</tex> <tex>(i \leqslant l)</tex>.
<tex>V_i</tex> {{---}} разъединяющее множество узлов: при его удалении исчезают все пути из <tex>s</tex> в <tex>t</tex>.
Следуя закону [[Определение сети, потока|сохранения потока]], если <tex>f</tex> обозначить как любой допустимый поток, то <tex>|f|</tex> единиц потока должно проходить через <tex>V_i</tex>.
Но суммарное количество потока, которое может проходить через любую вершину не превосходит ее потенциала.
Отсюда, если обозначить <tex>P_i</tex> как общий потенциал вершин из <tex>V_i</tex>, то мы имеем:

<tex>|f| \leqslant P_i</tex>

для любого допустимого потока <tex>f</tex>. В частности, <tex>F \leqslant P_i</tex>, таким образом получаем:

<tex>(l - 1)F \leqslant \displaystyle \sum_{i = 1}^{l - 1} P_i \leqslant P</tex>
}}

{{Лемма
|about = 2
|statement=
Пусть <tex> N </tex> {{---}} сеть, а <tex>f</tex> {{---}} допустимый поток в этой сети. Тогда общий потенциал в остаточной сети <tex>G_f</tex> равен общему потенциалу <tex>N</tex>.
|proof=
По [[Теорема_о_декомпозиции | теореме о декомпозиции]] поток можно разбить на множество простых путей из <tex>s</tex> в <tex>t</tex> и циклов. Рассмотрим каждый путь (цикл) и убедимся, что, пуская по нему поток <tex>f_i</tex>, потенциал вершины не изменится. Действительно, рассмотрим вершину <tex>v</tex>, поток <tex>f_i</tex> в нее течет по ребру <tex>uv</tex>, а из нее по ребру <tex>vw</tex>. Пусть <tex>c_{f_i}</tex> {{---}} функция пропускных способностей в остаточной сети после пропускания потока по <tex>i</tex>-ому пути (циклу). Рассмотрим <tex>c^+_{f_1}(v) = c_{f_1}(uv) + c_{f_1}(wv)</tex>. <tex>c_{f_1}(uv) = c(uv) - f_i</tex>, а <tex>c_{f_1}(wv) = c(wv) + f_i</tex>, сложив эти два значения, получим, что <tex>c^+(v)</tex> остается неизменной. Применив такое же рассуждение для <tex>c^-(v)</tex>, получим, что потенциал каждой вершины остается неизменным.
}}
{{Теорема
|id=th1.
|about=Первая теорема Карзанова
|statement=Число итераций [[Схема алгоритма Диница|алгоритма Диница]] в сети <tex>N</tex> (<tex>s</tex> — исток, <tex>t</tex> — сток) с целочисленными пропускными способностями — <tex>O(\sqrt{P})</tex>.
|proof=
Пусть <tex>F</tex> {{---}} максимальный поток в сети <tex>N</tex>. Теорема верна для <tex>F \leqslant \sqrt{P}</tex>, так как после каждой фазы поток увеличивается хотя бы на <tex>1</tex>. Если <tex>F > \sqrt{P}</tex>, рассмотрим последнюю фазу, на момент начала выполнения которой поток в сети был меньше, чем <tex>F - \sqrt{P}</tex>. После этого потребуется не больше <tex>\sqrt{P}</tex> фаз, чтобы найти максимальный поток. На предыдущей фазе поток (<tex>f</tex>) в <tex>N</tex> был не больше <tex>F-\sqrt{P}</tex>, таким образом <tex>F-|f| \geqslant \sqrt{P}</tex>.

<tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F-|f|</tex> и потенциалом <tex>P</tex> (по Лемме(2)). Поэтому можно воспользоваться Леммой(1), чтобы оценить расстояние между <tex>s</tex> и <tex>t</tex> в <tex>G_f</tex>, и получить оценку длины <tex>l</tex> слоистой сети:

<tex>l \leqslant \dfrac{P}{F-|f|} + 1</tex>

Так как каждая фаза увеличивает длину слоистой сети минимум на один, то осуществляется не больше <tex>\sqrt{P}</tex> фаз. Таким образом происходит не более <tex>2\sqrt{P}</tex> фаз.
}}

{{Лемма
|about = 3
|statement=
Пусть в сети <tex>N</tex> нет [[Основные определения теории графов#def1|параллельных ребер]]. Пусть <tex>F</tex> {{---}} максимальный поток в <tex>N</tex>. Тогда расстояние <tex>l</tex> между <tex>s</tex> и <tex>t</tex> в <tex>N</tex> таково: <tex>l \leqslant |V|\sqrt{\dfrac{2C}{F}} - 1</tex>.
|proof=
Обозначим <tex>V_i</tex> как набор вершин на расстоянии <tex>i</tex> от <tex>s</tex>. Множества <tex>X = \bigcup\limits_{i = 0}^k V_i</tex> и <tex>Y = V - X</tex> определяют разрез <tex>(X, Y)</tex>. Пропускная способность этого разреза не больше <tex>2C|V_k||V_{k + 1}|</tex>, так как все ребра между <tex>X</tex> и <tex>Y</tex> также являются ребрами между <tex>V_k</tex> и <tex>V_{k+1}</tex> и не более чем двумя параллельными ребрами, исходящими из какой-то вершины в остаточной сети. По теореме о максимальном потоке/минимальном разрезе, <tex>F \leqslant 2C|V_k||V_{k+1}|</tex>.
Таким образом <tex>F</tex> ограничен наименьшим из <tex>|V_k||V_{k+1}|</tex>. Но эта величина максимальна, когда <tex>|V_i| = \dfrac{|V|}{(l+1)}</tex> для <tex>0 \leqslant i \leqslant n</tex>, таким образом <tex>F \leqslant 2C\dfrac{|V|^2 }{ (l+1)^2}</tex>, из чего следует необходимое неравенство.
}}

{{Теорема
|id=th2
|about=Вторая теорема Карзанова
|statement=Число итераций алгоритма Диница с целочисленными пропускными способностями {{---}} <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex>.
|proof=
Если <tex>F \leqslant C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>, то теорема очевидна.
Положим, что <tex>F > C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>, и рассмотрим последнюю фазу, в которой поток <tex>f</tex> не превышает <tex>F - C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>. В этот момент осталось не более <tex>C^{\frac{1}{3}}|V|^{\frac{2}{3}} + 1</tex> фаз, и <tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F - |f| \geqslant C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>. Мы можем применить Лемму(3), чтобы оценить длину <tex>l</tex> слоистой сети, и, соответственно, количество выполненных фаз:

<tex>l \leqslant |V|{(\dfrac{2C}{F-|f|})}^{\frac{1}{2}} - 1 \leqslant 2^{\frac{1}{2}}C^{\frac{1}{3}}|V|^{\frac{2}{3}} - 1</tex>.

Таким образом, прошло <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex> фаз, и <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex> фаз осталось.
}}

== См. также ==
*[[Схема алгоритма Диница]]

== Источники информации ==
* [http://www.springerlink.com/content/w0q006u3631gg124/fulltext.pdf On the efficiency of Maximum-Flow Algorithms on Networks with Small Integer Capacities. David Fernandez-Baca and Charles U.Martel]
* [https://www.youtube.com/watch?v=sEwp5ZAJJps&feature=youtu.be&t=26m41s Андрей Станкевич: Лекториум, дополнительные главы алгоритмов, лекция 12]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о максимальном потоке]]

Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями

2017-01-04T17:16:25Z

Nikitaevg: /* Обозначения */

==Обозначения==
Введём следующие обозначения:
* <tex>N = (V,E,s,t,c)</tex> {{---}} [[Определение сети, потока|сеть]] с целочисленными пропускными способностями,
* обозначим <tex>C = \max\limits_{uv \in E} c_{uv}</tex> и <tex>F</tex> как максимальный поток,
*<tex>c^{+}(v) = \sum\limits_{uv \in E} c_{uv}</tex>,
*<tex>c^{-}(v) = \sum\limits_{vu \in E} c_{vu}</tex>,
*<tex>p(v) = \min\big\{c^{+}(v), c^{-}(v)\big\}</tex> {{---}} потенциал вершины <tex>v</tex>,
*<tex>P = \sum\limits_{v \in V, v \neq s,t}p(v)</tex> {{---}} общий потенциал,
*<tex>G_f</tex> {{---}} [[Дополняющая сеть, дополняющий путь|остаточная сеть]].

==Теоремы==
{{Лемма
|about = 1
|statement=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex> в исходной сети, максимальный поток в этой сети равен <tex>F</tex>.

Тогда <tex>l \leqslant \dfrac{P}{F} + 1</tex>

|proof=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex>, а <tex>V_i</tex> {{---}} набор вершин, удаленных от <tex>s</tex> на <tex>i</tex> <tex>(i \leqslant l)</tex>.
<tex>V_i</tex> {{---}} разъединяющее множество узлов: при его удалении исчезают все пути из <tex>s</tex> в <tex>t</tex>.
Следуя закону [[Определение сети, потока|сохранения потока]], если <tex>f</tex> обозначить как любой допустимый поток, то <tex>|f|</tex> единиц потока должно проходить через <tex>V_i</tex>.
Но суммарное количество потока, которое может проходить через любую вершину не превосходит ее потенциала.
Отсюда, если обозначить <tex>P_i</tex> как общий потенциал вершин из <tex>V_i</tex>, то мы имеем:

<tex>|f| \leqslant P_i</tex>

для любого допустимого потока <tex>f</tex>. В частности, <tex>F \leqslant P_i</tex>, таким образом получаем:

<tex>(l - 1)F \leqslant \displaystyle \sum_{i = 1}^{l - 1} P_i \leqslant P</tex>
}}

{{Лемма
|about = 2
|statement=
Пусть <tex> N </tex> {{---}} сеть, а <tex>f</tex> {{---}} допустимый поток в этой сети. Тогда общий потенциал в остаточной сети <tex>G_f</tex> равен общему потенциалу <tex>N</tex>.
|proof=
По [[Теорема_о_декомпозиции | теореме о декомпозиции]] поток можно разбить на множество простых путей из <tex>s</tex> в <tex>t</tex> и циклов. Рассмотрим каждый путь (цикл) и убедимся, что, пуская по нему поток <tex>f_i</tex>, потенциал вершины не изменится. Действительно, рассмотрим вершину <tex>v</tex>, поток <tex>f_i</tex> в нее течет по ребру <tex>uv</tex>, а из нее по ребру <tex>vw</tex>. Пусть <tex>c_{f_i}</tex> {{---}} функция пропускных способностей в остаточной сети после пропускания потока по <tex>i</tex>-ому пути (циклу). Рассмотрим <tex>c^+_{f_1}(v) = c_{f_1}(uv) + c_{f_1}(wv)</tex>. <tex>c_{f_1}(uv) = c(uv) - f_i</tex>, а <tex>c_{f_1}(wv) = c(wv) + f_i</tex>, сложив эти два значения, получим, что <tex>c^+(v)</tex> остается неизменной. Применив такое же рассуждение для <tex>c^-(v)</tex>, получим, что потенциал каждой вершины остается неизменным.
}}
{{Теорема
|id=th1.
|about=Первая теорема Карзанова
|statement=Число итераций [[Схема алгоритма Диница|алгоритма Диница]] в сети <tex>N</tex> (<tex>s</tex> — исток, <tex>t</tex> — сток) с целочисленными пропускными способностями — <tex>O(\sqrt{P})</tex>.
|proof=
Пусть <tex>F</tex> {{---}} максимальный поток в сети <tex>N</tex>. Теорема верна для <tex>F \leqslant \sqrt{P}</tex>, так как после каждой фазы поток увеличивается хотя бы на <tex>1</tex>. Если <tex>F > \sqrt{P}</tex>, рассмотрим последнюю фазу, на момент начала выполнения которой поток в сети был меньше, чем <tex>F - \sqrt{P}</tex>. После этого потребуется не больше <tex>\sqrt{P}</tex> фаз, чтобы найти максимальный поток. На предыдущей фазе поток (<tex>f</tex>) в <tex>N</tex> был не больше <tex>F-\sqrt{P}</tex>, таким образом <tex>F-|f| \geqslant \sqrt{P}</tex>.

<tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F-|f|</tex> и потенциалом <tex>P</tex> (по Лемме(2)). Поэтому можно воспользоваться Леммой(1), чтобы оценить расстояние между <tex>s</tex> и <tex>t</tex> в <tex>G_f</tex>, и получить оценку длины <tex>l</tex> слоистой сети:

<tex>l \leqslant \dfrac{P}{F-|f|} + 1</tex>

Так как каждая фаза увеличивает длину слоистой сети минимум на один, то осуществляется не больше <tex>\sqrt{P}</tex> фаз. Таким образом происходит не более <tex>2\sqrt{P}</tex> фаз.
}}

{{Лемма
|about = 3
|statement=
Пусть в сети <tex>N</tex> нет [[Основные определения теории графов#def1|параллельных ребер]]. Пусть <tex>F</tex> {{---}} максимальный поток в <tex>N</tex>. Тогда расстояние <tex>l</tex> между <tex>s</tex> и <tex>t</tex> в <tex>N</tex> таково: <tex>l \leqslant |V|\sqrt{\dfrac{2C}{F}} - 1</tex>.
|proof=
Обозначим <tex>V_i</tex> как набор вершин на расстоянии <tex>i</tex> от <tex>s</tex>. Множества <tex>X = \bigcup_{i = 0}^k V_i</tex> и <tex>Y = V - X</tex> определяют разрез <tex>(X, Y)</tex>. Пропускная способность этого разреза не больше <tex>2C|V_k||V_{k + 1}|</tex>, так как все ребра между <tex>X</tex> и <tex>Y</tex> также являются ребрами между <tex>V_k</tex> и <tex>V_{k+1}</tex> и не более чем двумя параллельными ребрами, исходящими из какой-то вершины в остаточной сети. По теореме о максимальном потоке/минимальном разрезе, <tex>F \leqslant 2C|V_k||V_{k+1}|</tex>.
Таким образом <tex>F</tex> ограничен наименьшим из <tex>|V_k||V_{k+1}|</tex>. Но эта величина максимальна, когда <tex>|V_i| = \dfrac{|V|}{(l+1)}</tex> для <tex>0 \leqslant i \leqslant n</tex>, таким образом <tex>F \leqslant 2C\dfrac{|V|^2 }{ (l+1)^2}</tex>. Выражая <tex>l</tex>, получаем нужное.
}}

{{Теорема
|id=th2
|about=Вторая теорема Карзанова
|statement=Число итераций алгоритма Диница с целочисленными пропускными способностями {{---}} <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex>.
|proof=
Если <tex>F \leqslant C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>, то теорема очевидна.
Положим, что <tex>F > C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>, и рассмотрим последнюю фазу, в которой поток <tex>f</tex> не превышает <tex>F - C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>. В этот момент осталось не более <tex>C^{\frac{1}{3}}|V|^{\frac{2}{3}} + 1</tex> фаз, и <tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F - |f| \geqslant C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>. Мы можем применить Лемму(3), чтобы оценить длину <tex>l</tex> слоистой сети, и, соответственно, количество выполненных фаз:

<tex>l \leqslant |V|{(\dfrac{2C}{F-|f|})}^{\frac{1}{2}} - 1 \leqslant 2^{\frac{1}{2}}C^{\frac{1}{3}}|V|^{\frac{2}{3}} - 1</tex>.

Таким образом, прошло <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex> фаз, и <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex> фаз осталось.
}}

== См. также ==
*[[Схема алгоритма Диница]]

== Источники информации ==
* [http://www.springerlink.com/content/w0q006u3631gg124/fulltext.pdf On the efficiency of Maximum-Flow Algorithms on Networks with Small Integer Capacities. David Fernandez-Baca and Charles U.Martel]
* [https://www.youtube.com/watch?v=sEwp5ZAJJps&feature=youtu.be&t=26m41s Андрей Станкевич: Лекториум, дополнительные главы алгоритмов, лекция 12]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о максимальном потоке]]

Теорема Менгера

2017-01-04T17:13:51Z

Nikitaevg:

Теорема Менгера представляет собой группу теорем, связывающих такие понятия на графах как ''<tex>k</tex>-связность'' и ''количество непересекающихся путей'' относительно двух выделенных вершин. Возникают различные варианты очень похожих друг на друга по формулировке теорем в зависимости от того, рассматриваем ли мы ситуацию в ''ориентированном'' или ''неориентированном'' графе, и подразумеваем ли ''реберную <tex>k</tex>-связность'' и ''реберно непересекающиеся пути'' или же ''вершинную <tex>k</tex>-связность'' и ''вершинно непересекающиеся пути''.

==Подготовка к доказательству==
Для доказательства мы будем пользоваться развитой раннее [[Определение сети, потока|теорией потоков]]. Кроме базовых определений нам потребуется понятие [[Дополняющая сеть, дополняющий путь| остаточной сети]] (иначе {{---}} дополнительной сети), а также [[Теорема_Форда-Фалкерсона|теорема Форда-Фалкерсона]].

Кроме того, потребуется лемма о целочисленности потока, которую сейчас и докажем:
{{Лемма
|about=о целочисленности потока
|statement=      Если пропускные способности всех ребер целочисленные (сеть целочислена), то существует максимальный поток, целочисленный на каждом ребре.
|proof=
:Для доказательства достаточно рассмотреть [[Алгоритм Форда-Фалкерсона, реализация с помощью поиска в глубину|алгоритм Форда-Фалкерсона]] для поиска максимального потока. Алгоритм делает примерно следующее (подробней {{---}} читай в соответствующей статье):

:# В начале берем какой-нибудь поток за начальный (например, нулевой).
:# В остаточной сети этого потока находим какой-нибудь путь из источника к стоку и увеличиваем поток на пропускную способность этого пути.
:# Повторяем пункт <tex>2</tex> до тех пор, пока находится хоть какой-то путь в остаточной сети.

:То, что получится в конце, будет максимальным потоком. В случае целочисленной сети достаточно в качестве начального приближения взять нулевой поток, и не трудно видеть, что на каждой итерации (в том числе и последней) этот поток будет оставаться целочисленным, что и докажет требуемое.
}}

И, наконец, сделаем немного более осознанным в общем-то и так интуитивно понятное утверждение:
{{Утверждение
|statement=Если в сети, где все пропускные способности ребер равны <tex>1</tex>, существует целочисленный поток величиной <tex>L</tex> то существует и <tex>L</tex> реберно непересекающихся путей.
|proof=
: Считаем, что <tex>u</tex> {{---}} источник, <tex>v</tex> {{---}} сток.
: В начале поймем, что если поток не нулевой, то существует маршрут из <tex>u</tex> в <tex>v</tex> лежащий только на ребрах с потоком равным <tex>1</tex>. В самом деле, если бы такого маршрута не существовало, то можно было бы выделить множество вершин до которых такие маршруты из вершины <tex>u</tex> существуют, не включающее <tex>v</tex>, и по нему построить разрез. Поток через такой разрез, очевидно равен нулю, видим противоречие (т.к. <tex>f(U,V)=|f|</tex>, смотри [[Разрез, лемма о потоке через разрез|первую лемму]]).

:Итак, найдем какой-нибудь маршрут из <tex>u</tex> в <tex>v</tex> лежащий только на ребрах где поток равен <tex>1</tex>. Удалив все ребра находящиеся в этом маршруте и оставив все остальное неизменным, придем к целочисленному потоку величиной <tex>L-1</tex>. Ясно, что можно повторить тоже самое еще <tex>L-1</tex> раз, и, таким образом мы выделим <tex>L</tex> реберно непересекающихся маршрутов.
}}

==Теорема==
Теперь сама теорема будет тривиальным следствием. В начале сформулируем и докажем реберную версию для случая ориентированного графа.

{{Теорема
|about=Менгера о реберной двойственности в ориентированном графе
|statement=Между вершинами <tex>u</tex> и <tex>v</tex> существует <tex>L</tex> реберно непересекающихся путей тогда и только тогда, когда после удаления любых <tex>(L-1)</tex> ребер существует путь из <tex>u</tex> в <tex>v</tex>.
|proof=
:<tex>\Leftarrow</tex> Как и прежде, пусть <tex>u</tex> {{---}} источник, а <tex>v</tex> {{---}} сток.
:Назначим каждому ребру пропускную способность <tex>1</tex>. Тогда существует максимальный поток, целочисленный на каждом ребре (по лемме).
:По теореме Форда-Фалкерсона для такого потока существует разрез с пропускной способностью равной потоку. Удалим в этом разрезе <tex>L-1</tex> ребер, и тогда, раз <tex>u</tex> и <tex>v</tex> находятся в разных частях разреза и, существует путь из <tex>u</tex> в <tex>v</tex>, то в разрезе останется хотя бы еще одно ребро. Это значит, что пропускная способность разреза и вместе с ним величина потока не меньше <tex>L</tex>. А так как поток целочисленный, то это и означает, что найдется <tex> L</tex> реберно непересекающихся путей.

:<tex>\Rightarrow</tex> Существует <tex> L</tex> реберно непересекающихся путей, а значит, удалив любые <tex>L-1</tex> ребер хотя бы один путь останется не тронутым (принцип Дирихле). Это и означает, что существует путь из <tex>u</tex> в <tex>v</tex>.
}}

{{Теорема
|about=Менгера о вершинной двойственности в ориентированном графе
|statement=Между вершинами <tex>u</tex> и <tex>v</tex> существует <tex>L</tex> вершинно непересекающихся путей тогда и только тогда, когда после удаления любых <tex>(L-1)</tex> вершин существует путь из <tex>u</tex> в <tex>v</tex>.
|proof=

:Разобьем каждую вершину на две таким образом:

:[[Файл:Menger-vertex.JPG]]

:''(все входящие ребра заходят в левую вершину, исходящие выходят из правой. между двумя новыми вершинами добавляем ребро)''

:Теперь задача практически сведена к первой теореме.
:Необходимо лишь отметить, что если в старом графе пути вершинно пересекаются, то в новом графе пути необходимо реберно пересекаются и наоборот.
:Кроме того, предложение "удалить в исходном графе любые <tex>L</tex> вершин" можно заменять на "в новом графе можно удалить любые <tex>L</tex> ребер" (достаточно выбирать вершины на концах этих ребер). Можно заменять и обратно, если учесть, что можно удалять ребра между парой вершин, которые раньше были одним целым.
}}
<includeonly>
Теоремы для неориентированного графа формулируются идентично, а их доказательства сводятся к своим ориентированным двойникам путем замены каждого ребра на две дуги:

[[Файл:Menger_undirected.JPG‎]]
</includeonly>

==См. также==
*[[Теорема Менгера, альтернативное доказательство]]
* [[wikipedia:Menger's theorem | Wikipedia {{---}} Menger's theorem ]]

==Источники информации==
* Ловас Л., Пламмер М. {{---}} '''Прикладные задачи теории графов. Теория паросочетаний в математике, физике, химии''' (глава 2.4 стр. 117) {{---}} 1998. {{---}} 656 с. {{---}} ISBN 5-03-002517-0
* Харари Ф. '''Теория графов.''' глава 5 — М.: Мир, 1973. (Изд. 3, М.: КомКнига, 2006. — 296 с.)

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Связность в графах]]

Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями

2017-01-03T17:55:14Z

Nikitaevg:

==Обозначения==
* Пусть <tex>N = (V,E,s,t,c)</tex> {{---}} [[Определение сети, потока|сеть]] с целочисленными пропускными способностями.
* Обозначим <tex>C = \max\limits_{uv \in E} c_{uv}</tex> и <tex>F</tex> как максимальный поток.
*<tex>c^{+}(v) = \sum\limits_{uv \in E} c_{uv}</tex>.
*<tex>c^{-}(v) = \sum\limits_{vu \in E} c_{vu}</tex>.
*<tex>p(v) = min\big\{c^{+}(v), c^{-}(v)\big\}</tex> {{---}} потенциал вершины <tex>v</tex>.
*<tex>P = \sum\limits_{v \in V, v \neq s,t}p(v)</tex> {{---}} общий потенциал.
*<tex>G_f</tex> {{---}} [[Дополняющая сеть, дополняющий путь|остаточная сеть]].

==Теоремы==
{{Лемма
|about = 1
|statement=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex> в исходной сети, максимальный поток в этой сети равен <tex>F</tex>.

Тогда <tex>l \leqslant \dfrac{P}{F} + 1</tex>

|proof=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex>, а <tex>V_i</tex> {{---}} набор вершин, удаленных от <tex>s</tex> на <tex>i</tex> <tex>(i \leqslant l)</tex>.
<tex>V_i</tex> {{---}} разъединяющее множество узлов: при его удалении исчезают все пути из <tex>s</tex> в <tex>t</tex>.
Следуя закону [[Определение сети, потока|сохранения потока]], если <tex>f</tex> обозначить как любой допустимый поток, то <tex>|f|</tex> единиц потока должно проходить через <tex>V_i</tex>.
Но суммарное количество потока, которое может проходить через любую вершину не превосходит ее потенциала.
Отсюда, если обозначить <tex>P_i</tex> как общий потенциал вершин из <tex>V_i</tex>, то мы имеем:

<tex>|f| \leqslant P_i</tex>

для любого допустимого потока <tex>f</tex>. В частности, <tex>F \leqslant P_i</tex>, таким образом получаем:

<tex>(l - 1)F \leqslant \displaystyle \sum_{i = 1}^{l - 1} P_i \leqslant P</tex>
}}

{{Лемма
|about = 2
|statement=
Пусть <tex> N </tex> {{---}} сеть, а <tex>f</tex> {{---}} допустимый поток в этой сети. Тогда общий потенциал в остаточной сети <tex>G_f</tex> равен общему потенциалу <tex>N</tex>.
|proof=
По [[Теорема_о_декомпозиции | теореме о декомпозиции]] поток можно разбить на множество простых путей из <tex>s</tex> в <tex>t</tex> и циклов. Рассмотрим каждый путь (цикл) и убедимся, что, пуская по нему поток <tex>f_i</tex>, потенциал вершины не изменится. Действительно, рассмотрим вершину <tex>v</tex>, поток <tex>f_i</tex> в нее течет по ребру <tex>uv</tex>, а из нее по ребру <tex>vw</tex>. Пусть <tex>c_{f_i}</tex> {{---}} функция пропускных способностей в остаточной сети после пропускания потока по <tex>i</tex>-ому пути (циклу). Рассмотрим <tex>c^+_{f_1}(v) = c_{f_1}(uv) + c_{f_1}(wv)</tex>. <tex>c_{f_1}(uv) = c(uv) - f_i</tex>, а <tex>c_{f_1}(wv) = c(wv) + f_i</tex>, сложив эти два значения, получим, что <tex>c^+(v)</tex> остается неизменной. Применив такое же рассуждение для <tex>c^-(v)</tex>, получим, что потенциал каждой вершины остается неизменным.
}}
{{Теорема
|id=th1.
|about=Первая теорема Карзанова
|statement=Число итераций [[Схема алгоритма Диница|алгоритма Диница]] в сети <tex>N</tex> (<tex>s</tex> — исток, <tex>t</tex> — сток) с целочисленными пропускными способностями — <tex>O(\sqrt{P})</tex>.
|proof=
Пусть <tex>F</tex> {{---}} максимальный поток в сети <tex>N</tex>. Теорема верна для <tex>F \leqslant \sqrt{P}</tex>, так как после каждой фазы поток увеличивается хотя бы на <tex>1</tex>. Если <tex>F > \sqrt{P}</tex>, рассмотрим последнюю фазу, на момент начала выполнения которой поток в сети был меньше, чем <tex>F - \sqrt{P}</tex>. После этого потребуется не больше <tex>\sqrt{P}</tex> фаз, чтобы найти максимальный поток. На предыдущей фазе поток (<tex>f</tex>) в <tex>N</tex> был не больше <tex>F-\sqrt{P}</tex>, таким образом <tex>F-|f| \geqslant \sqrt{P}</tex>.

<tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F-|f|</tex> и потенциалом <tex>P</tex> (по Лемме(2)). Поэтому можно воспользоваться Леммой(1), чтобы оценить расстояние между <tex>s</tex> и <tex>t</tex> в <tex>G_f</tex>, и получить оценку длины <tex>l</tex> слоистой сети:

<tex>l \leqslant \dfrac{P}{F-|f|} + 1</tex>

Так как каждая фаза увеличивает длину слоистой сети минимум на один, то осуществляется не больше <tex>\sqrt{P}</tex> фаз. Таким образом происходит не более <tex>2\sqrt{P}</tex> фаз.
}}

{{Лемма
|about = 3
|statement=
Пусть в сети <tex>N</tex> нет [[Основные определения теории графов#def1|параллельных ребер]]. Пусть <tex>F</tex> {{---}} максимальный поток в <tex>N</tex>. Тогда расстояние <tex>l</tex> между <tex>s</tex> и <tex>t</tex> в <tex>N</tex> таково: <tex>l \leqslant |V|\sqrt{\dfrac{2C}{F}} - 1</tex>.
|proof=
Обозначим <tex>V_i</tex> как набор вершин на расстоянии <tex>i</tex> от <tex>s</tex>. Множества <tex>X = \bigcup_{i = 0}^k V_i</tex> и <tex>Y = V - X</tex> определяют разрез <tex>(X, Y)</tex>. Пропускная способность этого разреза не больше <tex>2C|V_k||V_{k + 1}|</tex>, так как все ребра между <tex>X</tex> и <tex>Y</tex> также являются ребрами между <tex>V_k</tex> и <tex>V_{k+1}</tex> и не более чем двумя параллельными ребрами, исходящими из какой-то вершины в остаточной сети. По теореме о максимальном потоке/минимальном разрезе, <tex>F \leqslant 2C|V_k||V_{k+1}|</tex>.
Таким образом <tex>F</tex> ограничен наименьшим из <tex>|V_k||V_{k+1}|</tex>. Но эта величина максимальна, когда <tex>|V_i| = \dfrac{|V|}{(l+1)}</tex> для <tex>0 \leqslant i \leqslant n</tex>, таким образом <tex>F \leqslant 2C\dfrac{|V|^2 }{ (l+1)^2}</tex>. Выражая <tex>l</tex>, получаем нужное.
}}

{{Теорема
|id=th2
|about=Вторая теорема Карзанова
|statement=Число итераций алгоритма Диница с целочисленными пропускными способностями {{---}} <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex>.
|proof=
Если <tex>F \leqslant C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>, то теорема очевидна.
Положим, что <tex>F > C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>, и рассмотрим последнюю фазу, в которой поток <tex>f</tex> не превышает <tex>F - C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>. В этот момент осталось не более <tex>C^{\frac{1}{3}}|V|^{\frac{2}{3}} + 1</tex> фаз, и <tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F - |f| \geqslant C^{\frac{1}{3}}|V|^{\frac{2}{3}}</tex>. Мы можем применить Лемму(3), чтобы оценить длину <tex>l</tex> слоистой сети, и, соответственно, количество выполненных фаз:

<tex>l \leqslant |V|{(\dfrac{2C}{F-|f|})}^{\frac{1}{2}} - 1 \leqslant 2^{\frac{1}{2}}C^{\frac{1}{3}}|V|^{\frac{2}{3}} - 1</tex>.

Таким образом, прошло <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex> фаз, и <tex>O(C^{\frac{1}{3}}|V|^{\frac{2}{3}})</tex> фаз осталось.
}}

== См. также ==
*[[Схема алгоритма Диница]]

== Источники информации ==
* [http://www.springerlink.com/content/w0q006u3631gg124/fulltext.pdf On the efficiency of Maximum-Flow Algorithms on Networks with Small Integer Capacities. David Fernandez-Baca and Charles U.Martel]
* [https://www.youtube.com/watch?v=sEwp5ZAJJps&feature=youtu.be&t=26m41s Андрей Станкевич: Лекториум, дополнительные главы алгоритмов, лекция 12]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о максимальном потоке]]

Теорема Менгера

2017-01-03T14:32:26Z

Nikitaevg:

Теорема Менгера представляет собой группу теорем, связывающих такие понятия на графах как ''k-связность'' и ''количество непересекающихся путей'' относительно двух выделенных вершин. Возникают различные варианты очень похожих друг на друга по формулировке теорем в зависимости от того, рассматриваем ли мы ситуацию в ''ориентированном'' или ''неориентированном'' графе, и подразумеваем ли ''реберную k-связность'' и ''реберно непересекающиеся пути'' или же ''вершинную k-связность'' и ''вершинно непересекающиеся пути''.

==Подготовка к доказательству==
Для доказательства мы будем пользоваться развитой раннее [[Определение сети, потока|теорией потоков]]. Кроме базовых определений нам потребуется понятие [[Дополняющая сеть, дополняющий путь| остаточной сети]] (иначе {{---}} дополнительной сети), а также [[Теорема_Форда-Фалкерсона|теорема Форда-Фалкерсона]].

Кроме того, потребуется лемма о целочисленности потока, которую сейчас и докажем:
{{Лемма
|about=о целочисленности потока
|statement=      Если пропускные способности всех ребер целочисленные (сеть целочислена), то существует максимальный поток, целочисленный на каждом ребре.
|proof=
:Для доказательства достаточно рассмотреть [[Алгоритм Форда-Фалкерсона, реализация с помощью поиска в глубину|алгоритм Форда-Фалкерсона]] для поиска максимального потока. Алгоритм делает примерно следующее (подробней {{---}} читай в соответствующей статье):

:''1.'' В начале берем какой-нибудь поток за начальный (например, нулевой).

:''2.'' В остаточной сети этого потока находим какой-нибудь путь из источника к стоку и увеличиваем поток на пропускную способность этого пути.

:''3.'' Повторяем пункт ''2'' до тех пор, пока находится хоть какой-то путь в остаточной сети.

:То, что получится в конце, будет максимальным потоком. В случае целочисленной сети достаточно в качестве начального приближения взять нулевой поток, и не трудно видеть, что на каждой итерации (в том числе и последней) этот поток будет оставаться целочисленным, что и докажет требуемое.
}}

И, наконец, сделаем немного более осознаным в общем-то и так интуитивно понятное утверждение:
{{Утверждение
|statement=Если в сети, где все пропускные способности ребер равны 1, существует целочисленный поток величиной <tex>L</tex> то существует и <tex>L</tex> реберно непересекающихся путей.
|proof=
: Считаем, что <tex>u</tex> {{---}} источник, <tex>v</tex> {{---}} сток.
: В начале поймем, что если поток не нулевой, то существует маршрут из <tex>u</tex> в <tex>v</tex> лежащий только на ребрах с потоком равным 1. В самом деле, если бы такого маршрута не существовало, то можно было бы выделить множество вершин до которых такие маршруты из вершины <tex>u</tex> существуют, не включающее <tex>v</tex>, и по нему построить разрез. Поток через такой разрез, очевидно равен нулю, видим противоречие (т.к. <tex>f(U,V)=|f|</tex>, смотри [[Разрез, лемма о потоке через разрез|первую лемму]]).

:Итак, найдем какой-нибудь маршрут из <tex>u</tex> в <tex>v</tex> лежащий только на ребрах где поток равен 1. Удалив все ребра находящиеся в этом маршруте и оставив все остальное неизменным, придем к целочисленному потоку величиной <tex>L-1</tex>. Ясно, что можно повторить тоже самое еще <tex>L-1</tex> раз, и, таким образом мы выделим <tex>L</tex> реберно непересекающихся маршрутов.
}}

==Теорема==
Теперь сама теорема будет тривиальным следствием. В начале сформулируем и докажем реберную версию для случая ориентированного графа.

{{Теорема
|about=Менгера о реберной двойственности в ориентированном графе
|statement=Между вершинами <tex>u</tex> и <tex>v</tex> существует <tex>L</tex> реберно непересекающихся путей тогда и только тогда, когда после удаления любых <tex>(L-1)</tex> ребер существует путь из <tex>u</tex> в <tex>v</tex>.
|proof=
:<tex>\Leftarrow</tex>

:Как и прежде, пусть <tex>u</tex> {{---}} источник, а <tex>v</tex> {{---}} сток.
:Назначим каждому ребру пропускную способность 1. Тогда существует максимальный поток, целочисленный на каждом ребре (по лемме).
:По теореме Форда-Фалкерсона для такого потока существует разрез с пропускной способностью равной потоку. Удалим в этом разрезе <tex>L-1</tex> ребер, и тогда, раз <tex>u</tex> и <tex>v</tex> находятся в разных частях разреза и, существует путь из <tex>u</tex> в <tex>v</tex>, то в разрезе останется хотя бы еще одно ребро. Это значит, что пропускная способность разреза и вместе с ним величина потока не меньше <tex>L</tex>. А так как поток целочисленный, то это и означает, что найдется <tex> L</tex> реберно непересекающихся путей.

:<tex>\Rightarrow</tex>
: существует <tex> L</tex> реберно непересекающихся путей, а значит, удалив любые <tex>L-1</tex> ребер хотя бы один путь останется не тронутым (принцип Дирихле). Это и означает, что существует путь из <tex>u</tex> в <tex>v</tex>.
}}

{{Теорема
|about=Менгера о вершинной двойственности в ориентированном графе
|statement=Между вершинами <tex>u</tex> и <tex>v</tex> существует <tex>L</tex> вершинно непересекающихся путей тогда и только тогда, когда после удаления любых <tex>(L-1)</tex> вершин существует путь из <tex>u</tex> в <tex>v</tex>.
|proof=

:Разобьем каждую вершину на две таким образом:

:[[Файл:Menger-vertex.JPG]]

:''(все входящие ребра заходят в левую вершину, исходящие выходят из правой. между двумя новыми вершинами добавляем ребро)''

:Теперь задача практически сведена к первой теореме.
:Необходимо лишь отметить, что если в старом графе пути вершинно пересекаются, то в новом графе пути необходимо реберно пересекаются и наоборот.
:Кроме того, предложение "удалить в исходном графе любые <tex>L</tex> вершин" можно заменять на "в новом графе можно удалить любые <tex>L</tex> ребер" (достаточно выбирать вершины на концах этих ребер). Можно заменять и обратно, если учесть, что можно удалять ребра между парой вершин, которые раньше были одним целым.
}}
<includeonly>
Теоремы для неориентированного графа формулируются идентично, а их доказательства сводятся к своим ориентированным двойникам путем замены каждого ребра на две дуги:

[[Файл:Menger_undirected.JPG‎]]
</includeonly>

==См. также==
*[[Теорема Менгера, альтернативное доказательство]]
* [[wikipedia:Menger's theorem | Wikipedia {{---}} Menger's theorem ]]

==Литература==
* Ловас Л., Пламмер М. {{---}} '''Прикладные задачи теории графов. Теория паросочетаний в математике, физике, химии''' (глава 2.4 стр. 117) {{---}} 1998. {{---}} 656 с. {{---}} ISBN 5-03-002517-0
* Харари Ф. '''Теория графов.''' глава 5 — М.: Мир, 1973. (Изд. 3, М.: КомКнига, 2006. — 296 с.)

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Связность в графах]]

Непланарность K5 и K3,3

2017-01-03T14:19:27Z

Nikitaevg:

{{Теорема
|about=
Непланарность <tex>K_5</tex>
|statement=
Граф <tex>K_5</tex> [[Укладка графа на плоскости|непланарен]].
|proof=
Граф <tex>K_5</tex> имеет <tex>5</tex> вершин и <tex>10</tex> ребер. Если он планарен, то по [[Формула Эйлера#EulerFormulaCons|следствию из формулы Эйлера]] получаем <tex>10 \leqslant 3 \cdot 5 - 6 = 9</tex>. Что невозможно.
}}
{{Теорема
|about=
Непланарность <tex>K_{3,3}</tex>
|statement=
Граф <tex>K_{3,3}</tex> непланарен.
|proof=
Граф <tex>K_{3,3}</tex> содержит <tex>V = 6</tex>, <tex>E = 9</tex> и <tex>F</tex> [[Укладка графа на плоскости|граней]]. 
Пусть граф <tex>K_{3,3}</tex> планарен. Тогда по [[Формула Эйлера|формуле Эйлера]] <tex>F = E - V + 2 = 9 - 6 + 2 = 5</tex>. Пусть, двигаясь вдоль <tex>i</tex>-й грани мы пройдем <tex>l_i</tex> ребер. Очевидно, что <tex>\sum_{i=1}^{F}l_i = 2E</tex>. Поскольку граф двудольный, все его циклы имеют четную длину. Значит <tex>l_i \geqslant 4</tex>. Получаем <tex>4F \leqslant 2E</tex>, то есть <tex>2F \leqslant E</tex>. То есть <tex>2\cdot5 = 10 \leqslant 9</tex>, что невозможно.
}}

==См. также==
* [[wikipedia:ru:Планарный граф | Википедия {{---}} Планарный граф]]
* [[wikipedia:ru:Домики и колодцы | Википедия {{---}} Домики и колодцы]]

==Источники информации==
* Асанов М. О., Баранский В. А., Расин В. В. {{---}} '''Дискретная математика: Графы, матроиды, алгоритмы: Учебное пособие. 2-е изд., испр. и доп.''' стр. 134 {{---}} СПб.: Издательство "Лань", 2010. {{---}} 368 с.: ил. {{---}} (Учебники для вузов. Специальная литература). ISBN 978-5-8114-1068-2

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Укладки графов ]]

Непланарность K5 и K3,3

2017-01-03T14:14:10Z

Nikitaevg:

{{Теорема
|about=
Непланарность <tex>K_5</tex>
|statement=
Граф <tex>K_5</tex> [[Укладка графа на плоскости|непланарен]].
|proof=
Граф <tex>K_5</tex> имеет <tex>5</tex> вершин и <tex>10</tex> ребер. Если он планарен, то по [[Формула Эйлера#EulerFormulaCons|следствию из формулы Эйлера]] получаем <tex>10 \leqslant 3 \cdot 5 - 6 = 9</tex>. Что невозможно.
}}
{{Теорема
|about=
Непланарность <tex>K_{3,3}</tex>
|statement=
Граф <tex>K_{3,3}</tex> непланарен.
|proof=
Граф <tex>K_{3,3}</tex> содержит <tex>V = 6</tex>, <tex>E = 9</tex> и <tex>F</tex> [[Укладка графа на плоскости|граней]]. 
Пусть граф <tex>K_{3,3}</tex> планарен. Тогда по [[Формула Эйлера|формуле Эйлера]] <tex>F = E - V + 2 = 9 - 6 + 2 = 5</tex>. Пусть, двигаясь вдоль <tex>i</tex>-й грани мы пройдем <tex>l_i</tex> ребер. Очевидно, что <tex>\sum_{i=1}^{F}l_i = 2E</tex>. Поскольку граф двудольный, все его циклы имеют четную длину. Значит <tex>l_i \geqslant 4</tex>. Получаем <tex>4F \leqslant 2E</tex>, то есть <tex>2F \leqslant E</tex>. То есть <tex>2\cdot5 = 10 \leqslant 9</tex>, что невозможно.
}}

==См. также==
* [[wikipedia:ru:Планарный граф | Википедия {{---}} Планарный граф]]
* [[wikipedia:ru:Домики и колодцы | Википедия {{---}} Домики и колодцы]]

==Источники информации==
* Асанов М. О., Баранский В. А., Расин В. В. {{---}} Дискретная математика: Графы, матроиды, алгоритмы: Учебное пособие. 2-е изд., испр. и доп. {{---}} СПб.: Издательство "Лань", 2010. {{---}} C. 134 {{---}} (Учебники для вузов. Специальная литература). ISBN 978-5-8114-1068-2

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Укладки графов ]]

Непланарность K5 и K3,3

2017-01-03T13:57:45Z

Nikitaevg:

{{Теорема
|about=
Непланарность <tex>K_5</tex>
|statement=
Граф <tex>K_5</tex> [[Укладка графа на плоскости|непланарен]].
|proof=
Граф <tex>K_5</tex> имеет <tex>5</tex> вершин и <tex>10</tex> ребер. Если он планарен, то по [[Формула Эйлера#EulerFormulaCons|следствию из формулы Эйлера]] получаем <tex>10 \leqslant 3 \cdot 5 - 6 = 9</tex>. Что невозможно.
}}
{{Теорема
|about=
Непланарность <tex>K_{3,3}</tex>
|statement=
Граф <tex>K_{3,3}</tex> непланарен.
|proof=
Граф <tex>K_{3,3}</tex> содержит <tex>V = 6</tex>, <tex>E = 9</tex> и <tex>F</tex> [[Укладка графа на плоскости|граней]]. 
Пусть граф <tex>K_{3,3}</tex> планарен. Тогда по [[Формула Эйлера|формуле Эйлера]] <tex>F = E - V + 2 = 9 - 6 + 2 = 5</tex>. Пусть, двигаясь вдоль <tex>i</tex>-й грани мы пройдем <tex>l_i</tex> ребер. Очевидно, что <tex>\sum_{i=1}^{F}l_i = 2E</tex>. Поскольку граф двудольный, все его циклы имеют четную длину. Значит <tex>l_i \geqslant 4</tex>. Получаем <tex>4F \leqslant 2E</tex>, то есть <tex>2F \leqslant E</tex>. То есть <tex>2\cdot5 = 10 \leqslant 9</tex>, что невозможно.
}}

==Источники информации==
* Асанов М. О., Баранский В. А., Расин В. В. {{---}} Дискретная математика: Графы, матроиды, алгоритмы: Учебное пособие. 2-е изд., испр. и доп. {{---}} СПб.: Издательство "Лань", 2010. {{---}} C. 134 {{---}} (Учебники для вузов. Специальная литература). ISBN 978-5-8114-1068-2
* [[wikipedia:ru:Планарный граф | Википедия {{---}} Планарный граф]]
* [[wikipedia:ru:Домики и колодцы | Википедия {{---}} Домики и колодцы]]

[[Категория: Алгоритмы и структуры данных]]
[[Категория: Укладки графов ]]

Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями

2017-01-02T18:27:43Z

Nikitaevg: Доказательство второй леммы

==Определения==
{{Определение
|definition=
Пусть <tex>N = (V,E,s,t,c)</tex> {{---}} [[Определение сети, потока|сеть]] с целочисленными пропускными способностями.

Обозначим <tex>C = \max\limits_{uv \in E} c_{uv}</tex> и <tex>F</tex> как максимальный поток.

<tex>c^{+}(v) = \sum\limits_{uv \in E} c_{uv}</tex>.

<tex>c^{-}(v) = \sum\limits_{vu \in E} c_{vu}</tex>.

<tex>p(v) = min\big\{c^{+}(v), c^{-}(v)\big\}</tex> {{---}} потенциал вершины <tex>v</tex>.

Тогда общий потенциал выражается формулой:
<tex>P = \sum\limits_{v \in V, v \neq s,t}p(v)</tex>.

[[Дополняющая сеть, дополняющий путь|Остаточную сеть]] обозначим <tex>G_f</tex>.
Обозначим длину [[Схема алгоритма Диница|слоистой сети]] <tex>l</tex> {{---}} как длину кратчайшего <tex>s-t</tex> пути в <tex>G_f</tex>.
}}

==Теоремы==
{{Лемма
|about = 1
|statement=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex> в исходной сети, максимальный поток в этой сети равен <tex>F</tex>.

Тогда <tex>l \leqslant \frac{P}{F} + 1</tex>

|proof=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex>, а <tex>V_i</tex> {{---}} набор вершин, удаленных от <tex>s</tex> на <tex>i</tex> <tex>(i \leqslant l)</tex>.
<tex>V_i</tex> {{---}} разъединяющее множество узлов: при его удалении исчезают все пути из <tex>s</tex> в <tex>t</tex>.
Следуя закону [[Определение сети, потока|сохранения потока]], если <tex>f</tex> обозначить как любой допустимый поток, то <tex>|f|</tex> единиц потока должно проходить через <tex>V_i</tex>.
Но суммарное количество потока, которое может проходить через любую вершину не превосходит ее потенциала.
Отсюда, если обозначить <tex>P_i</tex> как общий потенциал вершин из <tex>V_i</tex>, то мы имеем:

<tex>|f| \leqslant P_i</tex>

для любого допустимого потока <tex>f</tex>. В частности, <tex>F \leqslant P_i</tex>, таким образом получаем:

<tex>(l - 1)F \leqslant \displaystyle \sum_{i = 1}^{l - 1} P_i \leqslant P</tex>

и лемма доказана.
}}

{{Лемма
|about = 2
|statement=
Пусть <tex> N </tex> {{---}} сеть, а <tex>f</tex> {{---}} допустимый поток в этой сети. Тогда общий потенциал в остаточной сети <tex>G_f</tex> равен общему потенциалу <tex>N</tex>.
|proof=
По [[Теорема_о_декомпозиции | теореме о декомпозиции]] поток можно разбить на множество простых путей из <tex>s</tex> в <tex>t</tex> и циклов. Рассмотрим каждый путь (цикл) и убедимся, что, пуская по нему поток <tex>f_i</tex>, потенциал вершины не изменится. Действительно, рассмотрим вершину v, поток <tex>f_i</tex> в нее течет по ребру <tex>uv</tex>, а из нее по ребру <tex>vw</tex>. Пусть <tex>c_{f_i}</tex> {{---}} функция пропускных способностей в остаточной сети после пропускания потока по <tex>i</tex>-ому пути (циклу). Рассмотрим <tex>c^+_{f_1}(v) = c_{f_1}(uv) + c_{f_1}(wv)</tex>. <tex>c_{f_1}(uv) = c(uv) - f_i</tex>, а <tex>c_{f_1}(wv) = c(wv) + f_i</tex>, сложив эти два значения, получим, что <tex>c^+(v)</tex> остается неизменной. Применив такое же рассуждение для <tex>c^-(v)</tex>, получим, что потенциал каждой вершины остается неизменным.
}}
{{Теорема
|id=th1.
|about=Первая теорема Карзанова
|statement=Число итераций [[Схема алгоритма Диница|алгоритма Диница]] в сети <tex>N</tex> (<tex>s</tex> — исток, <tex>t</tex> — сток) с целочисленными пропускными способностями — <tex>O(\sqrt{P})</tex>.
|proof=
Пусть <tex>F</tex> {{---}} максимальный поток в сети <tex>N</tex>. Теорема верна для <tex>F \leqslant \sqrt{P}</tex>, так как после каждой фазы поток увеличивается хотя бы на 1. Если <tex>F > \sqrt{P}</tex>, рассмотрим последнюю фазу, на момент начала выполнения которой поток в сети был меньше, чем <tex>F - \sqrt{P}</tex>. После этого потребуется не больше <tex>\sqrt{P}</tex> фаз, чтобы найти максимальный поток. На предыдущей фазе поток (<tex>f</tex>) в <tex>N</tex> был не больше <tex>F-\sqrt{P}</tex>, таким образом <tex>F-|f| \geqslant \sqrt{P}</tex>.

<tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F-|f|</tex> и потенциалом <tex>P</tex> (по Лемме(2)). Поэтому можно воспользоваться Леммой(1), чтобы оценить расстояние между <tex>s</tex> и <tex>t</tex> в <tex>G_f</tex>, и получить оценку длины <tex>l</tex> слоистой сети:

<tex>l \leqslant \frac{P}{F-|f|} + 1</tex>

Так как каждая фаза увеличивает длину слоистой сети минимум на один, то осуществляется не больше <tex>\sqrt{P}</tex> фаз. Таким образом происходит не более <tex>2\sqrt{P}</tex> фаз.
}}

{{Лемма
|about = 3
|statement=
Пусть в сети <tex>N</tex> нет [[Основные определения теории графов#def1|параллельных ребер]]. Пусть <tex>F</tex> {{---}} максимальный поток в <tex>N</tex>. Тогда расстояние <tex>l</tex> между <tex>s</tex> и <tex>t</tex> в <tex>N</tex> таково: <tex>l \leqslant |V|\sqrt{\frac{2C}{F}} - 1</tex>.
|proof=
Обозначим <tex>V_i</tex> как набор вершин на расстоянии <tex>i</tex> от <tex>s</tex>. Множества <tex>X = \bigcup_{i = 0}^k V_i</tex> и <tex>Y = V - X</tex> определяют разрез <tex>(X, Y)</tex>. Пропускная способность этого разреза не больше <tex>2C|V_k||V_{k + 1}|</tex>, так как все ребра между <tex>X</tex> и <tex>Y</tex> также являются ребрами между <tex>V_k</tex> и <tex>V_{k+1}</tex> и не более чем двумя параллельными ребрами, исходящими из какой-то вершины в остаточной сети. По теореме о максимальном потоке/минимальном разрезе, <tex>F \leqslant 2C|V_k||V_{k+1}|</tex>.
Таким образом <tex>F</tex> ограничен наименьшим из <tex>|V_k||V_{k+1}|</tex>. Но эта величина максимальна, когда <tex>|V_i| = |V|/(l+1)</tex> для <tex>0 \leqslant i \leqslant n</tex>, таким образом <tex>F \leqslant 2C|V|^2 / (l+1)^2</tex>. Выражая <tex>l</tex>, получаем нужное.
}}

{{Теорема
|id=th2
|about=Вторая теорема Карзанова
|statement=Число итераций алгоритма Диница с целочисленными пропускными способностями {{---}} <tex>O(C^{1/3}|V|^{2/3})</tex>.
|proof=
Если <tex>F \leqslant C^{1/3}|V|^{2/3}</tex>, то теорема очевидна.
Положим, что <tex>F > C^{1/3}|V|^{2/3}</tex>, и рассотрим последнюю фазу, в которой поток <tex>f</tex> не превышает <tex>F - C^{1/3}|V|^{2/3}</tex>. В этот момент осталось не более <tex>C^{1/3}|V|^{2/3} + 1</tex> фаз, и <tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F - |f| \ge C^{1/3}|V|^{2/3}</tex>. Мы можем применить Лемму(3), чтобы оценить длину <tex>l</tex> слоистой сети, и, соответственно, количество выполненных фаз:

<tex>l \leqslant |V|{(\frac{2C}{F-|f|})}^{1/2} - 1 \leqslant 2^{1/2}C^{1/3}|V|^{2/3} - 1</tex>.

Таким образом, прошло <tex>O(C^{1/3}|V|^{2/3})</tex> фаз, и <tex>O(C^{1/3}|V|^{2/3})</tex> фаз осталось. Теорема доказана.
}}

== Литература ==
* [http://www.springerlink.com/content/w0q006u3631gg124/fulltext.pdf On the efficiency of Maximum-Flow Algorithms on Networks with Small Integer Capacities. David Fernandez-Baca and Charles U.Martel]
* [https://www.youtube.com/watch?v=sEwp5ZAJJps&feature=youtu.be&t=26m41s Андрей Станкевич: Лекториум, дополнительные главы алгоритмов, лекция 12]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о максимальном потоке]]

Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями

2016-12-31T08:00:11Z

Nikitaevg:

==Определения==
{{Определение
|definition=
Пусть <tex>N = (V,E,s,t,c)</tex> {{---}} [[Определение сети, потока|сеть]] с целочисленными пропускными способностями.

Обозначим <tex>C = \max\limits_{uv \in E} c_{uv}</tex> и <tex>F</tex> как максимальный поток.

<tex>c^{+}(v) = \sum\limits_{uv \in E} c_{uv}</tex>.

<tex>c^{-}(v) = \sum\limits_{vu \in E} c_{vu}</tex>.

<tex>p(v) = min\big\{c^{+}(v), c^{-}(v)\big\}</tex> {{---}} потенциал вершины <tex>v</tex>.

Тогда общий потенциал выражается формулой:
<tex>P = \sum\limits_{v \in V, v \neq s,t}p(v)</tex>.

[[Дополняющая сеть, дополняющий путь|Остаточную сеть]] обозначим <tex>G_f</tex>.
Обозначим длину [[Схема алгоритма Диница|слоистой сети]] <tex>l</tex> {{---}} как длину кратчайшего <tex>s-t</tex> пути в <tex>G_f</tex>.
}}

==Теоремы==
{{Лемма
|about = 1
|statement=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex> в исходной сети, максимальный поток в этой сети равен <tex>F</tex>.

Тогда <tex>l \leqslant \frac{P}{F} + 1</tex>

|proof=
Пусть <tex>l</tex> {{---}} расстояние между <tex>s</tex> и <tex>t</tex>, а <tex>V_i</tex> {{---}} набор вершин, удаленных от <tex>s</tex> на <tex>i</tex> <tex>(i \leqslant l)</tex>.
<tex>V_i</tex> {{---}} разъединяющее множество узлов: при его удалении исчезают все пути из <tex>s</tex> в <tex>t</tex>.
Следуя закону [[Определение сети, потока|сохранения потока]], если <tex>f</tex> обозначить как любой допустимый поток, то <tex>|f|</tex> единиц потока должно проходить через <tex>V_i</tex>.
Но суммарное количество потока, которое может проходить через любую вершину не превосходит ее потенциала.
Отсюда, если обозначить <tex>P_i</tex> как общий потенциал вершин из <tex>V_i</tex>, то мы имеем:

<tex>|f| \leqslant P_i</tex>

для любого допустимого потока <tex>f</tex>. В частности, <tex>F \leqslant P_i</tex>, таким образом получаем:

<tex>(l - 1)F \leqslant \displaystyle \sum_{i = 1}^{l - 1} P_i \leqslant P</tex>

и лемма доказана.
}}

{{Лемма
|about = 2
|statement=
Пусть <tex> N </tex> {{---}} сеть, а <tex>f</tex> {{---}} допустимый поток в этой сети. Тогда общий потенциал в остаточной сети <tex>G_f</tex> равен общему потенциалу <tex>N</tex>.
|proof=
Пусть <tex>c_f</tex> {{---}} функция пропускных способностей в <tex>G_f</tex>, а <tex>p_f(v), in_f(v), out_f(v)</tex> {{---}} потенциал, множество входящих ребер и множество выходящих ребер вершины <tex>v</tex> из <tex>G_f</tex>.

Достаточно доказать, что <tex>p_f(v) = p(v)</tex>. Ребру <tex>e</tex> из <tex>in(v)</tex> соответствуют ребро <tex>e_1</tex> из <tex>in_f(v)</tex> с пропускной способностью <tex>c(e) - f(e)</tex>, и ребро <tex>e_2</tex> из <tex>out(v)</tex> с пропускной способностью <tex>f(e)</tex>. Аналогично, ребру <tex>e</tex> из <tex>out(v)</tex> соответствуют ребра из <tex>out_f(v)</tex> с пропускной способностью <tex>c(v) - f (v)</tex> и <tex>in_f(v)</tex> с пропускной способностью <tex>f(e)</tex>. Используя закон сохранения потока, нетрудно проверить, что

<tex>\displaystyle\sum_{e\in in_f(v)} c_f(e) = \sum_{e\in in(v)}c(e)</tex>

и

<tex>\displaystyle\sum_{e\in out_f(v)} c_f(e) = \sum_{e\in out(v)}c(e)</tex>

что и требовалось доказать.
}}
{{Теорема
|id=th1.
|about=Первая теорема Карзанова
|statement=Число итераций [[Схема алгоритма Диница|алгоритма Диница]] в сети <tex>N</tex> (<tex>s</tex> — исток, <tex>t</tex> — сток) с целочисленными пропускными способностями — <tex>O(\sqrt{P})</tex>.
|proof=
Пусть <tex>F</tex> {{---}} максимальный поток в сети <tex>N</tex>. Теорема верна для <tex>F \leqslant \sqrt{P}</tex>, так как после каждой фазы поток увеличивается хотя бы на 1. Если <tex>F > \sqrt{P}</tex>, рассмотрим последнюю фазу, на момент начала выполнения которой поток в сети был меньше, чем <tex>F - \sqrt{P}</tex>. После этого потребуется не больше <tex>\sqrt{P}</tex> фаз, чтобы найти максимальный поток. На предыдущей фазе поток (<tex>f</tex>) в <tex>N</tex> был не больше <tex>F-\sqrt{P}</tex>, таким образом <tex>F-|f| \geqslant \sqrt{P}</tex>.

<tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F-|f|</tex> и потенциалом <tex>P</tex> (по Лемме(2)). Поэтому можно воспользоваться Леммой(1), чтобы оценить расстояние между <tex>s</tex> и <tex>t</tex> в <tex>G_f</tex>, и получить оценку длины <tex>l</tex> слоистой сети:

<tex>l \leqslant \frac{P}{F-|f|} + 1</tex>

Так как каждая фаза увеличивает длину слоистой сети минимум на один, то осуществляется не больше <tex>\sqrt{P}</tex> фаз. Таким образом происходит не более <tex>2\sqrt{P}</tex> фаз.
}}

{{Лемма
|about = 3
|statement=
Пусть в сети <tex>N</tex> нет [[Основные определения теории графов#def1|параллельных ребер]]. Пусть <tex>F</tex> {{---}} максимальный поток в <tex>N</tex>. Тогда расстояние <tex>l</tex> между <tex>s</tex> и <tex>t</tex> в <tex>N</tex> таково: <tex>l \leqslant |V|\sqrt{\frac{2C}{F}} - 1</tex>.
|proof=
Обозначим <tex>V_i</tex> как набор вершин на расстоянии <tex>i</tex> от <tex>s</tex>. Множества <tex>X = \bigcup_{i = 0}^k V_i</tex> и <tex>Y = V - X</tex> определяют разрез <tex>(X, Y)</tex>. Пропускная способность этого разреза не больше <tex>2C|V_k||V_{k + 1}|</tex>, так как все ребра между <tex>X</tex> и <tex>Y</tex> также являются ребрами между <tex>V_k</tex> и <tex>V_{k+1}</tex> и не более чем двумя параллельными ребрами, исходящими из какой-то вершины в остаточной сети. По теореме о максимальном потоке/минимальном разрезе, <tex>F \leqslant 2C|V_k||V_{k+1}|</tex>.
Таким образом <tex>F</tex> ограничен наименьшим из <tex>|V_k||V_{k+1}|</tex>. Но эта величина максимальна, когда <tex>|V_i| = |V|/(l+1)</tex> для <tex>0 \leqslant i \leqslant n</tex>, таким образом <tex>F \leqslant 2C|V|^2 / (l+1)^2</tex>. Выражая <tex>l</tex>, получаем нужное.
}}

{{Теорема
|id=th2
|about=Вторая теорема Карзанова
|statement=Число итераций алгоритма Диница с целочисленными пропускными способностями {{---}} <tex>O(C^{1/3}|V|^{2/3})</tex>.
|proof=
Если <tex>F \leqslant C^{1/3}|V|^{2/3}</tex>, то теорема очевидна.
Положим, что <tex>F > C^{1/3}|V|^{2/3}</tex>, и рассотрим последнюю фазу, в которой поток <tex>f</tex> не превышает <tex>F - C^{1/3}|V|^{2/3}</tex>. В этот момент осталось не более <tex>C^{1/3}|V|^{2/3} + 1</tex> фаз, и <tex>G_f</tex> {{---}} сеть с максимальным потоком <tex>F - |f| \ge C^{1/3}|V|^{2/3}</tex>. Мы можем применить Лемму(3), чтобы оценить длину <tex>l</tex> слоистой сети, и, соответственно, количество выполненных фаз:

<tex>l \leqslant |V|{(\frac{2C}{F-|f|})}^{1/2} - 1 \leqslant 2^{1/2}C^{1/3}|V|^{2/3} - 1</tex>.

Таким образом, прошло <tex>O(C^{1/3}|V|^{2/3})</tex> фаз, и <tex>O(C^{1/3}|V|^{2/3})</tex> фаз осталось. Теорема доказана.
}}

== Литература ==
* [http://www.springerlink.com/content/w0q006u3631gg124/fulltext.pdf On the efficiency of Maximum-Flow Algorithms on Networks with Small Integer Capacities. David Fernandez-Baca and Charles U.Martel]
* [https://www.youtube.com/watch?v=sEwp5ZAJJps&feature=youtu.be&t=26m41s Андрей Станкевич: Лекториум, дополнительные главы алгоритмов, лекция 12]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о максимальном потоке]]

Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями

2016-12-28T08:09:49Z

Nikitaevg: /* Теоремы */ Опечатка в доказательстве

==Определения==
{{Определение
|definition=
Пусть <tex>N = (V,E,s,t,c)</tex> - [[Определение сети, потока|сеть]] с целочисленными пропускными способностями.

Обозначим <tex>C</tex> и <tex>F</tex>, как максимальная пропускная способность ребра и максимальный поток соответственно.

<tex>c^{+}(v) = \sum\limits_{uv \in E} c_{uv}</tex>.

<tex>c^{-}(v) = \sum\limits_{vu \in E} c_{vu}</tex>.

<tex>p(v) = min\big\{c^{+}(v), c^{-}(v)\big\}</tex> - потенциал вершины <tex>v</tex>.

Тогда общий потенциал выражается формулой:
<tex>P = \sum\limits_{v \in V, v \neq s,t}p(v)</tex>.

[[Дополняющая сеть, дополняющий путь|Остаточную сеть]] обозначим <tex>N(f)</tex>.
Обозначим длину [[Схема алгоритма Диница|слоистой сети]] <tex>l</tex> - как длину кратчайшего <tex>s-t</tex> пути в <tex>N(f)</tex>.
}}

==Теоремы==
{{Лемма
|about = 1
|statement=
Пусть <tex>l</tex> - расстояние между <tex>s</tex> и <tex>t</tex> в сети с текущим потоком, равным 0, и максимальным потоком, равным <tex>F</tex>.

Тогда <tex>l \leq \frac{P}{F} + 1</tex>

|proof=
Пусть <tex>l</tex> - расстояние между <tex>s</tex> и <tex>t</tex>, а <tex>V_i</tex> - набор вершин, удаленных от <tex>s</tex> на <tex>i</tex> <tex>(i \leq l)</tex>.
<tex>V_i</tex> - разъединяющее множество узлов: при его удалении исчезают все пути из <tex>s</tex> в <tex>t</tex>.
Следуя закону [[Определение сети, потока|сохранения потока]], если <tex>f</tex> обозначить как любой допустимый поток, то <tex>|f|</tex> единиц потока должно проходить через <tex>V_i</tex>.
Но суммарное количество потока, которое может проходить через любую вершину не превосходит ее потенциала.
Отсюда, если обозначить <tex>P_i</tex> как общий потенциал вершин из <tex>V_i</tex>, то мы имеем:

<tex>|f| \leq P_i</tex>

для любого допустимого потока <tex>f</tex>. В частности, <tex>F \leq P_i</tex>, таким образом получаем:

<tex>(l - 1)F \leq \displaystyle \sum_{i = 1}^{l - 1} P_i \leq P</tex>

и лемма доказана.
}}

{{Лемма
|about = 2
|statement=
Пусть <tex> N </tex> - сеть, а <tex>f</tex> - допустимый поток в этой сети. Тогда общий потенциал в остаточной сети <tex>N(f)</tex> равен общему потенциалу <tex>N</tex>.
|proof=
Пусть <tex>c_f</tex> - функция пропускных способностей в <tex>N(f)</tex>, а <tex>p_f(v), in_f(v), out_f(v)</tex> - потенциал, множество входящих ребер и множество выходящих ребер вершины <tex>v</tex> из <tex>N(f)</tex>.

Достаточно доказать, что <tex>p_f(v) = p(v)</tex>. Ребру <tex>e</tex> из <tex>in(v)</tex> соответствуют ребро <tex>e_1</tex> из <tex>in_f(v)</tex> с пропускной способностью <tex>c(e) - f(e)</tex>, и ребро <tex>e_2</tex> из <tex>out(v)</tex> с пропускной способностью <tex>f(e)</tex>. Аналогично, ребру <tex>e</tex> из <tex>out(v)</tex> соответствуют ребра из <tex>out_f(v)</tex> с пропускной способностью <tex>c(v) - f (v)</tex> и <tex>in_f(v)</tex> с пропускной способностью <tex>f(e)</tex>. Используя закон сохранения потока, нетрудно проверить, что

<tex>\displaystyle\sum_{e\in in_f(v)} c_f(e) = \sum_{e\in in(v)}c(e)</tex>

и

<tex>\displaystyle\sum_{e\in out_f(v)} c_f(e) = \sum_{e\in out(v)}c(e)</tex>

что и требовалось доказать.
}}
{{Теорема
|id=th1.
|about=Первая теорема Карзанова
|statement=Число итераций [[Схема алгоритма Диница|алгоритма Диница]] в сети <tex>N</tex> (<tex>s</tex> — исток, <tex>t</tex> — сток) с целочисленными пропускными способностями — <tex>O(\sqrt{P})</tex>.
|proof=
Пусть <tex>F</tex> - максимальный поток в сети <tex>N</tex>. Теорема верна для <tex>F \leq \sqrt{P}</tex>, так как после каждой фазы поток увеличивается хотя бы на 1. Если <tex>F > \sqrt{P}</tex>, рассмотрим последнюю фазу, на момент начала выполнения которой поток в сети был меньше, чем <tex>F - \sqrt{P}</tex>. После этого потребуется не больше <tex>\sqrt{P}</tex> фаз, чтобы найти максимальный поток. На предыдущей фазе поток (<tex>f</tex>) в <tex>N</tex> был не больше <tex>F-\sqrt{P}</tex>, таким образом <tex>F-|f| \geqslant \sqrt{P}</tex>.

<tex>N(f)</tex> - сеть с максимальным потоком <tex>F-|f|</tex> и потенциалом <tex>P</tex> (по Лемме(2)). Поэтому можно воспользоваться Леммой(1), чтобы оценить расстояние между <tex>s</tex> и <tex>t</tex> в <tex>N(f)</tex>, и получить оценку длины <tex>l</tex> слоистой сети:

<tex>l \leq \frac{P}{F-|f|} + 1</tex>

Так как каждая фаза увеличивает длину слоистой сети минимум на один, то осуществляется не больше <tex>\sqrt{P}</tex> фаз. Таким образом происходит не более <tex>2\sqrt{P}</tex> фаз.
}}

{{Лемма
|about = 3
|statement=
Пусть в сети <tex>N</tex> нет [[Основные определения теории графов#def1|параллельных ребер]]. <tex>f</tex> - поток в <tex>N</tex>, а <tex>F</tex> - максимальный поток в <tex>N(f)</tex>. Тогда расстояние <tex>l</tex> между <tex>s</tex> и <tex>t</tex> в <tex>N(f)</tex> таково: <tex>l \leq |V|\sqrt{\frac{2C}{F}} - 1</tex>.
|proof=
Обозначим <tex>V_i</tex> как набор вершин на расстоянии <tex>i</tex> от <tex>s</tex>. Множества <tex>X = \bigcup_{i = 0}^k V_i</tex> и <tex>Y = V - X</tex> определяют разрез <tex>(X, Y)</tex>. Пропускная способность этого разреза не больше <tex>2C|V_k||V_{k + 1}|</tex>, так как все ребра между <tex>X</tex> и <tex>Y</tex> также являются ребрами между <tex>V_k</tex> и <tex>V_{k+1}</tex> и не более чем двумя параллельными ребрами, исходящими из какой-то вершины в остаточной сети. По теореме о максимальном потоке/минимальном разрезе, <tex>F \leq 2C|V_k||V_{k+1}|</tex>.
Таким образом <tex>F</tex> ограничен наименьшим из <tex>|V_k||V_{k+1}|</tex>. Но эта величина максимальна, когда <tex>|V_i| = |V|/(l+1)</tex> для <tex>0 \leq i \leq n</tex>, таким образом <tex>F \leq 2C|V|^2 / (l+1)^2</tex>. Выражая <tex>l</tex>, получаем нужное.
}}

{{Теорема
|id=th2
|about=Вторая теорема Карзанова
|statement=Число итераций алгоритма Диница с целочисленными пропускными способностями - <tex>O(C^{1/3}|V|^{2/3})</tex>.
|proof=
Если <tex>F \leq C^{1/3}|V|^{2/3}</tex>, то теорема очевидна.
Положим, что <tex>F > C^{1/3}|V|^{2/3}</tex>, и рассотрим последнюю фазу, в которой поток <tex>f</tex> не превышает <tex>F - C^{1/3}|V|^{2/3}</tex>. В этот момент осталось не более <tex>C^{1/3}|V|^{2/3} + 1</tex> фаз, и <tex>N(f)</tex> - сеть с максимальным потоком <tex>F - |f| \ge C^{1/3}|V|^{2/3}</tex>. Мы можем применить Лемму(2), чтобы оценить длину <tex>l</tex> слоистой сети, и, соответственно, количество выполненных фаз:

<tex>l \leq |V|{(\frac{2C}{F-|f|})}^{1/2} - 1 </tex>

<tex>\leq 2^{1/2}C^{1/3}|V|^{2/3} - 1</tex>.

Таким образом, прошло <tex>O(C^{1/3}|V|^{2/3})</tex> фаз, и <tex>O(C^{1/3}|V|^{2/3})</tex> фаз осталось. Теорема доказана.
}}

== Литература ==
* [http://www.springerlink.com/content/w0q006u3631gg124/fulltext.pdf On the efficiency of Maximum-Flow Algorithms on Networks with Small Integer Capacities. David Fernandez-Baca and Charles U.Martel]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о максимальном потоке]]

Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями

2016-12-25T10:39:00Z

Nikitaevg: /* Теоремы */ Опечатка в доказательстве

==Определения==
{{Определение
|definition=
Пусть <tex>N = (V,E,s,t,c)</tex> - [[Определение сети, потока|сеть]] с целочисленными пропускными способностями.

Обозначим <tex>C</tex> и <tex>F</tex>, как максимальная пропускная способность ребра и максимальный поток соответственно.

<tex>c^{+}(v) = \sum\limits_{uv \in E} c_{uv}</tex>.

<tex>c^{-}(v) = \sum\limits_{vu \in E} c_{vu}</tex>.

<tex>p(v) = min\big\{c^{+}(v), c^{-}(v)\big\}</tex> - потенциал вершины <tex>v</tex>.

Тогда общий потенциал выражается формулой:
<tex>P = \sum\limits_{v \in V, v \neq s,t}p(v)</tex>.

[[Дополняющая сеть, дополняющий путь|Остаточную сеть]] обозначим <tex>N(f)</tex>.
Обозначим длину [[Схема алгоритма Диница|слоистой сети]] <tex>l</tex> - как длину кратчайшего <tex>s-t</tex> пути в <tex>N(f)</tex>.
}}

==Теоремы==
{{Лемма
|about = 1
|statement=
Пусть <tex>l</tex> - расстояние между <tex>s</tex> и <tex>t</tex> в сети с текущим потоком, равным 0, и максимальным потоком, равным <tex>F</tex>.

Тогда <tex>l \leq \frac{P}{F} + 1</tex>

|proof=
Пусть <tex>l</tex> - расстояние между <tex>s</tex> и <tex>t</tex>, а <tex>V_i</tex> - набор вершин, удаленных от <tex>s</tex> на <tex>i</tex> <tex>(i \leq l)</tex>.
<tex>V_i</tex> - разъединяющее множество узлов: при его удалении исчезают все пути из <tex>s</tex> в <tex>t</tex>.
Следуя закону [[Определение сети, потока|сохранения потока]], если <tex>f</tex> обозначить как любой допустимый поток, то <tex>|f|</tex> единиц потока должно проходить через <tex>V_i</tex>.
Но суммарное количество потока, которое может проходить через любую вершину не превосходит ее потенциала.
Отсюда, если обозначить <tex>P_i</tex> как общий потенциал вершин из <tex>V_i</tex>, то мы имеем:

<tex>|f| \leq P_i</tex>

для любого допустимого потока <tex>f</tex>. В частности, <tex>F \leq P_i</tex>, таким образом получаем:

<tex>(l - 1)F \leq \displaystyle \sum_{i = 1}^{l - 1} P_i \leq P</tex>

и лемма доказана.
}}

{{Лемма
|about = 2
|statement=
Пусть <tex> N </tex> - сеть, а <tex>f</tex> - допустимый поток в этой сети. Тогда общий потенциал в остаточной сети <tex>N(f)</tex> равен общему потенциалу <tex>N</tex>.
|proof=
Пусть <tex>c_f</tex> - функция пропускных способностей в <tex>N(f)</tex>, а <tex>p_f(v), in_f(v), out_f(v)</tex> - потенциал, множество входящих ребер и множество выходящих ребер вершины <tex>v</tex> из <tex>N(f)</tex>.

Достаточно доказать, что <tex>p_f(v) = p(v)</tex>. Ребру <tex>e</tex> из <tex>in(v)</tex> соответствуют ребро <tex>e_1</tex> из <tex>in_f(v)</tex> с пропускной способностью <tex>c(e) - f(e)</tex>, и ребро <tex>e_2</tex> из <tex>out(v)</tex> с пропускной способностью <tex>f(e)</tex>. Аналогично, ребру <tex>e</tex> из <tex>out(v)</tex> соответствуют ребра из <tex>out_f(v)</tex> с пропускной способностью <tex>c(v) - f (v)</tex> и <tex>in_f(v)</tex> с пропускной способностью <tex>f(e)</tex>. Используя закон сохранения потока, нетрудно проверить, что

<tex>\displaystyle\sum_{e\in in_f(v)} c_f(e) = \sum_{e\in in(v)}c(e)</tex>

и

<tex>\displaystyle\sum_{e\in out_f(v)} c_f(e) = \sum_{e\in out(v)}c(e)</tex>

что и требовалось доказать.
}}
{{Теорема
|id=th1.
|about=Первая теорема Карзанова
|statement=Число итераций [[Схема алгоритма Диница|алгоритма Диница]] в сети <tex>N</tex> (<tex>s</tex> — исток, <tex>t</tex> — сток) с целочисленными пропускными способностями — <tex>O(\sqrt{P})</tex>.
|proof=
Пусть <tex>F</tex> - максимальный поток в сети <tex>N</tex>. Теорема верна для <tex>F \leq \sqrt{P}</tex>, так как после каждой фазы поток увеличивается хотя бы на 1. Если <tex>F > \sqrt{P}</tex>, рассмотрим последнюю фазу, на момент начала выполнения которой поток в сети был меньше, чем <tex>F - \sqrt{P}</tex>. После этого потребуется не больше <tex>\sqrt{P}</tex> фаз, чтобы найти максимальный поток. На предыдущей фазе поток (<tex>f</tex>) в <tex>N</tex> был не больше <tex>F-\sqrt{P}</tex>, таким образом <tex>F-|f| \geqslant \sqrt{P}</tex>.

<tex>N(f)</tex> - сеть с максимальным потоком <tex>F-|f|</tex> и потенциалом <tex>P</tex> (по Лемме(2)). Поэтому можно воспользоваться Леммой(1), чтобы оценить расстояние между <tex>s</tex> и <tex>t</tex> в <tex>N(f)</tex>, и получить оценку длины <tex>l</tex> слоистой сети:

<tex>l \leq \frac{P}{F-|f|} + 1</tex>

Так как каждая фаза увеличивает длину слоистой сети минимум на один, то осуществляется не больше <tex>\sqrt{P}</tex> фаз. Таким образом происходит не более <tex>2\sqrt{P}</tex> фаз.
}}

{{Лемма
|about = 3
|statement=
Пусть в сети <tex>N</tex> нет [[Основные определения теории графов#def1|параллельных ребер]]. <tex>f</tex> - поток в <tex>N</tex>, а <tex>F</tex> - максимальный поток в <tex>N(f)</tex>. Тогда расстояние <tex>l</tex> между <tex>s</tex> и <tex>t</tex> в <tex>N(f)</tex> таково: <tex>l \leq |V|\sqrt{\frac{2C}{F}} - 1</tex>.
|proof=
Обозначим <tex>V_i</tex> как набор вершин на расстоянии <tex>i</tex> от <tex>s</tex>. Множества <tex>X = \bigcup_{i = 0}^k V_i</tex> и <tex>Y = V - X</tex> определяют разрез <tex>(X, Y)</tex>. Пропускная способность этого разреза не больше <tex>2C|V_k||V_{k + 1}|</tex>, так как все ребра между <tex>X</tex> и <tex>Y</tex> также являются ребрами между <tex>V_k</tex> и <tex>V_{k+1}</tex> и не более чем двумя параллельными ребрами, исходящими из какой-то вершины в остаточной сети. По теореме о максимальном потоке/минимальном разрезе, <tex>F \leq 2C|V_k||V_{k+1}|</tex>.
Таким образом <tex>F</tex> ограничен наименьшим из <tex>|V_k||V_{k+1}|</tex>. Но эта величина максимальна, когда <tex>|V_i| = |V|/(l+1)</tex> для <tex>0 \leq i \leq n</tex>, таким образом <tex>F \leq 2C|V|^2(l+1)^2</tex>. Выражая <tex>l</tex>, получаем нужное.
}}

{{Теорема
|id=th2
|about=Вторая теорема Карзанова
|statement=Число итераций алгоритма Диница с целочисленными пропускными способностями - <tex>O(C^{1/3}|V|^{2/3})</tex>.
|proof=
Если <tex>F \leq C^{1/3}|V|^{2/3}</tex>, то теорема очевидна.
Положим, что <tex>F > C^{1/3}|V|^{2/3}</tex>, и рассотрим последнюю фазу, в которой поток <tex>f</tex> не превышает <tex>F - C^{1/3}|V|^{2/3}</tex>. В этот момент осталось не более <tex>C^{1/3}|V|^{2/3} + 1</tex> фаз, и <tex>N(f)</tex> - сеть с максимальным потоком <tex>F - |f| \ge C^{1/3}|V|^{2/3}</tex>. Мы можем применить Лемму(2), чтобы оценить длину <tex>l</tex> слоистой сети, и, соответственно, количество выполненных фаз:

<tex>l \leq |V|{(\frac{2C}{F-|f|})}^{1/2} - 1 </tex>

<tex>\leq 2^{1/2}C^{1/3}|V|^{2/3} - 1</tex>.

Таким образом, прошло <tex>O(C^{1/3}|V|^{2/3})</tex> фаз, и <tex>O(C^{1/3}|V|^{2/3})</tex> фаз осталось. Теорема доказана.
}}

== Литература ==
* [http://www.springerlink.com/content/w0q006u3631gg124/fulltext.pdf On the efficiency of Maximum-Flow Algorithms on Networks with Small Integer Capacities. David Fernandez-Baca and Charles U.Martel]

[[Категория:Алгоритмы и структуры данных]]
[[Категория:Задача о максимальном потоке]]

Динамический массив

2016-01-21T09:10:10Z

Nikitaevg: /* Стоимость операции del() */

{{Определение
| definition =
'''Массив''' {{---}} набор однотипных переменных, доступ к которым осуществляется по индексу. '''Динамический массив''' может изменять свой размер в зависимости от количества элементов в нём.
}}

== Операции ==
Определим операции, которые мы будем применять к динамическому массиву: 
=== get(i) ===
:Возвращает значение <tex>i</tex>-ой ячейки массива. Время выполнения {{---}} <tex>O(1)</tex>.
=== set(i,x) ===
:В <tex>i</tex>-ую ячейку массива записывается элемент <tex>x</tex>. Время выполнения {{---}} <tex>O(1)</tex>.
=== add(x) ===
:Добавление в массив элемента <tex>x</tex>. Время выполнения {{---}} <tex>O(1)</tex>; в худшем случае, при котором необходимо перенести все элементы из текущего массива в вдвое больший массив {{---}} <tex>O(n)</tex> (<tex>n</tex> {{---}} размер массива).
=== del() ===
:Удаляет последний элемент массива. В случае, если количество элементов в массиве в <tex>C</tex> раз меньше его длины, то происходит сжатие в <tex>B</tex> раз. (<tex>C,B</tex> {{---}} константы, зависящие от реализации). Время выполнения операции в худшем случае {{---}} <tex>O(n)</tex>.

=== size() ===
:Возвращает количество элементов массива. Время выполнения {{---}} <tex>O(1)</tex>.

== Амортизационная стоимость каждой операции ==
Пусть наш массив расширяется в <tex>2</tex> раза, и уменьшается в <tex>2</tex> раза, когда длина массива в <tex>4</tex> раза больше количества элементов в массиве. В этом случае амортизационная стоимость каждой операции будет <tex>O(1)</tex>.
=== Метод предоплаты ===
==== Стоимость операции add(x) ====
[[Файл:Безымянный1.png|400px|thumb|right|Иллюстрация]]
Пусть у нас единицей стоимости операции является одна монетка. Тогда при каждой операции '''add(x)''', при которой нам не требуется копирование, мы будем использовать три монетки. Из них одна пойдёт на стоимость самой этой операции, а две будут в резерве (пусть, если мы добавили <tex>i</tex>-ый элемент, мы будем класть по одной монетке к элементам с номерами <tex dpi=150>i</tex> и <tex dpi=150>i-\frac{n}{2}</tex>). В итоге, к тому моменту, как массив будет заполнен, рядом с каждым элементом будет лежать по одной монетке, которую мы и можем использовать на его копирование в новый массив. Таким образом, амортизационная стоимость каждой операции '''add(x)''' {{---}} <tex>3</tex>, и среднее время её работы {{---}} <tex>O(1)</tex>.
==== Стоимость операции del() ====
При каждой операции будем использовать две монетки. Одну из них потратим на само удаление элемента, другую на элемент, стоящий на позиции <tex>i \bmod \dfrac{n}{4}</tex>. Тогда даже в самом худшем случае (только что расширились, а потом <tex>\dfrac{n}{4}</tex> удалили) у каждого элемента из первых <tex>\dfrac{n}{4}</tex> будет по монете и на удаление надо будет потратить только <tex>1</tex> монету.

=== Метод потенциалов ===
За потенциал примем число:
<tex dpi=150>\Phi(c, s) = \begin{cases}
2s-c, & \text{if } s\geqslant\frac{1}{2}c \\
\frac{1}{2}c-s, & \text{if } s<\frac{1}{2}c
\end{cases}</tex>

где <tex>c</tex> {{---}} размер массива, <tex>s</tex> {{---}} число элементов массива.

==== Стоимость операции '''add(x)''' ====

* <tex dpi=150>\frac{s}{c} = 1</tex>, массив расширяется: <tex dpi=150> a_i = t_i + \Phi(2c, s + 1) - \Phi(c, s) = (s + 1) + (2(s+1)-2c)-(2s-c) = 3 </tex>

* <tex dpi=150>1>\frac{s}{c}\geqslant\frac{1}{2}</tex>, массив не расширяется: <tex dpi=150>a_i=t_i+\Phi(c,s+1)-\Phi(c,s)=1+(2(s+1)-c)-(2s-c)=3</tex>

* <tex dpi=150>\frac{s}{c}<\frac{1}{2}, \frac{s+1}{c}\geqslant\frac{1}{2}</tex>, массив не расширяется:
<tex dpi=150>a_i = t_i + \Phi(c, s+1)-\Phi(c, s)= 1 +(2(s+1)-c)-(\frac{1}{2}c - s)= 3+s-\frac{3}{2}c= 3 + \frac{s}{c}c-\frac{3}{2}c <3+\frac{3}{2}c-\frac{3}{2}c=3</tex>

* <tex dpi=150>\frac{s}{c}<\frac{1}{2}, \frac{s+1}{c}<\frac{1}{2}</tex>, массив не расширяется: <tex dpi=150>a_i = t_i + \Phi(c, s + 1) - \Phi(c, s) = 1 + (\frac{1}{2}c - (s + 1)) - (\frac{1}{2}c - s) = 0</tex>

В итоге, средняя стоимость операции {{---}} <tex>3</tex>, а среднее время работы {{---}} <tex>O(1)</tex>.

==== Стоимость операции del() ====

* <tex dpi=150>\frac{s}{c}=\frac{1}{4}</tex>, массив сужается: <tex dpi=150>a_i = t_i + \Phi(\frac{c}{2}, s - 1) - \Phi(c, s) = s + (\frac{1}{2}\cdot\frac{1}{2}c-(s-1)) - (\frac{1}{2}c-s) = 1-\frac{1}{4}c+s=1</tex>
* <tex dpi=150>\frac{1}{4}<\frac{s}{c}<\frac{1}{2}</tex>, массив не сужается: <tex dpi=150>a_i = t_i + \Phi(c, s - 1) - \Phi(c, s) = 1 + (\frac{1}{2}c-(s-1))-(\frac{1}{2}c-s)= 2</tex>
* <tex dpi=150>\frac{s}{c}\geqslant\frac{1}{2}, \frac{s-1}{c}<\frac{1}{2}\Rightarrow s=\frac{1}{2}c</tex>, массив не сужается: <tex dpi=150>a_i = t_i + \Phi(c, s - 1) - \Phi(c, s) =1 +(\frac{1}{2}c-(s-1))-(2s-c)=2+\frac{3}{2}c-3s = 2</tex>
* <tex dpi=150>\frac{s}{c}>\frac{1}{2}</tex>, массив не сужается: <tex dpi=150>a_i = t_i + \Phi(c, s - 1) - \Phi(c, s) = 1 + (2(s-1)-c)-(2s-c)=0</tex>

Средняя стоимость операции {{---}} <tex>2</tex>, а среднее время работы {{---}} <tex>O(1)</tex>.

==Динамические массивы в современных языках программирования==
Динамические массивы широко применяются во многих языках программирования. Рассмотрим, как эта структура данных реализуется в С++ и Java.
===С++ {{---}} vector===
В С++ динамический массив используется в структуре vector, она описана в STL(<vector>). Стратегия расширения проста: при попытке записи в массив нового элемента в момент полного заполнения памяти происходит увеличение размера в <tex>2</tex> раза при компиляции GNU C++ и в <tex>1.5</tex> раза при компиляции Microsoft Visual C++. При удалении элементов уменьшение размера массива никогда не происходит. При инициализации vector по-умолчанию начальный размер равен <tex>0</tex>.
===Java {{---}} ArrayList===
В Java структура ArrayList основана на динамическом массиве. При превышении максимального на данный момент размера происходит увеличение в <tex>1.5</tex> раза. Причем начальный размер равен <tex>10</tex>. Как и в vector, в ArrayList не предусмотрено изменение размера при удалении элементов. Для принудительного изменения размера следует использовать метод trimToSize().

==Источники информации==
* [[wikipedia:Dynamic_array | Wikipedia {{---}} Dynamic array]]
* [[wikipedia:ru:Динамический_массив | Wikipedia {{---}} Динамический массив]]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Амортизационный анализ]]

Динамический массив

2016-01-21T09:06:39Z

Nikitaevg: /* Стоимость операции del() */

{{Определение
| definition =
'''Массив''' {{---}} набор однотипных переменных, доступ к которым осуществляется по индексу. '''Динамический массив''' может изменять свой размер в зависимости от количества элементов в нём.
}}

== Операции ==
Определим операции, которые мы будем применять к динамическому массиву: 
=== get(i) ===
:Возвращает значение <tex>i</tex>-ой ячейки массива. Время выполнения {{---}} <tex>O(1)</tex>.
=== set(i,x) ===
:В <tex>i</tex>-ую ячейку массива записывается элемент <tex>x</tex>. Время выполнения {{---}} <tex>O(1)</tex>.
=== add(x) ===
:Добавление в массив элемента <tex>x</tex>. Время выполнения {{---}} <tex>O(1)</tex>; в худшем случае, при котором необходимо перенести все элементы из текущего массива в вдвое больший массив {{---}} <tex>O(n)</tex> (<tex>n</tex> {{---}} размер массива).
=== del() ===
:Удаляет последний элемент массива. В случае, если количество элементов в массиве в <tex>C</tex> раз меньше его длины, то происходит сжатие в <tex>B</tex> раз. (<tex>C,B</tex> {{---}} константы, зависящие от реализации). Время выполнения операции в худшем случае {{---}} <tex>O(n)</tex>.

=== size() ===
:Возвращает количество элементов массива. Время выполнения {{---}} <tex>O(1)</tex>.

== Амортизационная стоимость каждой операции ==
Пусть наш массив расширяется в <tex>2</tex> раза, и уменьшается в <tex>2</tex> раза, когда длина массива в <tex>4</tex> раза больше количества элементов в массиве. В этом случае амортизационная стоимость каждой операции будет <tex>O(1)</tex>.
=== Метод предоплаты ===
==== Стоимость операции add(x) ====
[[Файл:Безымянный1.png|400px|thumb|right|Иллюстрация]]
Пусть у нас единицей стоимости операции является одна монетка. Тогда при каждой операции '''add(x)''', при которой нам не требуется копирование, мы будем использовать три монетки. Из них одна пойдёт на стоимость самой этой операции, а две будут в резерве (пусть, если мы добавили <tex>i</tex>-ый элемент, мы будем класть по одной монетке к элементам с номерами <tex dpi=150>i</tex> и <tex dpi=150>i-\frac{n}{2}</tex>). В итоге, к тому моменту, как массив будет заполнен, рядом с каждым элементом будет лежать по одной монетке, которую мы и можем использовать на его копирование в новый массив. Таким образом, амортизационная стоимость каждой операции '''add(x)''' {{---}} <tex>3</tex>, и среднее время её работы {{---}} <tex>O(1)</tex>.
==== Стоимость операции del() ====
При каждой операции будем использовать две монетки. Одну из них потратим на само удаление элемента, другую на элемент, стоящий на позиции <tex>i \bmod \dfrac{n}{4}</tex>. Тогда даже в самом худшем случае (только что расширились, а потом <tex>\dfrac{n}{4}</tex> удалили) у каждого элемента из первых <tex>\dfrac{n}{4}</tex> будет по монете и на удаление надо будет потратить только <tex>1</tex> монету.

=== Метод потенциалов ===
За потенциал примем число:
<tex dpi=150>\Phi(c, s) = \begin{cases}
2s-c, & \text{if } s\geqslant\frac{1}{2}c \\
\frac{1}{2}c-s, & \text{if } s<\frac{1}{2}c
\end{cases}</tex>

где <tex>c</tex> {{---}} размер массива, <tex>s</tex> {{---}} число элементов массива.

==== Стоимость операции '''add(x)''' ====

* <tex dpi=150>\frac{s}{c} = 1</tex>, массив расширяется: <tex dpi=150> a_i = t_i + \Phi(2c, s + 1) - \Phi(c, s) = (s + 1) + (2(s+1)-2c)-(2s-c) = 3 </tex>

* <tex dpi=150>1>\frac{s}{c}\geqslant\frac{1}{2}</tex>, массив не расширяется: <tex dpi=150>a_i=t_i+\Phi(c,s+1)-\Phi(c,s)=1+(2(s+1)-c)-(2s-c)=3</tex>

* <tex dpi=150>\frac{s}{c}<\frac{1}{2}, \frac{s+1}{c}\geqslant\frac{1}{2}</tex>, массив не расширяется:
<tex dpi=150>a_i = t_i + \Phi(c, s+1)-\Phi(c, s)= 1 +(2(s+1)-c)-(\frac{1}{2}c - s)= 3+s-\frac{3}{2}c= 3 + \frac{s}{c}c-\frac{3}{2}c <3+\frac{3}{2}c-\frac{3}{2}c=3</tex>

* <tex dpi=150>\frac{s}{c}<\frac{1}{2}, \frac{s+1}{c}<\frac{1}{2}</tex>, массив не расширяется: <tex dpi=150>a_i = t_i + \Phi(c, s + 1) - \Phi(c, s) = 1 + (\frac{1}{2}c - (s + 1)) - (\frac{1}{2}c - s) = 0</tex>

В итоге, средняя стоимость операции {{---}} <tex>3</tex>, а среднее время работы {{---}} <tex>O(1)</tex>.

==== Стоимость операции del() ====

* <tex dpi=150>\frac{s}{c}=\frac{1}{4}</tex>, массив сужается: <tex dpi=150>a_i = t_i + \Phi(\frac{c}{2}, s - 1) - \Phi(c, s) = s + (\frac{1}{2}\cdot\frac{1}{2}c-(s-1)) - (\frac{1}{2}c-s) = 1-\frac{1}{4}c+s=1</tex>
* <tex dpi=150>\frac{1}{4}<\frac{s}{c}<\frac{1}{2}</tex>, массив не сужается: <tex dpi=150>a_i = t_i + \Phi(c, s - 1) - \Phi(c, s) = 1 + (\frac{1}{2}c-(s-1))-(\frac{1}{2}c-s)= 2</tex>
* <tex dpi=150>\frac{s}{c}\geqslant\frac{1}{2}, \frac{s-1}{c}<\frac{1}{2}\Rightarrow s=\frac{1}{2}c</tex>, массив не сужается: <tex dpi=150>a_i = t_i + \Phi(c, s - 1) - \Phi(c, s) =1 +(\frac{1}{2}c-(s-1))-(2s-c)=2+\frac{3}{2}c-3s = 2</tex>
* <tex dpi=150>\frac{s}{c}>\frac{1}{2}</tex>, массив не сужается: <tex dpi=150>a_i = t_i + \Phi(c, s - 1) - \Phi(c, s) = 1 + (2(s-1)-c)-(2s-c)=3</tex>

Средняя стоимость операции {{---}} <tex>2</tex>, а среднее время работы {{---}} <tex>O(1)</tex>.

==Динамические массивы в современных языках программирования==
Динамические массивы широко применяются во многих языках программирования. Рассмотрим, как эта структура данных реализуется в С++ и Java.
===С++ {{---}} vector===
В С++ динамический массив используется в структуре vector, она описана в STL(<vector>). Стратегия расширения проста: при попытке записи в массив нового элемента в момент полного заполнения памяти происходит увеличение размера в <tex>2</tex> раза при компиляции GNU C++ и в <tex>1.5</tex> раза при компиляции Microsoft Visual C++. При удалении элементов уменьшение размера массива никогда не происходит. При инициализации vector по-умолчанию начальный размер равен <tex>0</tex>.
===Java {{---}} ArrayList===
В Java структура ArrayList основана на динамическом массиве. При превышении максимального на данный момент размера происходит увеличение в <tex>1.5</tex> раза. Причем начальный размер равен <tex>10</tex>. Как и в vector, в ArrayList не предусмотрено изменение размера при удалении элементов. Для принудительного изменения размера следует использовать метод trimToSize().

==Источники информации==
* [[wikipedia:Dynamic_array | Wikipedia {{---}} Dynamic array]]
* [[wikipedia:ru:Динамический_массив | Wikipedia {{---}} Динамический массив]]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Амортизационный анализ]]

Динамический массив

2016-01-21T09:02:08Z

Nikitaevg: /* Стоимость операции del() */ неправильно была описана.

{{Определение
| definition =
'''Массив''' {{---}} набор однотипных переменных, доступ к которым осуществляется по индексу. '''Динамический массив''' может изменять свой размер в зависимости от количества элементов в нём.
}}

== Операции ==
Определим операции, которые мы будем применять к динамическому массиву: 
=== get(i) ===
:Возвращает значение <tex>i</tex>-ой ячейки массива. Время выполнения {{---}} <tex>O(1)</tex>.
=== set(i,x) ===
:В <tex>i</tex>-ую ячейку массива записывается элемент <tex>x</tex>. Время выполнения {{---}} <tex>O(1)</tex>.
=== add(x) ===
:Добавление в массив элемента <tex>x</tex>. Время выполнения {{---}} <tex>O(1)</tex>; в худшем случае, при котором необходимо перенести все элементы из текущего массива в вдвое больший массив {{---}} <tex>O(n)</tex> (<tex>n</tex> {{---}} размер массива).
=== del() ===
:Удаляет последний элемент массива. В случае, если количество элементов в массиве в <tex>C</tex> раз меньше его длины, то происходит сжатие в <tex>B</tex> раз. (<tex>C,B</tex> {{---}} константы, зависящие от реализации). Время выполнения операции в худшем случае {{---}} <tex>O(n)</tex>.

=== size() ===
:Возвращает количество элементов массива. Время выполнения {{---}} <tex>O(1)</tex>.

== Амортизационная стоимость каждой операции ==
Пусть наш массив расширяется в <tex>2</tex> раза, и уменьшается в <tex>2</tex> раза, когда длина массива в <tex>4</tex> раза больше количества элементов в массиве. В этом случае амортизационная стоимость каждой операции будет <tex>O(1)</tex>.
=== Метод предоплаты ===
==== Стоимость операции add(x) ====
[[Файл:Безымянный1.png|400px|thumb|right|Иллюстрация]]
Пусть у нас единицей стоимости операции является одна монетка. Тогда при каждой операции '''add(x)''', при которой нам не требуется копирование, мы будем использовать три монетки. Из них одна пойдёт на стоимость самой этой операции, а две будут в резерве (пусть, если мы добавили <tex>i</tex>-ый элемент, мы будем класть по одной монетке к элементам с номерами <tex dpi=150>i</tex> и <tex dpi=150>i-\frac{n}{2}</tex>). В итоге, к тому моменту, как массив будет заполнен, рядом с каждым элементом будет лежать по одной монетке, которую мы и можем использовать на его копирование в новый массив. Таким образом, амортизационная стоимость каждой операции '''add(x)''' {{---}} <tex>3</tex>, и среднее время её работы {{---}} <tex>O(1)</tex>.
==== Стоимость операции del() ====
При каждой операции будем использовать две монетки. Одну из них потратим на само удаление элемента, другую на элемент, стоящий на позиции <tex dpi=150>i \bmod \dfrac{n}{4}</tex>. Тогда даже в самом худшем случае (только что расширились, а потом <tex>\dfrac{n}{4}</tex> удалили) у каждого элемента из первых <tex>\dfrac{n}{4}</tex> будет по монете и на удаление надо будет потратить только <tex>1</tex> монету.

=== Метод потенциалов ===
За потенциал примем число:
<tex dpi=150>\Phi(c, s) = \begin{cases}
2s-c, & \text{if } s\geqslant\frac{1}{2}c \\
\frac{1}{2}c-s, & \text{if } s<\frac{1}{2}c
\end{cases}</tex>

где <tex>c</tex> {{---}} размер массива, <tex>s</tex> {{---}} число элементов массива.

==== Стоимость операции '''add(x)''' ====

* <tex dpi=150>\frac{s}{c} = 1</tex>, массив расширяется: <tex dpi=150> a_i = t_i + \Phi(2c, s + 1) - \Phi(c, s) = (s + 1) + (2(s+1)-2c)-(2s-c) = 3 </tex>

* <tex dpi=150>1>\frac{s}{c}\geqslant\frac{1}{2}</tex>, массив не расширяется: <tex dpi=150>a_i=t_i+\Phi(c,s+1)-\Phi(c,s)=1+(2(s+1)-c)-(2s-c)=3</tex>

* <tex dpi=150>\frac{s}{c}<\frac{1}{2}, \frac{s+1}{c}\geqslant\frac{1}{2}</tex>, массив не расширяется:
<tex dpi=150>a_i = t_i + \Phi(c, s+1)-\Phi(c, s)= 1 +(2(s+1)-c)-(\frac{1}{2}c - s)= 3+s-\frac{3}{2}c= 3 + \frac{s}{c}c-\frac{3}{2}c <3+\frac{3}{2}c-\frac{3}{2}c=3</tex>

* <tex dpi=150>\frac{s}{c}<\frac{1}{2}, \frac{s+1}{c}<\frac{1}{2}</tex>, массив не расширяется: <tex dpi=150>a_i = t_i + \Phi(c, s + 1) - \Phi(c, s) = 1 + (\frac{1}{2}c - (s + 1)) - (\frac{1}{2}c - s) = 0</tex>

В итоге, средняя стоимость операции {{---}} <tex>3</tex>, а среднее время работы {{---}} <tex>O(1)</tex>.

==== Стоимость операции del() ====

* <tex dpi=150>\frac{s}{c}=\frac{1}{4}</tex>, массив сужается: <tex dpi=150>a_i = t_i + \Phi(\frac{c}{2}, s - 1) - \Phi(c, s) = s + (\frac{1}{2}\cdot\frac{1}{2}c-(s-1)) - (\frac{1}{2}c-s) = 1-\frac{1}{4}c+s=1</tex>
* <tex dpi=150>\frac{1}{4}<\frac{s}{c}<\frac{1}{2}</tex>, массив не сужается: <tex dpi=150>a_i = t_i + \Phi(c, s - 1) - \Phi(c, s) = 1 + (\frac{1}{2}c-(s-1))-(\frac{1}{2}c-s)= 2</tex>
* <tex dpi=150>\frac{s}{c}\geqslant\frac{1}{2}, \frac{s-1}{c}<\frac{1}{2}\Rightarrow s=\frac{1}{2}c</tex>, массив не сужается: <tex dpi=150>a_i = t_i + \Phi(c, s - 1) - \Phi(c, s) =1 +(\frac{1}{2}c-(s-1))-(2s-c)=2+\frac{3}{2}c-3s = 2</tex>
* <tex dpi=150>\frac{s}{c}>\frac{1}{2}</tex>, массив не сужается: <tex dpi=150>a_i = t_i + \Phi(c, s - 1) - \Phi(c, s) = 1 + (2(s-1)-c)-(2s-c)=3</tex>

Средняя стоимость операции {{---}} <tex>2</tex>, а среднее время работы {{---}} <tex>O(1)</tex>.

==Динамические массивы в современных языках программирования==
Динамические массивы широко применяются во многих языках программирования. Рассмотрим, как эта структура данных реализуется в С++ и Java.
===С++ {{---}} vector===
В С++ динамический массив используется в структуре vector, она описана в STL(<vector>). Стратегия расширения проста: при попытке записи в массив нового элемента в момент полного заполнения памяти происходит увеличение размера в <tex>2</tex> раза при компиляции GNU C++ и в <tex>1.5</tex> раза при компиляции Microsoft Visual C++. При удалении элементов уменьшение размера массива никогда не происходит. При инициализации vector по-умолчанию начальный размер равен <tex>0</tex>.
===Java {{---}} ArrayList===
В Java структура ArrayList основана на динамическом массиве. При превышении максимального на данный момент размера происходит увеличение в <tex>1.5</tex> раза. Причем начальный размер равен <tex>10</tex>. Как и в vector, в ArrayList не предусмотрено изменение размера при удалении элементов. Для принудительного изменения размера следует использовать метод trimToSize().

==Источники информации==
* [[wikipedia:Dynamic_array | Wikipedia {{---}} Dynamic array]]
* [[wikipedia:ru:Динамический_массив | Wikipedia {{---}} Динамический массив]]

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Амортизационный анализ]]

Расстояние Хэмминга

2016-01-20T07:42:18Z

Nikitaevg:

{{Определение
|definition=
'''Расстояние Хэмминга''' (англ. ''Hamming distance'') {{---}} число позиций, в которых различаются соответствующие символы двух строк одинаковой длины. }}
В более общем случае расстояние Хэмминга применяется для строк одинаковой длины любых k-ичных алфавитов и служит [[Метрическое пространство#def1 | метрикой]] различия (функцией, определяющей расстояние в метрическом пространстве) объектов одинаковой размерности.

==Пример==
*d(1011101, 1001001)=2
*d(1538124, 1523156)=4
*d(hill, holl)=1

==Свойства==
''Расстояние Хэмминга'' обладает свойствами метрики, так как удовлетворяет ее [[Метрическое пространство#def1 | определению]].

#<tex>~d(x, y) = 0 \iff x = y</tex> ''(Если расстояние от <tex>x</tex> до <tex>y</tex> равно нулю, то <tex>x</tex> и <tex>y</tex> совпадают (<tex>x = y</tex>))''
#<tex>~d(x,y)=d(y,x)</tex> ''(Объект <tex>x</tex> удален от объекта <tex>y</tex> так же, как объект <tex>y</tex> удален от объекта <tex>x</tex>)''
#<tex>~d(x,y) \leqslant d(x,z) + d(z,y)</tex> ''(Расстояние от <tex>x</tex> до <tex>y</tex> всегда меньше или равно расстоянию от <tex>x</tex> до <tex>y</tex> через точку <tex>z</tex>. Это свойство обычно называют неравенством треугольника за его естественную геометрическую аналогию: сумма двух сторон треугольника всегда больше третьей стороны.)''

== Доказательство неравенства треугольника ==
{{Утверждение
|statement=<tex>~d(x,y) \leqslant d(x,z) + d(z,y)</tex>
|proof=

Пусть слова <tex>x</tex> и <tex>y</tex> отличаются в некоторых позициях. Тогда какое бы слово <tex>z</tex> мы ни взяли, оно будет отличаться в каждой из этих позиций по крайне мере от одного из слов <tex>x</tex> и <tex>y</tex>. Следовательно, суммируя в правой части <tex>d(x, z)</tex> и <tex>d(z, y)</tex>, мы обязательно учтем все позиции, в которых различались слова <tex>x</tex> и <tex>y</tex>. Т.е. получается, что <tex>~d(x,y) \leqslant d(x,z) + d(z,y)</tex>.
}}

== См. также ==
*[[Избыточное кодирование, код Хэмминга]]

== Источники информации ==
*[http://ru.wikipedia.org/wiki/Расстояние_Хэмминга Расстояние Хэмминга — Википедия]
*[http://en.wikipedia.org/wiki/Hamming_distance Hamming distance - Wikipedia]
*[http://inf.1september.ru/article.php?ID=200701701 Математические основы информатики]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия]]

Алгоритм Ху-Таккера

2016-01-20T07:39:19Z

Nikitaevg:

'''''Алгоритм Ху-Таккера''''' (англ. ''Hu-Tucker Algorithm'') {{---}} алгоритм построения оптимального алфавитного дерева.

''Алфавитное дерево'' {{---}} дерево в котором при просмотре листьев слева направо символы идут в алфавитном порядке, и код последующего лексикографически больше предыдущего.
==Определение==

{{Определение
|definition=
Пусть <tex>A=\{a_{1},a_{2},...,a_{n}\}</tex> — алфавит из <tex>n</tex> различных символов, <tex>W=\{w_{1},w_{2},...,w_{n}\}</tex> — соответствующий ему набор весов. Тогда алгоритм выбора набора бинарных кодов <tex>C=\{c_{1},c_{2},...,c_{n}\}</tex>, такой, что:

*<tex>c_{i}</tex> не является префиксом для <tex>c_{j}</tex>, при <tex>i \ne j</tex>

*для всех <tex>a_{i}<a_{j}</tex>, выполнено <tex>c_{i}<c_{j}</tex>

*при удовлетворенности условия <tex>2</tex>, <tex>\sum\limits_{i \in [1, n]} w_{i}\cdot |c_{i}|</tex> минимальна (<tex>|c_{i}|</tex> — длина кода <tex>c_{i}</tex>)

называется ''алгоритмом Ху-Таккера''.
}}
== Алгоритм ==

=== Алгоритм Ху-Таккера ===
* Начало.
* '''Шаг 0.''' ''Введем следующие понятия''.
**Две вершины называются совместимой парой, если они соседние или если между ними нет вершин алфавита.
**Две вершины называются минимальной парой, когда их суммарный вес наименьший из всех. При равенстве весов выбирается пара с самой левой вершиной, из всех таких та, у которой правый узел расположен левее.
**Минимальной совместимой парой называется наименьшая пара из всех совместимых.
* '''Шаг 1.''' Изначально мы имеем только алфавит (и соответствующие веса), отсортированный лексикографически.
* '''Шаг 2.''' ''Комбинирование''. По данной последовательности из <tex>n</tex> вершин строим последовательность из <tex>n-1</tex> вершины, комбинируя минимальную совместимую пару и заменяя ее левую вершину вершиной с весом <tex> w = w_{l} + w_{r} </tex> и удаляя правую. Эта процедура повторяется до тех пор, пока не останется одна вершина.
* '''Шаг 3.''' ''Определение уровней''. Находим номер уровня <tex>l_{i}</tex> каждого листа относительно корня.
* '''Шаг 4.''' ''Перестройка''. После того, как номера уровней <tex>l_{1}, l_{2}, ..., l_{n}</tex> всех листьев определены, просматриваем последовательность слева направо и находим самый левый номер максимального уровня, скажем, <tex>l_{i}=q</tex>. Тогда и <tex>l_{i+1}=q</tex> (в последовательности <tex>l_{1}, l_{2}, ..., l_{n}</tex> максимальные номера уровней всегда располагаются рядом). Создаем вершину уровня <tex>q-1</tex> вместо вершин уровня <tex>q</tex>. Другими словами, последовательность уровней <tex>l_{1}, l_{2}, ..., l_{q}, l_{q}, ..., l_{n}</tex> заменяется на <tex>l_{1}, l_{2}, ..., l_{q}-1, ..., l_{n}</tex>. Повторяем этот процесс до тех пор пока не останется одна вершина с уровнем <tex>0</tex>.
* Конец.

Заметим, что перестройку легко можно организовать с помощью следующего стекового алгоритма.
=== Стековый алгоритм перестройки ===
* Начало.
* '''Шаг 0.''' [[Стек]] пуст.
* '''Шаг 1.''' Если значение двух верхних элементов различно или в стеке всего один элемент перейти к шагу <tex>2</tex>, иначе к шагу <tex>3</tex>.
* '''Шаг 2.''' Поместить следующий элемент <tex>l_{i}</tex> на вершину стека. Перейти к шагу <tex>1</tex>.
* '''Шаг 3.''' Удалить <tex>2</tex> верхних элемента стека, поместить в стек элемент со значением меньшим на единицу, чем удаленные. Если значение нового элемента равно нулю {{---}} остановиться, иначе перейти к шагу <tex>1</tex>.
* Конец.

==Пример==
Для примера возьмем алфавит <tex>A= \{a,b,c,d,e,f,t,g,h,i,j\} </tex>, а набор весов <tex>W= \{8,6,2,3,4,7,11,9,8,1,3\} </tex>.

Выполним второй шаг алгоритма.

Объединим сначала <tex>w_{i}=1</tex> и <tex>w_{j}=3</tex>, получим вершину с весом <tex>w_{ij}=4</tex>, затем <tex>w_{c}=2</tex> и <tex>w_{d}=3</tex> на вершину веса <tex>w_{cd}=5</tex>, и т.д. пока не останется одна вершина.

[[Файл:Hu-Taker_eps1.gif‎|300px]]

Выполним третий шаг.
Определим уровни для каждого листа <tex>L= \{3,3,5,5,4,3,3,3,3,4,4\} </tex>.

[[Файл:Hu-Taker Layer2.png|300px]]

Выполним четвертый шаг, воспользовавшись стековым алгоритмом, и получим необходимое дерево.

[[Файл:Hu-Taker_eps3.gif|300px]][[Файл:Hu Takker eps3.png ‎|300px]]

Осталось только назначить код для каждого символа. Это делается аналогично [[Алгоритм Хаффмана|коду Хаффмана]]: левым ребрам назначается <tex>0</tex>, а правым <tex>1</tex>.

== Обоснование алгоритма Ху-Таккера ==

Далее последовательностью-впадиной будем называть последовательность вида <tex>w_{1} > ... > w_{t} < ... < w_{n}</tex>.

Для обоснования воспользуемся несколькими леммами.
{{Лемма
|id=lemma1
|about=1
|statement=
Если последовательность весов монотонно не убывает или монотонно убывает, то стоимости деревьев Хаффмана и Ху-Таккера совпадают. Более того, существует дерево Хаффмана, удовлетворяющее требованию алфавитности (см. упражнения к разделу 2.3.4-5 вт.1 книги Д. Кнута Искусство программирования для ЭВМ).
}}
{{Лемма
|id=lemma2
|about=2
|statement=
Если последовательность весов является впадиной, то стоимости деревьев Хаффмана и Ху-Таккера равны. Более того, существует дерево Хаффмана, удовлетворяющее требованию алфавитности (см. книгу Т.Ч.Ху и М.Т.Шинг Комбинаторные алгоритмы {{---}} леммы 7 и 8 в разделе 5.8).
}}
{{Лемма
|id=lemma3
|about=3
|statement=
Если последовательность весов является впадиной, то новые вершины, создаваемые в фазе <tex>1</tex> алгоритма Ху-Таккера, образуют очередь с монотонно возрастающими весами. Потомки каждой из этих новых вершин могут быть соединены в алфавитное бинарное дерево, удовлетворяющее условию: если <tex>w_{i} \leqslant w_{j}</tex>, то <tex>l_{j} \leqslant l_{i}</tex>.
}}
Заметим, что в последовательности-впадине две наименьших вершины всегда совместимы. Поэтому в алгоритме Хаффмана будут комбинироваться те же пары, что и в фазе <tex>1</tex> алгоритма Ху-Таккера. Для удобства введем две вершины алфавита <tex>w_{L}</tex> и <tex>w_{R}</tex> веса <tex>\infty</tex>, расположенных соответственно в начале и в конце последовательности. Тогда последовательность весов <tex>w_{1} < w_{2} < ... < w_{t} > w_{t+1} > ... > w_{n}</tex> можно рассматривать как последовательность состоящую из двух впадин: <tex>w_{L} > w_{1} < w_{2} < ... < w_{t} > w_{t+1} > ... > w_{n} < w_{R}</tex>.

Вершину <tex>t</tex> назовем горой между двумя впадинами.

Из [[#lemma3|леммы 3]] следует, что можно образовать две отдельных [[Очередь | очереди]] {{---}} одну для каждой впадины. Из-за горы вершины из разных впадин не совместимы между собой. Когда наименьшие новые вершины(полученные в результате слияния) во впадинах станут достаточно большими, гора будет наконец скомбинирована. С этого момента все новые вершины станут совместимыми. Получается слияние двух очередей. По существу, фаза <tex>1</tex> в алгоритме Ху-Таккера подобна слиянию нескольких очередей, а произвольную последовательность весов можно рассматривать как соединение нескольких впадин.

Чтобы понять, почему последовательность уровней может быть соединена в алфавитное дерево на третьем шаге алгоритма, достаточно рассмотреть два случая:
*Комбинируются две вершины из одной впадины.
*Комбинируются две вершины <tex>a</tex> и <tex>e</tex> из разных впадин. Пусть при этом между <tex>a</tex> и <tex>e</tex> расположены новые вершины <tex>b,c,d</tex> {{---}} каждая из них имеет двух сыновей, скажем, <tex>b1</tex> и <tex>b2</tex>, <tex>c1</tex> и <tex>c2</tex>, <tex>d1</tex> и <tex>d2</tex> {{---}} когда комбинируются <tex>a</tex> и <tex>e</tex>, мы в действительности создаем общего отца для <tex>a</tex> и <tex>b1</tex>. После этого общего отца получают <tex>b2</tex> и <tex>c1</tex>, затем <tex>c2</tex> и <tex>d1</tex>. Наконец, общего отца получают <tex>d2</tex> и <tex>e</tex>.

Заметим, что это лишь обоснование, а не строгое доказательство, его задача {{---}} дать понимание правдивости алгоритма.

== Корректность алгоритма Ху-Таккера ==

Как пишет Д. Кнут короткого доказательства алгоритма не известно, и вероятно оно никогда не будет найдено. Для доказательства своего алгоритма Ху и Таккеру потребовалось <tex>3</tex> теоремы и <tex>2</tex> леммы (См. книгу Т.Ч.Ху и М.Т.Шинг Комбинаторные алгоритмы {{---}} стр.172).

== Сложность алгоритма ==

Для реализации данного алгоритма потребуется <tex>O(n)</tex> памяти и <tex>O(n \log n)</tex> времени на построение дерева.

Разберем оценку. Для доказательства такой оценки времени введем понятие ''локально минимальной совместимой пары'' (л.м.с.п), пара <tex>(w_{l},w_{r})</tex> является л.м.с.п, когда выполнены следующие условия <tex>w_{r}<w_{i}</tex> для всех вершин <tex>i</tex> совместимых с <tex>l</tex> и <tex>w_{l} \leqslant w_{j}</tex> для всех вершин <tex>j</tex> совместимых с <tex>r</tex>. Также докажем следующую лемму:
{{Лемма
|id=lemma1
|about=1
|statement=
Пусть <tex>a</tex> {{---}} любая вершина в последовательности, состоящей из вершин алфавита и вершин, образованных в результате комбинации, <tex>w_{i}</tex> {{---}} вес наименьшей вершины <tex>i</tex>, совместимой с <tex>a</tex>. Если в результате комбинирования некоторой л.м.с.п. какая-нибудь новая вершина <tex>d</tex> становится совместимой с <tex>a</tex>, то <tex>w_{i}<w_{d}</tex>. В частности, в последовательности вершин будет оставаться л.м.с.п., пока комбинируются другие л.м.с.п.

Из этой леммы следует, что дерево, получаемое комбинированием л.м.с.п., не зависит от того, в каком порядке они комбинируются.
|proof=
Рассмотрим произвольную вершину <tex>a</tex> и предположим, что вес наименьшей вершины, совместимой с <tex>a</tex>, равен <tex>w_{i}</tex>.

Пусть комбинируется л.м.с.п. <tex>(b, c)</tex>, причем <tex>a</tex> ближе к <tex>b</tex>. Тогда между <tex>a</tex> и <tex>b</tex> нет вершин алфавита и хотя бы одна из <tex>b</tex>, <tex>c</tex> должна быть вершиной алфавита, иначе при слиянии <tex>(b, c)</tex> не появилось бы новых вершин (кроме <tex>bc</tex>), совместимых с <tex>a</tex>.

Заметим, что <tex>w_{i}</tex> может находиться в любой стороне от <tex>a</tex>. Если вершина <tex>w_{i}</tex> лежит справа от <tex>a</tex>, то она не вершина алфавита. Пусть <tex>d</tex> {{---}} вершина, которая становится совместимой с <tex>a</tex> после слияния <tex>(b, c)</tex> (она может быть как алфавитной так и слитой). Тогда <tex>d</tex> должна быть совместима с <tex>c</tex> в исходной последовательности и в силу локальной минимальности пары <tex>(b, c)</tex> имеем <tex>w_{b} \leqslant w_{d}</tex>.

Но <tex>w_{i}<w_{b}</tex>, так как <tex>b</tex> совместима с <tex>a</tex> в исходной последовательности, а <tex>w_{i}</tex> является наименьшим совместимым с <tex>a</tex> весом. Поэтому <tex>w_{i} \leqslant w_{b} \leqslant w_{d}</tex>.

Мы доказали, что вес наименьшей вершины, совместимой с любой вершиной, не может уменьшиться. Отсюда следует, что любая л.м.с.п. <tex>(x, y)</tex> останется л.м.с.п. после слияния другой л.м.с.п., потому что <tex>x</tex> останется наименьшей вершиной, совместимой с <tex>y</tex>, и наоборот.
}}

Теперь согласно этой лемме нам не придется искать минимально совместимую пару, что весьма долго. Достаточно лишь находить л.м.с.п., при этом не важно, в каком порядке комбинировать л.м.с.п. По этому нам необходимо иметь массив размера <tex>n</tex>, из которого мы будем удалять л.м.с.п и создавать новую вершину. На нем легко будет осуществлять поиск л.м.с.п. А так же необходим массив размера <tex>2n</tex> для реализации следующего шага, хранящий дерево. Второй шаг легко осуществить проходом по дереву, имея сохраненное дерево. Третий шаг, реализованный стековым алгоритмом, работает за <tex>2n</tex> времени и требует <tex>4n</tex> памяти <tex>n</tex> на стек, <tex>n</tex> на хранения уровней вершин и <tex>2n</tex> на хранение итогового дерева. Итак, общая оценка как раз получается <tex>O(n)</tex> памяти и <tex>O(n \log n)</tex> времени.

== Смотри также ==
* [[Алгоритм Хаффмана]]
* [[Избыточное кодирование, код Хэмминга]]
* [[Стек]]
* [[Очередь]]

== Источники информации ==
* ''Т.Ч.Ху, М.Т.Шинг'' Комбинаторные алгоритмы. — стр. 166. — ISBN 5-85746-761-6
* ''Дональд Кнут'' Искусство программирования, том 3. Сортировка и поиск — 2-е изд. — М.: «Вильямс», 2007. — 824 с. — ISBN 5-8459-0082-4

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Алгоритмы сжатия ]]

Специальные формы КНФ

2016-01-20T07:13:59Z

Nikitaevg:

Рассмотрим две формы, с помощью которых можно представить формулы, заданные в [[Определение булевой функции#Представление булевых функций|конъюнктивной нормальной форме]], то есть имеющей вид конъюнкции выражений в скобках, каждое из которых представляет собой дизъюнкцию одного или нескольких литералов. Эти две формы интересны тем, что для них существует алгоритм, который может за полиномиальное время проверить, существует ли набор аргументов, на которых данная функция будет принимать значение <tex>1</tex>, в то время, как для обычной функции, не представленной данной формой, эта задача является [[Примеры NP-полных языков. Теорема Кука|NP-полной]].

== КНФ в форме Крома ==
{{Определение
|definition=
'''Конъюнктивная нормальная форма (КНФ) в форме Крома (2-КНФ)''' (англ. ''2-CNF'') {{---}} это конъюнкция выражений в скобках, каждое из которых представляет собой дизъюнкцию нескольких литералов, количество которых не превышает двух.}}

'''Пример :'''

<tex>(x_1\vee\overline x_2) \wedge (\overline x_1 \vee x_3 ) \wedge (\overline x_3 \vee x_2 ) \wedge (\overline x_1 \vee \overline x_2) \wedge... </tex>

'''Утверждения:'''

*Существует алгоритм, который за полиномиальное время проверяет, что функцию, заданную в форме Крома можно удовлетворить(т.е КНФ в форме Крома не является тождественным <tex>0</tex>).

*Функцию <tex>F</tex> можно задать в форме Крома <tex> \iff </tex> выполнено следующее следствие:

<tex> F(x_1, ..., x_n)=F(y_1, ..., y_n)=F(z_1, ..., z_n)=1 \Rightarrow</tex> <tex>F(\langle x_1, y_1, z_1 \rangle, \langle x_2, y_2, z_2 \rangle, ..., \langle x_n, y_n, z_n \rangle)</tex>

= КНФ в форме Хорна =

{{Определение
|definition=
'''Конъюнктивная нормальная форма (КНФ)в форме Хорна''' (англ. ''Horn clause'') {{---}} это конъюнкция выражений в скобках, каждое из которых представляет собой дизъюнкцию литералов, в которой присутствует не более одного литерала без отрицания.}}

'''Пример:'''

<tex> (\overline x_1 \vee \overline x_2 \vee ... \vee \overline x_n ) \wedge (x_1 \vee \overline x_2 \vee ... \vee \overline x_n)\wedge ...</tex>

Каждая скобка представляет собой Дизъюнкт Хорна<ref>[https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B7%D1%8A%D1%8E%D0%BD%D0%BA%D1%82_%D0%A5%D0%BE%D1%80%D0%BD%D0%B0 {{---}} Дизъюнкт Хорна]</ref>.

Любую формулу можно представить в виде КНФ в форме Хорна. Для этого формулу необходимо преобразовать в конъюнкцию элементарных дизъюнкций и далее каждую дизъюнкцию представить в форме дизьюнкта Хорна.

'''Утверждения:'''

*Существует алгоритм, который за полиномиальное время проверяет, что функцию, заданную в форме Хорна можно удовлетворить.
*Функцию <tex>F</tex> можно задать в форме Хорна <tex> \iff </tex> выполнено следующее следствие:

<tex> F(x_1, ..., x_n)=F(y_1, ..., y_n)=1 \Rightarrow F(x_1 \wedge y_1, x_2 \wedge y_2, ..., x_n \wedge y_n)</tex>

== См.также ==
* [[СКНФ]]
* [[2SAT]]

==Примечания==

<references />

==Источники информации==
*[https://en.wikipedia.org/wiki/Horn_clause| Wikipedia {{---}} Horn clause]
*[https://en.wikipedia.org/wiki/2-satisfiability| Wikipedia {{---}} 2-satisfiability]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Булевы функции ]]

Специальные формы КНФ

2016-01-20T07:10:08Z

Nikitaevg:

Рассмотрим две формы, с помощью которых можно представить формулы, заданные в [[Определение булевой функции#Представление булевых функций|конъюнктивной нормальной форме]], то есть имеющей вид конъюнкции выражений в скобках, каждое из которых представляет собой дизъюнкцию одного или нескольких литералов. Эти две формы интересны тем, что для них существует алгоритм, который может за полиномиальное время проверить, существует ли набор аргументов, на которых данная функция будет принимать значение <tex>1</tex>, в то время, как для обычной функции, не представленной данной формой, эта задача является [[Примеры NP-полных языков. Теорема Кука|NP-полной]].

== КНФ в форме Крома ==
{{Определение
|definition=
'''Конъюнктивная нормальная форма (КНФ) в форме Крома (2-КНФ)''' (англ. ''2-SAT'') {{---}} это конъюнкция выражений в скобках, каждое из которых представляет собой дизъюнкцию нескольких литералов, количество которых не превышает двух.}}

'''Пример :'''

<tex>(x_1\vee\overline x_2) \wedge (\overline x_1 \vee x_3 ) \wedge (\overline x_3 \vee x_2 ) \wedge (\overline x_1 \vee \overline x_2) \wedge... </tex>

'''Утверждения:'''

*Существует алгоритм, который за полиномиальное время проверяет, что функцию, заданную в форме Крома можно удовлетворить(т.е КНФ в форме Крома не является тождественным <tex>0</tex>).

*Функцию <tex>F</tex> можно задать в форме Крома <tex> \iff </tex> выполнено следующее следствие:

<tex> F(x_1, ..., x_n)=F(y_1, ..., y_n)=F(z_1, ..., z_n)=1 \Rightarrow</tex> <tex>F(\langle x_1, y_1, z_1 \rangle, \langle x_2, y_2, z_2 \rangle, ..., \langle x_n, y_n, z_n \rangle)</tex>

= КНФ в форме Хорна =

{{Определение
|definition=
'''Конъюнктивная нормальная форма (КНФ)в форме Хорна''' (англ. ''Horn clause'') {{---}} это конъюнкция выражений в скобках, каждое из которых представляет собой дизъюнкцию литералов, в которой присутствует не более одного литерала без отрицания.}}

'''Пример:'''

<tex> (\overline x_1 \vee \overline x_2 \vee ... \vee \overline x_n ) \wedge (x_1 \vee \overline x_2 \vee ... \vee \overline x_n)\wedge ...</tex>

Каждая скобка представляет собой Дизъюнкт Хорна<ref>[https://ru.wikipedia.org/wiki/%D0%94%D0%B8%D0%B7%D1%8A%D1%8E%D0%BD%D0%BA%D1%82_%D0%A5%D0%BE%D1%80%D0%BD%D0%B0 {{---}} Дизъюнкт Хорна]</ref>.

Любую формулу можно представить в виде КНФ в форме Хорна. Для этого формулу необходимо преобразовать в конъюнкцию элементарных дизъюнкций и далее каждую дизъюнкцию представить в форме дизьюнкта Хорна.

'''Утверждения:'''

*Существует алгоритм, который за полиномиальное время проверяет, что функцию, заданную в форме Хорна можно удовлетворить.
*Функцию <tex>F</tex> можно задать в форме Хорна <tex> \iff </tex> выполнено следующее следствие:

<tex> F(x_1, ..., x_n)=F(y_1, ..., y_n)=1 \Rightarrow F(x_1 \wedge y_1, x_2 \wedge y_2, ..., x_n \wedge y_n)</tex>

== См.также ==
* [[СКНФ]]
* [[2SAT]]

==Примечания==

<references />

==Источники информации==
*[https://en.wikipedia.org/wiki/Horn_clause| Wikipedia {{---}} Horn clause]
*[https://en.wikipedia.org/wiki/2-satisfiability| Wikipedia {{---}} 2-satisfiability]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Булевы функции ]]

Числа Эйлера I и II рода

2016-01-19T20:18:29Z

Nikitaevg:

==Числа Эйлера I рода==
{{Определение
|definition=
Пусть <tex>a</tex> и <tex>b</tex> — соседние элементы некоторой перестановки порядка <tex>n</tex> причем <tex>a < b</tex>. Тогда пара <tex>(a, b)</tex> называется '''подъемом''' (англ. ''ascent'') данной перестановки.
}}
'''''Числа Эйлера I рода''''' (англ. ''Eulerian numbers'') — количество [[Комбинаторные объекты|перестановок]] чисел от <tex>1</tex> до <tex>n</tex> таких, что в каждой из них существует ровно <tex>m</tex> подъемов. Числа Эйлера I рода обозначают как <tex dpi=190>\langle{n\atop m}\rangle </tex> или же <tex>A(n, m)</tex>.

===Вывод рекуррентной формулы===
Пусть у нас есть некая перестановка <tex> \pi = \pi_1, \pi_2\ldots \pi_{n-1} </tex>. Тогда операцией вставки элемента с номером <tex>n</tex> в какую-либо из позиций мы получим <tex>n</tex> перестановок вида <tex>\theta = \theta_1, \theta_2\ldots \theta_p, n, \theta_q\ldots \theta_{n-1}</tex>. Далее рассмотрим два случая:

# Количество подъемов в перестановке <tex>\theta</tex> равно количеству подъемов в <tex>\pi</tex>. Этого можно добиться, вставляя элемент <tex>n</tex> на самое первое место в <tex>\theta</tex> (всего <tex dpi=190>\langle{n\atop m}\rangle </tex> возможностей) или перед последним последним элементом каждого подъема (еще <tex>m \times </tex><tex dpi=190> \langle{n\atop m}\rangle </tex> раз).
# Количество подъемов в новой перестановке на один больше предыдущего количества. Этого эффекта добиваемся вставкой элемента <tex>n</tex> во все места, не подходящие по критерию первого пункта. Таких вставок, как не трудно догадаться, можно совершить <tex>(n - m)</tex><tex dpi=190>\langle{n\atop m}\rangle</tex>.

Тогда рекуррентная формула имеет вид:

:<tex dpi=190>\left\langle{n\atop m}\right\rangle</tex> <tex> = (m + 1)</tex> <tex dpi=190>\left\langle{n - 1\atop m}\right\rangle</tex> <tex> + (n - m)</tex> <tex dpi=180>\left\langle{n - 1\atop m - 1}\right\rangle</tex>

Примем также следующее начальное значение:
:<tex dpi=190>\left\langle{0\atop m}\right\rangle</tex> <tex> = [m = 0]</tex><ref>http://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%82%D0%B0%D1%86%D0%B8%D1%8F_%D0%90%D0%B9%D0%B2%D0%B5%D1%80%D1%81%D0%BE%D0%BD%D0%B0 нотация Айверсона</ref>.

===Пример===
Рассмотрим все перестановки порядка <tex>4</tex>, в которых есть ровно <tex>2</tex> подъема (в квадратных скобках один или больше подъемов подряд):
:<tex dpi=190> \left\langle{4\atop 2}\right\rangle</tex> <tex> = 11:
[124]3,
[13][24],
[134]2,
[14][23],
2[134],
[23][14],
[23][41],
[24][13],
3[124],
[34][12],
4[123],
</tex>

Согласно алгоритму вывода рекуррентной формулы мы можем добавить <tex>4</tex> в следующие позиции всех перестановок порядка <tex>3</tex> с двумя подъемами, не увеличив количество подъемов:

:<tex dpi=190>
\left\langle{3\atop 2}\right\rangle</tex> <tex> = 1:
[123] \Rightarrow (4)[123], [1(4)][23], [12(4)]3
</tex>

Далее рассмотрим все перестановки порядка <tex>3</tex> с одним подъемом, причем операцией вставки <tex>4</tex> мы будем увеличивать количество перестановок на <tex>1</tex>:

:<tex dpi=190> \left\langle{3\atop 1}\right\rangle</tex> <tex> = 4:</tex>

:<tex>[13]2 \Rightarrow [13(4)]2, [13][2(4)];</tex>

:<tex>2[13] \Rightarrow [2(4)][13], 2[13(4)];</tex>

:<tex>[23]1 \Rightarrow [23(4)]1, [23][1(4)];</tex>

:<tex>3[12] \Rightarrow [3(4)][12], 3[12(4)];</tex>

Таким образом мы убеждаемся в верности формулы:

:<tex dpi=190> \left\langle{4\atop 2}\right\rangle</tex> <tex> = (2 + 1)</tex> <tex dpi=190>\left\langle{3\atop 2}\right\rangle</tex> <tex> + (4 - 2)</tex> <tex dpi=190>\left\langle{3\atop 1}\right\rangle</tex> <tex> = 11;</tex>

===Треугольник чисел Эйлера I рода===
На значениях <tex>n = m</tex> чисел Эйлера I рода можно построить массив <tex>n \times m</tex>, нижнедиагональная часть которого названа треугольником чисел Эйлера I рода.

::{| class="number_triangle"

|- align="center"
| style="background:white; color:black; width:50px;" |
| style="background:white; color:black; width:50px;" | '''''m = 0'''''
| style="background:white; color:black; width:50px;" | '''''1'''''
| style="background:white; color:black; width:50px;" | '''''2'''''
| style="background:white; color:black; width:50px;" | '''''3'''''
| style="background:white; color:black; width:50px;" | '''''4'''''
| style="background:white; color:black; width:50px;" | '''''5'''''
| style="background:white; color:black; width:50px;" | '''''6'''''
| style="background:white; color:black; width:50px;" | '''''7'''''
| style="background:white; color:black; width:50px;" | '''''8'''''
| style="background:white; color:black; width:50px;" | '''''9'''''
|- align="center"
| style="background:white; color:black;" | '''''n = 0'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''

|- align="center"
| style="background:white; color:black;" | '''''1'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''2'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''3'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''4'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''4'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''11'''
| style="background:#FFDEAD; color:black;" | '''11'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''5'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''26'''
| style="background:#FFDEAD; color:black;" | '''66'''
| style="background:#FFDEAD; color:black;" | '''26'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''6'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''57'''
| style="background:#FFDEAD; color:black;" | '''302'''
| style="background:#FFDEAD; color:black;" | '''302'''
| style="background:#FFDEAD; color:black;" | '''57'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''7'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''120'''
| style="background:#FFDEAD; color:black;" | '''1191'''
| style="background:#FFDEAD; color:black;" | '''2416'''
| style="background:#FFDEAD; color:black;" | '''1191'''
| style="background:#FFDEAD; color:black;" | '''120'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''8'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''247'''
| style="background:#FFDEAD; color:black;" | '''4293'''
| style="background:#FFDEAD; color:black;" | '''15619'''
| style="background:#FFDEAD; color:black;" | '''15619'''
| style="background:#FFDEAD; color:black;" | '''4293'''
| style="background:#FFDEAD; color:black;" | '''247'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''9'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''502'''
| style="background:#FFDEAD; color:black;" | '''14608'''
| style="background:#FFDEAD; color:black;" | '''88234'''
| style="background:#FFDEAD; color:black;" | '''156190'''
| style="background:#FFDEAD; color:black;" | '''88234'''
| style="background:#FFDEAD; color:black;" | '''14608'''
| style="background:#FFDEAD; color:black;" | '''502'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
|}

===Явные формулы===
:<tex dpi=190>\left\langle{n\atop m}\right\rangle</tex> <tex> = \sum\limits_{j=1}^{m+1} (-1)^{m-j+1} {n+1\choose m-j+1}j^{n}</tex>
:<tex dpi=190>\left\langle{n\atop m}\right\rangle</tex> <tex> = \sum\limits_{j=0}^{m}(-1)^j {n+1\choose j} (m+1-j)^n</tex>

===Связь чисел Эйлера I рода с сечениями гиперкубов===
{{Теорема
|statement=
Число <tex>\dfrac{1}{n!}</tex> <tex dpi=190>\left\langle{n\atop m}\right\rangle</tex> выражает объем части <tex>n</tex>-мерного единичного гиперкуба, ограниченного гиперплоскостями <tex>x_1+x_2+\dots+x_n=m</tex> и <tex>x_1+x_2+\dots+x_n=m-1</tex>.
|proof=
Для доказательства этого факта нам потребуется следующая теорема:
{{Теорема
|about=Об объемах сечений <tex>n</tex>-мерных гиперкубов полупространствами
|statement=

Пусть <tex>w \in \mathbb{R}</tex> — вектор с ненулевыми компонентами (<tex>w = {w_1, w_2 \ldots w_n}</tex>), а <tex>z \in \mathbb{R}_+</tex>. Тогда верно следующее равенство:

<tex>\mathrm{Vol}_{n}(G^n_{w,z} \cap I^{n}) = \dfrac{1}{n! \prod\limits_{i=1}^{n}w_i} \sum\limits_{K \subseteq [n]} (-1)^{|K|}(z-w \cdot 1_K)^n_+</tex>

*<tex>G_{w, z}^{n} := \{x \in \mathbb{R}^{n} : (w \cdot x) \leqslant z \}</tex> — полупространство;
*<tex>I^n := [0,1]^n</tex>;
*<tex>[n] := \{1,2\ldots n\}</tex>;
*<tex>1_K</tex>, где <tex>K</tex> — подмножество <tex>\{1,2\ldots n\}</tex>, {{---}} вектор, где значения координат с номерами, входящими в <tex>K</tex>, равны <tex>1</tex>, а остальные {{---}} нули;
*Для <tex>r \in \mathbb{R}</tex> и <tex>n \in \mathbb{N}</tex> : <tex>r^n_+ := (\max{\{r, 0\}})^n</tex>.

|proof=С доказательством можно ознакомиться по ссылке <ref>http://arxiv.org/pdf/math/0607715.pdf</ref>.
}}

[[Файл:HypercubeEuler2_2.png|200px|thumb|m = 2, n = 1. V = 1/2]]
[[Файл:HypercubeEuler3.png|200px|thumb|m = 3, n = 2. V = 1/6]]
Рассмотрим пересечение гиперкуба полупространством <tex>G^n_{1_{[n]},m}</tex>. Вектор <tex>1_{[n]}</tex> (все координаты которого равны единицы) появляется здесь ввиду того, как мы определили в формулировке секущие гиперплоскости (<tex>x_1+x_2+\ldots +x_n = m | m+1</tex>) {{---}} это вектор нормали к <tex>\mathrm{G}</tex>. Очевидно, что при данном значении вектора произведение <tex>\prod\limits_{i=1}^{n}w_i</tex> равно единице (вектор <tex>w_i</tex> тут {{---}} единичный вектор <tex>1_{[n]}</tex>, то есть рассматривается произведение всех его координат {{---}} единиц). Рассмотрим выражение, стоящее под знаком суммы. При итерации по подмножествам <tex>[n]</tex> равной мощности будут получаться одинаковые слагаемые, так как выражение <tex>(-1)^{|K|}(z-w \cdot 1_K)^n_+</tex> зависит лишь от мощности итерируемого в сумме подмножества <tex>K</tex> {{---}} скалярное произведение <tex>w \cdot 1_K</tex> одинаково за счет того лишь факта, что оно вычисляется как сумма произведений соответствующих координат, где ровно <tex>n - |K|</tex> их обращаются в ноль. Такое скалярное произведение будет равно мощности <tex>K</tex>. Заменим итератор суммы значением мощности множества <tex>K</tex>. Также ограничим верхний индекс суммирования значением <tex>m+1</tex>, так как при больших значениях <tex>j</tex> слагаемое будет обращаться в ноль (<tex>r^n_+</tex>). Отсюда имеем <tex>{n \choose j}</tex> таких одинаковых слагаемых, где <tex>j = |K|</tex>.

Тогда перейдем от первоначальной формулировки теоремы к следующей:
:<tex>\mathrm{Vol}_{n}(G^n_{1_{[n]},m} \cap I^{n}) = \dfrac{1}{n!}\sum\limits_{j = 0}^{m + 1} (-1)^{j}{n \choose j}(m-j)^n</tex>

Положим <tex>W_n^m</tex> — фигура, образованная сечением гиперкуба <tex>[0,1]^{n}</tex> плоскостями <tex>\sum\limits_{i=1}^{n} x_{i} = m</tex> и <tex>\sum\limits_{i=1}^{n} x_{i} = m+1</tex>.
:<tex>W_n^m := \{ x \in \mathbb{R} : m \leqslant x \cdot 1_{[n]} \leqslant m+1 \} \cap I^{n}</tex>

Тогда перейдем к следующему равенству:

:<tex>\mathrm{Vol}_{n}(W_n^m) = \mathrm{Vol}_n(G_{1_{[n]},m+1}^{n} \cap I^n) - \mathrm{Vol}_n(G_{1_{[n]},m}^{n} \cap I^n)</tex>
:<tex>= \dfrac{1}{n!}[\sum\limits_{j=0}^{m+1}(-1)^{j}{n \choose j}(m+1-j)^{n} - \sum\limits_{j=0}^{m}(-1)^{j}{n \choose j}(m-j)^{n}]</tex>
:<tex> = \dfrac{1}{n!}\sum\limits_{j=0}^{m+1}(-1)^j{n+1 \choose j}(m+1-j)^n</tex>
:<tex> = \dfrac{1}{n!}\sum\limits_{j=0}^{m}(-1)^j{n+1 \choose j}(m+1-j)^n</tex> (элемент суммы с номером <tex>j=m+1</tex> обращается в ноль)
:<tex> = </tex> <tex>\dfrac{1}{n!}</tex> <tex dpi=190>\left\langle{n\atop m}\right\rangle</tex> (вторая явная формула)

}}

===Свойства===

# Нетрудно увидеть, что каждый ряд ненулевых значений симметричен относительно своей середины, то есть:
#:<tex dpi=190>\left\langle{n\atop m}\right\rangle = \left\langle{n\atop (n-1) - k}\right\rangle</tex><tex>,\ n \geqslant 1,\ 0 \leqslant k \leqslant n-1. \, </tex>
# Сумма всех значений каждого ряда равна <tex> n! </tex>:
#:<tex>\sum\limits_{m=0}^{n}</tex><tex dpi=190> \left\langle{n\atop m}\right\rangle</tex> <tex> = n!,\ n \geqslant 0, \,</tex>
# Связь чисел Эйлера I рода с числом сочетаний:
#:<tex>\sum\limits_{m=0}^n (-1)^m </tex><tex dpi=190>{\left\langle{n\atop m}\right\rangle}</tex> <tex>{n-1\choose m}^{-1}=0.</tex>
# Вероятность того, что сумма <tex>n</tex> независимых равномерно распределённых в отрезке <tex>[0,1]</tex> переменных лежит между <tex>m-1</tex> и <tex>m</tex> равна <tex>\dfrac{1}{n!}\left\langle{n\atop m}\right\rangle</tex>.

==Числа Эйлера II рода==
'''''Числа Эйлера II рода''''' (англ. ''Eulerian numbers of the second kind'') — количество перестановок мультимножества от <tex>1</tex> до <tex>n</tex> вида <tex>\{1,1,2,2\ldots n,n\}</tex>, обладающих свойством "все элементы перестановки, встречающиеся между двумя вхождниями <tex>z</tex> для любого <tex>z</tex>, больше, чем <tex>z</tex>", таких, что в каждой из них существует ровно <tex>m</tex> подъемов. Числа Эйлера II рода обозначаются как <tex dpi = "190"> \scriptstyle \left\langle \!\! \left\langle {n \atop m} \right\rangle \!\! \right\rangle </tex>

'''Пример'''

Рассмотрим <tex> n = 3</tex>. Тогда существует <tex>15</tex> перестановок такого вида, среди которых одна не имеет подъемов, <tex>8</tex> штук имеют всего <tex>1</tex> подъем, и <tex>6</tex> перестановок имеют <tex>2</tex> подъема:

:<tex> 332211,\; </tex>
:<tex> 221[13]3,\; 22[13]31,\; 2[23]311,\; [23]3211,\; 1[13]322,\; [13]3221,\; 331[12]2,\; 33[12]21, </tex>
:<tex>1[12][23]3,\; [12]2[13]3,\; 1[123]32,\; [123]321,\; [13]3[12]2,\; [12][23]31. </tex>

{{Лемма
|statement=Количество перестановок мультимножества <tex>\{1,1,2,2\ldots n,n\}</tex> со свойством "все элементы перестановки, встречающиеся между двумя вхождниями <tex>z</tex> для любого <tex>z</tex>, больше, чем
<tex dpi="130">z</tex>" равно двойному факториалу <tex dpi="130">(2n-1)!!</tex>.
|proof = Докажем лемму методом математической индукции.
*'''База'''. Для <tex>n=1</tex> очевидно, что существует только одна такая перестановка.
*'''Переход'''. Рассмотрим какую-нибудь перестановку длины <tex>2n</tex>. Таких перестановок <tex>(2n-1)!!</tex>. Теперь докажем, что перестановок длины <tex>2(n+1)</tex> будет <tex>(2(n+1)-1)!!</tex>. Попробуем вставить два числа <tex>n + 1</tex>. Очевидно, что их нельзя вставить не на соседние места, так как в таком случае между ними точно будут меньшие элементы. Но их можно вставить в любые два соседних места, так как они больше всех чисел в перестановке, а значит они не нарушат свойства для других элементов. Таким образом два новых элемента можно вставить в <tex>2n+1</tex> место. В итоге перестановок длины <tex>2(n+1)</tex> будет <tex>(2n-1)!!\cdot (2n+1)=(2n+1)!!=(2(n+1)-1)!!</tex>.
}}

===Рекуррентная формула===
Числа Эйлера II рода можно выразить рекурсивно следующим образом:
:<tex dpi=190> \left\langle \!\! \left\langle {n \atop m} \right\rangle \!\! \right\rangle</tex> <tex> = (2n-m-1) </tex> <tex dpi=180>\left\langle \!\! \left\langle {n-1 \atop m-1} \right\rangle \!\! \right\rangle</tex> <tex> + (m+1) </tex> <tex dpi=190>\left\langle \!\! \left\langle {n-1 \atop m} \right\rangle \!\! \right\rangle, </tex>

С начальным условием для <tex>n = 0</tex>:
:<tex dpi=190> \left\langle \!\! \left\langle {0 \atop m} \right\rangle \!\! \right\rangle</tex> <tex> = [m=0]. </tex>

===Треугольник чисел Эйлера II рода===
Значения чисел Эйлера II рода для <tex>0 \leqslant n \leqslant m \leqslant 9</tex> представлены в данном массиве. Нижнедиагональная его часть называется треугольником чисел Эйлера II рода.

:::{| class="number_triangle"

|- align="center"
| style="background:white; color:black; width:50px;" |
| style="background:white; color:black; width:50px;" | '''''m = 0'''''
| style="background:white; color:black; width:50px;" | '''''1'''''
| style="background:white; color:black; width:50px;" | '''''2'''''
| style="background:white; color:black; width:50px;" | '''''3'''''
| style="background:white; color:black; width:50px;" | '''''4'''''
| style="background:white; color:black; width:50px;" | '''''5'''''
| style="background:white; color:black; width:50px;" | '''''6'''''
| style="background:white; color:black; width:50px;" | '''''7'''''
| style="background:white; color:black; width:50px;" | '''''8'''''
| style="background:white; color:black; width:50px;" | '''''9'''''

|- align="center"
| style="background:white; color:black;" | '''''n = 0'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''

|- align="center"
| style="background:white; color:black;" | '''''1'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''2'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''2'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''3'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''8'''
| style="background:#FFDEAD; color:black;" | '''6'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''4'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''22'''
| style="background:#FFDEAD; color:black;" | '''58'''
| style="background:#FFDEAD; color:black;" | '''24'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''5'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''52'''
| style="background:#FFDEAD; color:black;" | '''328'''
| style="background:#FFDEAD; color:black;" | '''444'''
| style="background:#FFDEAD; color:black;" | '''120'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''6'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''114'''
| style="background:#FFDEAD; color:black;" | '''1452'''
| style="background:#FFDEAD; color:black;" | '''4400'''
| style="background:#FFDEAD; color:black;" | '''3708'''
| style="background:#FFDEAD; color:black;" | '''720'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''7'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''240'''
| style="background:#FFDEAD; color:black;" | '''5610'''
| style="background:#FFDEAD; color:black;" | '''32120'''
| style="background:#FFDEAD; color:black;" | '''58140'''
| style="background:#FFDEAD; color:black;" | '''33984'''
| style="background:#FFDEAD; color:black;" | '''5040'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''8'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''494'''
| style="background:#FFDEAD; color:black;" | '''19950'''
| style="background:#FFDEAD; color:black;" | '''195800'''
| style="background:#FFDEAD; color:black;" | '''644020'''
| style="background:#FFDEAD; color:black;" | '''785304'''
| style="background:#FFDEAD; color:black;" | '''341136'''
| style="background:#FFDEAD; color:black;" | '''40320'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''9'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''1004'''
| style="background:#FFDEAD; color:black;" | '''67260'''
| style="background:#FFDEAD; color:black;" | '''1062500'''
| style="background:#FFDEAD; color:black;" | '''5765500'''
| style="background:#FFDEAD; color:black;" | '''12440064'''
| style="background:#FFDEAD; color:black;" | '''11026296'''
| style="background:#FFDEAD; color:black;" | '''3733920'''
| style="background:#FFDEAD; color:black;" | '''362880'''
| style="background:#FFDEAD; color:red;" | '''0'''
|}

==Примечания==
<references/>

==Источники информации==
<references/>
*[http://en.wikipedia.org/wiki/Eulerian_number Eulerian number — Wikipedia]
*[http://oeis.org/wiki/Eulerian_numbers Треугольник чисел Эйлера I рода — OEIS Wiki]
*[http://www.mathpages.com/home/kmath012/kmath012.htm Eulerian number — Math Pages]
*[http://mathworld.wolfram.com/EulerianNumber.html Числа Эйлера — Wolfram Mathworld]
*[http://www-personal.umich.edu/~mconger/andkpaper.pdf A Refinement of the Eulerian numbers]
*[http://arxiv.org/pdf/math/0607715.pdf Доказательство свойства о взаимосвязи чисел Эйлера I рода и объема сечений гиперкуба]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Комбинаторика ]]

Числа Эйлера I и II рода

2016-01-19T19:43:24Z

Nikitaevg: Добавлено доказательство леммы. Внесены мелкие поправки.

==Числа Эйлера I рода==
'''''Числа Эйлера I рода''''' (англ. ''Eulerian numbers'') — количество [[Комбинаторные объекты|перестановок]] чисел от <tex>1</tex> до <tex>n</tex> таких, что в каждой из них существует ровно <tex>m</tex> подъемов. Числа Эйлера I рода обозначают как <tex dpi=190>\langle{n\atop m}\rangle </tex> или же <tex>A(n, m)</tex>.
{{Определение
|definition=
Пусть <tex>a</tex> и <tex>b</tex> — соседние элементы некоторой перестановки порядка <tex>n</tex> причем <tex>a < b</tex>. Тогда пара <tex>(a, b)</tex> называется '''подъемом''' (англ. ''ascent'') данной перестановки.
}}

===Вывод рекуррентной формулы===
Пусть у нас есть некая перестановка <tex> \pi = \pi_1, \pi_2...\pi_{n-1} </tex>. Тогда операцией вставки элемента с номером <tex>n</tex> в какую-либо из позиций мы получим <tex>n</tex> перестановок вида <tex>\theta = \theta_1, \theta_2...\theta_p, n, \theta_q...\theta_{n-1}</tex>. Далее рассмотрим два случая:

# Количество подъемов в перестановке <tex>\theta</tex> равно количеству подъемов в <tex>\pi</tex>. Этого можно добиться, вставляя элемент <tex>n</tex> на самое первое место в <tex>\theta</tex> (всего <tex dpi=190>\langle{n\atop m}\rangle </tex> возможностей) или перед последним последним элементом каждого подъема (еще <tex>m \times </tex><tex dpi=190> \langle{n\atop m}\rangle </tex> раз).
# Количество подъемов в новой перестановке на один больше предыдущего количества. Этого эффекта добиваемся вставкой элемента <tex>n</tex> во все места, не подходящие по критерию первого пункта. Таких вставок, как не трудно догадаться, можно совершить <tex>(n - m)</tex><tex dpi=190>\langle{n\atop m}\rangle</tex>.

Тогда рекуррентная формула имеет вид:

:<tex dpi=190>\left\langle{n\atop m}\right\rangle</tex> <tex> = (m + 1)</tex> <tex dpi=190>\left\langle{n - 1\atop m}\right\rangle</tex> <tex> + (n - m)</tex> <tex dpi=180>\left\langle{n - 1\atop m - 1}\right\rangle</tex>

Примем также следующее начальное значение:
:<tex dpi=190>\left\langle{0\atop m}\right\rangle</tex> <tex> = [m = 0]</tex><ref>http://ru.wikipedia.org/wiki/%D0%9D%D0%BE%D1%82%D0%B0%D1%86%D0%B8%D1%8F_%D0%90%D0%B9%D0%B2%D0%B5%D1%80%D1%81%D0%BE%D0%BD%D0%B0 нотация Айверсона</ref>.

===Пример===
Рассмотрим все перестановки порядка <tex>4</tex>, в которых есть ровно <tex>2</tex> подъема (в квадратных скобках один или больше подъемов подряд):
:<tex dpi=190> \left\langle{4\atop 2}\right\rangle</tex> <tex> = 11:
[124]3,
[13][24],
[134]2,
[14][23],
2[134],
[23][14],
[23][41],
[24][13],
3[124],
[34][12],
4[123],
</tex>

Согласно алгоритму вывода рекуррентной формулы мы можем добавить <tex>4</tex> в следующие позиции всех перестановок порядка <tex>3</tex> с двумя подъемами, не увеличив количество подъемов:

:<tex dpi=190>
\left\langle{3\atop 2}\right\rangle</tex> <tex> = 1:
[123] \Rightarrow (4)[123], [1(4)][23], [12(4)]3
</tex>

Далее рассмотрим все перестановки порядка <tex>3</tex> с одним подъемом, причем операцией вставки <tex>4</tex> мы будем увеличивать количество перестановок на <tex>1</tex>:

:<tex dpi=190> \left\langle{3\atop 1}\right\rangle</tex> <tex> = 4:</tex>

:<tex>[13]2 \Rightarrow [13(4)]2, [13][2(4)];</tex>

:<tex>2[13] \Rightarrow [2(4)][13], 2[13(4)];</tex>

:<tex>[23]1 \Rightarrow [23(4)]1, [23][1(4)];</tex>

:<tex>3[12] \Rightarrow [3(4)][12], 3[12(4)];</tex>

Таким образом мы убеждаемся в верности формулы:

:<tex dpi=190> \left\langle{4\atop 2}\right\rangle</tex> <tex> = (2 + 1)</tex> <tex dpi=190>\left\langle{3\atop 2}\right\rangle</tex> <tex> + (4 - 2)</tex> <tex dpi=190>\left\langle{3\atop 1}\right\rangle</tex> <tex> = 11;</tex>

===Треугольник чисел Эйлера I рода===
На значениях <tex>n = m</tex> чисел Эйлера I рода можно построить массив <tex>n \times m</tex>, нижнедиагональная часть которого названа треугольником чисел Эйлера I рода.

::{| class="number_triangle"

|- align="center"
| style="background:white; color:black; width:50px;" |
| style="background:white; color:black; width:50px;" | '''''m = 0'''''
| style="background:white; color:black; width:50px;" | '''''1'''''
| style="background:white; color:black; width:50px;" | '''''2'''''
| style="background:white; color:black; width:50px;" | '''''3'''''
| style="background:white; color:black; width:50px;" | '''''4'''''
| style="background:white; color:black; width:50px;" | '''''5'''''
| style="background:white; color:black; width:50px;" | '''''6'''''
| style="background:white; color:black; width:50px;" | '''''7'''''
| style="background:white; color:black; width:50px;" | '''''8'''''
| style="background:white; color:black; width:50px;" | '''''9'''''
|- align="center"
| style="background:white; color:black;" | '''''n = 0'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''

|- align="center"
| style="background:white; color:black;" | '''''1'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''2'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''3'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''4'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''4'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''11'''
| style="background:#FFDEAD; color:black;" | '''11'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''5'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''26'''
| style="background:#FFDEAD; color:black;" | '''66'''
| style="background:#FFDEAD; color:black;" | '''26'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''6'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''57'''
| style="background:#FFDEAD; color:black;" | '''302'''
| style="background:#FFDEAD; color:black;" | '''302'''
| style="background:#FFDEAD; color:black;" | '''57'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''7'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''120'''
| style="background:#FFDEAD; color:black;" | '''1191'''
| style="background:#FFDEAD; color:black;" | '''2416'''
| style="background:#FFDEAD; color:black;" | '''1191'''
| style="background:#FFDEAD; color:black;" | '''120'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''8'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''247'''
| style="background:#FFDEAD; color:black;" | '''4293'''
| style="background:#FFDEAD; color:black;" | '''15619'''
| style="background:#FFDEAD; color:black;" | '''15619'''
| style="background:#FFDEAD; color:black;" | '''4293'''
| style="background:#FFDEAD; color:black;" | '''247'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''9'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''502'''
| style="background:#FFDEAD; color:black;" | '''14608'''
| style="background:#FFDEAD; color:black;" | '''88234'''
| style="background:#FFDEAD; color:black;" | '''156190'''
| style="background:#FFDEAD; color:black;" | '''88234'''
| style="background:#FFDEAD; color:black;" | '''14608'''
| style="background:#FFDEAD; color:black;" | '''502'''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
|}

===Явные формулы===
:<tex dpi=190>\left\langle{n\atop m}\right\rangle</tex> <tex> = \sum\limits_{j=1}^{m+1} (-1)^{m-j+1} {n+1\choose m-j+1}j^{n}</tex>
:<tex dpi=190>\left\langle{n\atop m}\right\rangle</tex> <tex> = \sum\limits_{j=0}^{m}(-1)^j {n+1\choose j} (m+1-j)^n</tex>

===Связь чисел Эйлера I рода с сечениями гиперкубов===
{{Теорема
|statement=
Число <tex dpi=190>\frac{1}{n!}\left\langle{n\atop m}\right\rangle</tex> выражает объем части <tex>n</tex>-мерного единичного гиперкуба, ограниченного гиперплоскостями <tex>x_1+x_2+\dots+x_n=m</tex> и <tex>x_1+x_2+\dots+x_n=m-1</tex>;
|proof=
Для доказательства этого факта нам потребуется следующая теорема:
{{Теорема
|about=Об объемах сечений <tex>n</tex>-мерных гиперкубов полупространствами
|statement=

Пусть <tex>w \in \mathbb{R}</tex> — вектор с ненулевыми компонентами (<tex>w = {w_1, w_2 ... w_n}</tex>), а <tex>z \in \mathbb{R}_+</tex>. Тогда верно следующее равенство:

<tex dpi = "140">\mathrm{Vol}_{n}(G^n_{w,z} \cap I^{n}) = \frac{1}{n! \prod\limits_{i=1}^{n}w_i} \sum\limits_{K \subseteq [n]} (-1)^{|K|}(z-w \cdot 1_K)^n_+</tex>

*<tex>G_{w, z}^{n} := \{x \in \mathbb{R}^{n} : (w \cdot x) \le z \}</tex> — полупространство;
*<tex>I^n := [0,1]^n</tex>;
*<tex>[n] := \{1,2...n\}</tex>;
*<tex>1_K</tex>, где <tex>K</tex> — подмножество <tex>\{1,2...n\}</tex>, {{---}} вектор, где значения координат с номерами, входящими в <tex>K</tex>, равны <tex>1</tex>, а остальные {{---}} нули;
*Для <tex>r \in \mathbb{R}</tex> и <tex>n \in \mathbb{N}</tex> : <tex>r^n_+ := (\max{\{r, 0\}})^n</tex>.

|proof=С доказательством можно ознакомиться по ссылке <ref>http://arxiv.org/pdf/math/0607715.pdf</ref>.
}}

[[Файл:HypercubeEuler2_2.png|200px|thumb|m = 2, n = 1. V = 1/2]]
[[Файл:HypercubeEuler3.png|200px|thumb|m = 3, n = 2. V = 1/6]]
Рассмотрим пересечение гиперкуба полупространством <tex>G^n_{1_{[n]},m}</tex>. Вектор <tex>1_{[n]}</tex> (все координаты которого равны единицы) появляется здесь ввиду того, как мы определили в формулировке секущие гиперплоскости (<tex>x_1+x_2+...+x_n = m | m+1</tex>) {{---}} это вектор нормали к <tex>\mathrm{G}</tex>. Очевидно, что при данном значении вектора произведение <tex>\prod\limits_{i=1}^{n}w_i</tex> равно единице (вектор <tex>w_i</tex> тут {{---}} единичный вектор <tex>1_{[n]}</tex>, то есть рассматривается произведение всех его координат {{---}} единиц). Рассмотрим выражение, стоящее под знаком суммы. При итерации по подмножествам <tex>[n]</tex> равной мощности будут получаться одинаковые слагаемые, так как выражение <tex>(-1)^{|K|}(z-w \cdot 1_K)^n_+</tex> зависит лишь от мощности итерируемого в сумме подмножества <tex>K</tex> {{---}} скалярное произведение <tex>w \cdot 1_K</tex> одинаково за счет того лишь факта, что оно вычисляется как сумма произведений соответствующих координат, где ровно <tex>n - |K|</tex> их обращаются в ноль. Такое скалярное произведение будет равно мощности <tex>K</tex>. Заменим итератор суммы значением мощности множества <tex>K</tex>. Также ограничим верхний индекс суммирования значением <tex>m+1</tex>, так как при больших значениях <tex>j</tex> слагаемое будет обращаться в ноль (<tex>r^n_+</tex>). Отсюда имеем <tex>{n \choose j}</tex> таких одинаковых слагаемых, где <tex>j = |K|</tex>.

Тогда перейдем от первоначальной формулировки теоремы к следующей:
:<tex>\mathrm{Vol}_{n}(G^n_{1_{[n]},m} \cap I^{n}) = \frac{1}{n!}\sum\limits_{j = 0}^{m + 1} (-1)^{j}{n \choose j}(m-j)^n</tex>

Положим <tex>W_n^m</tex> — фигура, образованная сечением гиперкуба <tex>[0,1]^{n}</tex> плоскостями <tex>\sum\limits_{i=1}^{n} x_{i} = m</tex> и <tex>\sum\limits_{i=1}^{n} x_{i} = m+1</tex>.
:<tex>W_n^m := \{ x \in \mathbb{R} : m \le x \cdot 1_{[n]} \le m+1 \} \cap I^{n}</tex>

Тогда перейдем к следующему равенству:

:<tex>\mathrm{Vol}_{n}(W_n^m) = \mathrm{Vol}_n(G_{1_{[n]},m+1}^{n} \cap I^n) - \mathrm{Vol}_n(G_{1_{[n]},m}^{n} \cap I^n)</tex>
:<tex>= \frac{1}{n!}[\sum\limits_{j=0}^{m+1}(-1)^{j}{n \choose j}(m+1-j)^{n} - \sum\limits_{j=0}^{m}(-1)^{j}{n \choose j}(m-j)^{n}]</tex>
:<tex> = \frac{1}{n!}\sum\limits_{j=0}^{m+1}(-1)^j{n+1 \choose j}(m+1-j)^n</tex>
:<tex> = \frac{1}{n!}\sum\limits_{j=0}^{m}(-1)^j{n+1 \choose j}(m+1-j)^n</tex> (элемент суммы с номером <tex>j=m+1</tex> обращается в ноль)
:<tex> = </tex> <tex dpi=190>\frac{1}{n!}\left\langle{n\atop m}\right\rangle</tex> (вторая явная формула)

}}

===Свойства===

# Нетрудно увидеть, что каждый ряд ненулевых значений симметричен относительно своей середины, то есть:
#:<tex dpi=190>\left\langle{n\atop m}\right\rangle = \left\langle{n\atop (n-1) - k}\right\rangle</tex><tex>,\ n \ge 1,\ 0 \le k \le n-1. \, </tex>
# Сумма всех значений каждого ряда равна <tex> n! </tex>:
#:<tex>\sum\limits_{m=0}^{n}</tex><tex dpi=190> \left\langle{n\atop m}\right\rangle</tex> <tex> = n!,\ n \ge 0, \,</tex>
# Связь чисел Эйлера I рода с числом сочетаний:
#:<tex>\sum\limits_{m=0}^n (-1)^m </tex><tex dpi=190>{\left\langle{n\atop m}\right\rangle}</tex> <tex>{n-1\choose m}^{-1}=0.</tex>
# Вероятность того, что сумма <tex>n</tex> независимых равномерно распределённых в отрезке <tex>[0,1]</tex> переменных лежит между <tex>m-1</tex> и <tex>m</tex> равна <tex>\frac{1}{n!}\left\langle{n\atop m}\right\rangle</tex>.

==Числа Эйлера II рода==
'''''Числа Эйлера II рода''''' (англ. ''Eulerian numbers of the second kind'') — количество перестановок мультимножества от <tex>1</tex> до <tex>n</tex> вида <tex>\{1,1,2,2..n,n\}</tex>, обладающих свойством "все элементы перестановки, встречающиеся между двумя вхождниями <tex>z</tex> для любого <tex>z</tex>, больше, чем <tex>z</tex>", таких, что в каждой из них существует ровно <tex>m</tex> подъемов. Числа Эйлера II рода обозначаются как <tex dpi = "190"> \scriptstyle \left\langle \!\! \left\langle {n \atop m} \right\rangle \!\! \right\rangle </tex>

'''Пример'''

Рассмотрим <tex> n = 3</tex>. Тогда существует <tex>15</tex> перестановок такого вида, среди которых одна не имеет подъемов, <tex>8</tex> штук имеют всего <tex>1</tex> подъем, и <tex>6</tex> перестановок имеют <tex>2</tex> подъема:

:<tex> 332211,\; </tex>
:<tex> 221[13]3,\; 22[13]31,\; 2[23]311,\; [23]3211,\; 1[13]322,\; [13]3221,\; 331[12]2,\; 33[12]21, </tex>
:<tex>1[12][23]3,\; [12]2[13]3,\; 1[123]32,\; [123]321,\; [13]3[12]2,\; [12][23]31. </tex>

{{Лемма
|statement=Количество перестановок мультимножества <tex>\{1,1,2,2..n,n\}</tex> со свойством "все элементы перестановки, встречающиеся между двумя вхождниями <tex>z</tex> для любого <tex>z</tex>, больше, чем
<tex dpi="130">z</tex>" равно двойному факториалу <tex dpi="130">(2n-1)!!</tex>.
|proof = Докажем лемму методом математической индукции.
*'''База'''. Для <tex>n=1</tex> очевидно, что существует только одна такая перестановка.
*'''Переход'''. Рассмотрим какую-нибудь перестановку длины <tex>2n</tex>. Таких перестановок <tex>(2n-1)!!</tex>. Теперь докажем, что перестановок длины <tex>2(n+1)</tex> будет <tex>(2(n+1)-1)!!</tex>. Попробуем вставить два числа <tex>n + 1</tex>. Очевидно, что их нельзя вставить не на соседние места, так как в таком случае между ними точно будут меньшие элементы. Но их можно вставить в любые два соседних места, так как они больше всех чисел в перестановке, а значит они не нарушат свойства для других элементов. Таким образом два новых элемента можно вставить в <tex>2n+1</tex> место. В итоге перестановок длины <tex>2(n+1)</tex> будет <tex>(2n-1)!!\cdot (2n+1)=(2n+1)!!=(2(n+1)-1)!!</tex>.
}}

===Рекуррентная формула===
Числа Эйлера II рода можно выразить рекурсивно следующим образом:
:<tex dpi=190> \left\langle \!\! \left\langle {n \atop m} \right\rangle \!\! \right\rangle</tex> <tex> = (2n-m-1) </tex> <tex dpi=180>\left\langle \!\! \left\langle {n-1 \atop m-1} \right\rangle \!\! \right\rangle</tex> <tex> + (m+1) </tex> <tex dpi=190>\left\langle \!\! \left\langle {n-1 \atop m} \right\rangle \!\! \right\rangle, </tex>

С начальным условием для <tex>n = 0</tex>:
:<tex dpi=190> \left\langle \!\! \left\langle {0 \atop m} \right\rangle \!\! \right\rangle</tex> <tex> = [m=0]. </tex>

===Треугольник чисел Эйлера II рода===
Значения чисел Эйлера II рода для <tex>0 \le n \le m \le 9</tex> представлены в данном массиве. Нижнедиагональная его часть называется треугольником чисел Эйлера II рода.

:::{| class="number_triangle"

|- align="center"
| style="background:white; color:black; width:50px;" |
| style="background:white; color:black; width:50px;" | '''''m = 0'''''
| style="background:white; color:black; width:50px;" | '''''1'''''
| style="background:white; color:black; width:50px;" | '''''2'''''
| style="background:white; color:black; width:50px;" | '''''3'''''
| style="background:white; color:black; width:50px;" | '''''4'''''
| style="background:white; color:black; width:50px;" | '''''5'''''
| style="background:white; color:black; width:50px;" | '''''6'''''
| style="background:white; color:black; width:50px;" | '''''7'''''
| style="background:white; color:black; width:50px;" | '''''8'''''
| style="background:white; color:black; width:50px;" | '''''9'''''

|- align="center"
| style="background:white; color:black;" | '''''n = 0'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''

|- align="center"
| style="background:white; color:black;" | '''''1'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''2'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''2'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''3'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''8'''
| style="background:#FFDEAD; color:black;" | '''6'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''4'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''22'''
| style="background:#FFDEAD; color:black;" | '''58'''
| style="background:#FFDEAD; color:black;" | '''24'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''5'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''52'''
| style="background:#FFDEAD; color:black;" | '''328'''
| style="background:#FFDEAD; color:black;" | '''444'''
| style="background:#FFDEAD; color:black;" | '''120'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''6'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''114'''
| style="background:#FFDEAD; color:black;" | '''1452'''
| style="background:#FFDEAD; color:black;" | '''4400'''
| style="background:#FFDEAD; color:black;" | '''3708'''
| style="background:#FFDEAD; color:black;" | '''720'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''7'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''240'''
| style="background:#FFDEAD; color:black;" | '''5610'''
| style="background:#FFDEAD; color:black;" | '''32120'''
| style="background:#FFDEAD; color:black;" | '''58140'''
| style="background:#FFDEAD; color:black;" | '''33984'''
| style="background:#FFDEAD; color:black;" | '''5040'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''8'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''494'''
| style="background:#FFDEAD; color:black;" | '''19950'''
| style="background:#FFDEAD; color:black;" | '''195800'''
| style="background:#FFDEAD; color:black;" | '''644020'''
| style="background:#FFDEAD; color:black;" | '''785304'''
| style="background:#FFDEAD; color:black;" | '''341136'''
| style="background:#FFDEAD; color:black;" | '''40320'''
| style="background:#FFDEAD; color:red;" | '''0'''
| style="background:#FFDEAD; color:red;" | '''0'''
|- align="center"
| style="background:white; color:black;" | '''''9'''''
| style="background:#FFDEAD; color:black;" | '''1'''
| style="background:#FFDEAD; color:black;" | '''1004'''
| style="background:#FFDEAD; color:black;" | '''67260'''
| style="background:#FFDEAD; color:black;" | '''1062500'''
| style="background:#FFDEAD; color:black;" | '''5765500'''
| style="background:#FFDEAD; color:black;" | '''12440064'''
| style="background:#FFDEAD; color:black;" | '''11026296'''
| style="background:#FFDEAD; color:black;" | '''3733920'''
| style="background:#FFDEAD; color:black;" | '''362880'''
| style="background:#FFDEAD; color:red;" | '''0'''
|}

==Примечания==
<references/>

==Источники информации==
<references/>
*[http://en.wikipedia.org/wiki/Eulerian_number Eulerian number — Wikipedia]
*[http://oeis.org/wiki/Eulerian_numbers Треугольник чисел Эйлера I рода — OEIS Wiki]
*[http://www.mathpages.com/home/kmath012/kmath012.htm Eulerian number — Math Pages]
*[http://mathworld.wolfram.com/EulerianNumber.html Числа Эйлера — Wolfram Mathworld]
*[http://www-personal.umich.edu/~mconger/andkpaper.pdf A Refinement of the Eulerian numbers]
*[http://arxiv.org/pdf/math/0607715.pdf Доказательство свойства о взаимосвязи чисел Эйлера I рода и объема сечений гиперкуба]

[[Категория: Дискретная математика и алгоритмы]]

[[Категория: Комбинаторика ]]

Полином Жегалкина

2016-01-18T07:49:54Z

Nikitaevg: /* Преобразование Мёбиуса */

'''Полином Жегалкина''' (англ. ''Zhegalkin polynomial'') — полином с коэффициентами вида <tex>0</tex> и <tex>1</tex>, где в качестве произведения берётся конъюнкция, а в качестве сложения исключающее или. Полином был предложен в 1927 году И. И. Жегалкиным в качестве средства для представления [[Определение булевой функции|функций булевой логики]]. Полином Жегалкина имеет следующий вид:

<tex>P = a_{000...000} \oplus a_{100...0} x_1 \oplus a_{010...0} x_2 \oplus ... \oplus a_{00...01} x_n \oplus a_{110...0} x_1 x_2 \oplus ... \oplus a_{00...011} x_{n-1} x_n \oplus ... \oplus a_{11..1} x_1 x_2 ... x_n </tex>

== Полнота ==

По [[Теорема Поста о полной системе функций|теореме Поста]], чтобы система булевых функций была полной, надо, чтобы в ней существовали

#Хотя бы одна функция, не сохраняющая <tex>0</tex>;
#Хотя бы одна функция, не сохраняющая <tex>1</tex>;
#Хотя бы одна нелинейная функция;
#Хотя бы одна немонотонная функция;
#Хотя бы одна несамодвойственная функция.

Исходя из этого, система функций <tex>\bigl\langle \wedge, \oplus, 1 \bigr\rangle</tex> является полной:

{| class="wikitable" style="width:8cm" border="1"
|-align="center" bgcolor=#EEEEFF
!<tex>x_0</tex>||<tex>x_1</tex>||<tex>\dots</tex>||<tex>x_n</tex>
|<tex>1</tex>||<tex>\land</tex>||<tex>\oplus</tex>
|-align="center"
!<tex>0</tex>||<tex>0</tex>||<tex>\dots</tex>||<tex>0</tex>
|<tex>1</tex>||<tex>0</tex>||<tex>0</tex>
|-align="center"
!<tex>1</tex>||<tex>0</tex>||<tex>\dots</tex>||<tex>0</tex>
|<tex>1</tex>||<tex>0</tex>||<tex>1</tex>
|-align="center"
!<tex>\vdots</tex>||<tex>\vdots</tex>||<tex>\vdots</tex>||<tex>\vdots</tex>
|<tex>\vdots</tex>||<tex>\vdots</tex>||<tex>\vdots</tex>
|-align="center"
!<tex>1</tex>||<tex>1</tex>||<tex>\dots</tex>||<tex>1</tex>
|<tex>1</tex>||<tex>1</tex>||<tex>0</tex>
|-align="center"
!colspan="4"|Сохраняет 0
|<tex>0</tex>||<tex>1</tex>||<tex>1</tex>
|-align="center"
!colspan="4"|Сохраняет 1
|<tex>1</tex>||<tex>1</tex>||<tex>0</tex>
|-align="center"
!colspan="4"|Самодвойственная
|<tex>0</tex>||<tex>0</tex>||<tex>0</tex>
|-align="center"
!colspan="4"|Монотонная
|<tex>1</tex>||<tex>1</tex>||<tex>0</tex>
|-align="center"
!colspan="4"|Линейная
|<tex>1</tex>||<tex>0</tex>||<tex>1</tex>
|}

На основе этой системы и строятся полиномы Жегалкина.

== Существование и единственность представления (теорема Жегалкина) ==
{{Теорема
|author=Жегалкина
|statement=
Каждая булева функция единственным образом представляется в виде полинома Жегалкина.
|proof=
Заметим, что различных булевых функций от <tex>n</tex> переменных <tex>2^{2^n}</tex> штук. При этом конъюнкций вида <tex>x_{i_1} \ldots x_{i_k}</tex> существует ровно <tex>2^n</tex>, так как из <tex>n</tex> возможных сомножителей каждый или входит в конъюнкцию, или нет. В полиноме у каждой такой конъюнкции стоит <tex>0</tex> или <tex>1</tex>, то есть существует <tex>2^{2^n}</tex> различных полиномов Жегалкина от <tex>n</tex> переменных.

Теперь достаточно лишь доказать, что различные полиномы реализуют различные функции. Предположим противное. Тогда приравняв два различных полинома и перенеся один из них в другую часть равенства, получим полином, тождественно равный нулю и имеющий ненулевые коэффициенты. Тогда рассмотрим слагаемое с единичным коэффициентом наименьшей длины, то есть с наименьшим числом переменных, входящих в него (любой один, если таких несколько). Подставив единицы на места этих переменных, и нули на места остальных, получим, что на этом наборе только одно это слагаемое принимает единичное значение, то есть нулевая функция на одном из наборов принимает значение 1. Противоречие. Значит, каждая булева функция реализуется полиномом Жегалкина единственным образом.
}}

== Построение полинома Жегалкина ==

Существует несколько способов построения полинома Жегалкина.

=== По таблице истинности ===
Пусть для функции <tex>f(x_1,x_2,\dots,x_n)</tex> задана таблица истинности. Запишем сначала данную функцию в виде полинома Жегалкина с неопределёнными коэффициентами. Затем по очереди подставляем всевозможные наборы в порядке увеличения количества единиц и находим коэффициенты с учётом того, что <tex> a \oplus 1 = \bar{a}</tex>, а <tex> a \oplus 0 = a</tex>. За каждую подстановку находим только один коэффициент.

'''Пример:'''
Дана функция <tex>f(x_1,x_2,x_3,x_4)</tex> и её таблица истинности:

{| class="wikitable" style="width:8cm" border="1"
|-
!class="dark" style="font-weight:normal"| <tex>x_1</tex>
!class="dark" style="font-weight:normal"| <tex>x_2</tex>
!class="dark" style="font-weight:normal"| <tex>x_3</tex>
!class="dark" style="font-weight:normal"| <tex>x_4</tex>
!class="dark" style="font-weight:normal"| <tex>f(x_1,x_2,x_3,x_4)</tex>
|- align="center"
||0||0||0||0||0
|- align="center"
||0||0||0||1||0
|- align="center"
||0||0||1||0||0
|- align="center"
||0||0||1||1||0
|- align="center"
||0||1||0||0||0
|- align="center"
||0||1||0||1||0
|- align="center"
||0||1||1||0||1
|- align="center"
||0||1||1||1||0
|- align="center"
||1||0||0||0||1
|- align="center"
||1||0||0||1||0
|- align="center"
||1||0||1||0||0
|- align="center"
||1||0||1||1||1
|- align="center"
||1||1||0||0||1
|- align="center"
||1||1||0||1||0
|- align="center"
||1||1||1||0||1
|- align="center"
||1||1||1||1||0
|}
Построим для неё полином Жегалкина:

<tex>f(x_1,x_2,x_3,x_4) = a_{0000} \oplus a_{1000} x_1 \oplus a_{0100} x_2 \oplus a_{0010} x_3 \oplus a_{0001} x_4 \oplus a_{1100} x_1 x_2 \oplus a_{1010} x_1 x_3 \oplus a_{1001} x_1 x_4 \oplus a_{0110} x_2 x_3 \oplus a_{0101} x_2 x_4 \oplus a_{0011} x_3 x_4 \oplus a_{1110} x_1 x_2 x_3 \oplus a_{1101} x_1 x_2 x_4 \oplus a_{1011} x_1 x_3 x_4 \oplus a_{0111} x_2 x_3 x_4 \oplus a_{1111} x_1 x_2 x_3 x_4</tex>

Так как <tex>f(0,0,0,0) = 0</tex>, то <tex>a_{0000} = 0</tex>.
Далее подставляем все остальные наборы в порядке возрастания числа единиц, подставляя вновь полученные значения в следующие формулы:

<tex>f(1,0,0,0) = a_{0000} \oplus a_{1000} = 1 \Rightarrow a_{1000} = 1</tex>

<tex>f(0,1,0,0) = a_{0000} \oplus a_{0100} = 0 \Rightarrow a_{0100} = 0</tex>

<tex>f(0,0,1,0) = a_{0000} \oplus a_{0010} = 0 \Rightarrow a_{0010} = 0</tex>

<tex>f(0,0,0,1) = a_{0000} \oplus a_{0001} = 0 \Rightarrow a_{0001} = 0</tex>

<tex>f(1,1,0,0) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{1100} = 1 \Rightarrow a_{1100} = 0</tex>

<tex>f(1,0,1,0) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{1010} = 0 \Rightarrow a_{1010} = 1</tex>

<tex>f(1,0,0,1) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{1001} = 0 \Rightarrow a_{1001} = 1</tex>

<tex>f(0,1,1,0) = a_{0000} \oplus a_{0100} \oplus a_{0010} \oplus a_{0110} = 1 \Rightarrow a_{0110} = 1</tex>

<tex>f(0,1,0,1) = a_{0000} \oplus a_{0100} \oplus a_{0001} \oplus a_{0101} = 0 \Rightarrow a_{0101} = 0</tex>

<tex>f(0,0,1,1) = a_{0000} \oplus a_{0010} \oplus a_{0001} \oplus a_{0011} = 0 \Rightarrow a_{0011} = 0</tex>

<tex>f(1,1,1,0) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{0010} \oplus a_{1100} \oplus a_{1010} \oplus a_{0110} \oplus a_{1110} = 1 \Rightarrow a_{1110} = 0</tex>

<tex>f(1,1,0,1) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{0001} \oplus a_{1100} \oplus a_{1001} \oplus a_{0101} \oplus a_{1101} = 0 \Rightarrow a_{1101} = 0</tex>

<tex>f(1,0,1,1) = a_{0000} \oplus a_{1000} \oplus a_{0010} \oplus a_{0001} \oplus a_{1010} \oplus a_{1001} \oplus a_{0011} \oplus a_{1011} = 1 \Rightarrow a_{1011} = 0</tex>

<tex>f(0,1,1,1) = a_{0000} \oplus a_{0100} \oplus a_{0010} \oplus a_{0001} \oplus a_{0110} \oplus a_{0101} \oplus a_{0011} \oplus a_{0111} = 0 \Rightarrow a_{0111} = 1</tex>

<tex>f(1,1,1,1) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{0010} \oplus a_{0001} \oplus a_{1100} \oplus a_{1010} \oplus a_{1001} \oplus a_{0110} \oplus a_{0101} \oplus a_{0011} \oplus a_{1110} \oplus a_{1101} \oplus a_{1011} \oplus a_{0111} \oplus a_{1111} = 0 \Rightarrow a_{1111} = 1</tex>

Таким образом, полином Жегалкина выглядит так:

<tex>f(x_1,x_2,x_3,x_4) = x_1 \oplus x_1 x_3 \oplus x_1 x_4 \oplus x_2 x_3 \oplus x_2 x_3 x_4 \oplus x_1 x_2 x_3 x_4</tex>

=== Преобразование [[Определение_булевой_функции#Дизъюнктивная нормальная форма (ДНФ)|дизъюнктивной нормальной формы]] ===
Этот способ основан на том, что <tex> X \oplus 1 = \bar{X} </tex>. Если функция задана в виде ДНФ, то можно сначала убрать дизъюнкцию, используя правило де Моргана, а все отрицания заменить прибавлением единицы по модулю два, после чего раскрыть скобки по обычным правилам, при этом учитывая, что четное число одинаковых слагаемых равно нулю (так как <tex> X \oplus X = 0 </tex>), а нечетное число одинаковых слагаемых равно одному такому слагаемому. Либо же можно заменить дизъюнкцию по следующему правилу:
<tex> A \lor B = AB \oplus A \oplus B </tex>   <tex> (1) </tex>.

Если функция задана в СДНФ, то так как при любых значениях входных переменных в единицу обращается не более одного члена выражения, то достаточно просто заменить все дизъюнкции исключающим ИЛИ.

'''Пример:'''
Дана функция в ДНФ <tex> f(x_1,x_2,x_3,x_4) = (x_1 \land x_2 \land \neg x_3 \land x_4) \lor (\neg x_1 \land \neg x_4) \lor (x_1 \land x_2) \lor x_2 </tex>, построим полином Жегалкина.

Запишем функцию так:

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_2 \neg x_3 x_4 + \neg x_1 \neg x_4 + x_1 x_2 + x_2</tex>;

Сгруппируем слагаемые и воспользуемся преобразованием (1):

<tex>f(x_1,x_2,x_3,x_4) = (x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4 \oplus x_1 x_2 \neg x_3 x_4 \neg x_1 \neg x_4) + (x_1 x_2 \oplus x_2 \oplus \oplus x_1 x_2 x_2)</tex>

Воспользуемся свойствами конъюнкции <tex>A \land A = A</tex> и <tex>\neg A \land A = 0</tex>, а также тем, что <tex>A \oplus A = 0</tex>, и упростим выражение:

<tex>f(x_1,x_2,x_3,x_4) = (x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4) + x_2</tex>

Ещё раз воспользуемся преобразованием (1):

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4 \oplus x_2 \oplus (x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4) x_2</tex>

Раскроем скобку по алгебраическим правилам:

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4 \oplus x_2 \oplus x_1 x_2 x_2 \neg x_3 x_4 \oplus \neg x_1 x_2 \neg x_4</tex>

Снова воспользуемся свойствами конъюнкции и исключающего ИЛИ:

<tex>f(x_1,x_2,x_3,x_4) = \neg x_1 \neg x_4 \oplus x_2 \oplus \neg x_1 x_2 \neg x_4</tex>

Заменим отрицание на прибавление <tex>1</tex>:

<tex>f(x_1,x_2,x_3,x_4) = (x_1 \oplus 1) (x_4 \oplus 1) \oplus x_2 \oplus (x_1 \oplus 1) x_2 (x_4 \oplus 1)</tex>

Раскроем скобки:

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_4 \oplus x_1 \oplus x_4 \oplus 1 \oplus x_2 \oplus x_1 x_2 x_4 \oplus x_1 x_2 \oplus x_2 x_4 \oplus x_2</tex>

Выкинем парные слагаемые и получим окончательную формулу:

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_2 x_4 \oplus x_1 x_2 \oplus x_1 x_4 \oplus x_2 x_4 \oplus x_1 \oplus x_4 \oplus 1</tex>

=== Метод треугольника === 
Метод треугольника позволяет преобразовать таблицу истинности в полином Жегалкина путём построения вспомогательной треугольной таблицы в соответствии со следующими правилами:
# Строится полная таблица истинности, в которой строки идут в порядке возрастания двоичных кодов от <tex>000\dots00</tex> до <tex>111\dots11</tex>.
# Строится вспомогательная треугольная таблица, в которой первый столбец совпадает со столбцом значений функции в таблице истинности.
# Ячейка в каждом последующем столбце получается путём сложения по модулю 2 двух ячеек предыдущего столбца — стоящей в той же строке и строкой ниже.
# Столбцы вспомогательной таблицы нумеруются двоичными кодами в том же порядке, что и строки таблицы истинности.
# Каждому двоичному коду ставится в соответствие один из членов полинома Жегалкина в зависимости от позиций кода, в которых стоят единицы. Например, ячейке <tex>111</tex> соответствует член <tex>ABC</tex>, ячейке <tex>101</tex> — член <tex>AC</tex>, ячейке <tex>010</tex> — член <tex>B</tex>, ячейке <tex>000</tex> — член <tex>1</tex> и т.д.
# Если в верхней строке какого-либо столбца стоит единица, то соответствующий член присутствует в полиноме Жегалкина.

Фактически, этот метод является модификацией метода построения по таблице истинности, описанного выше. По сравнению с ним он удобнее тем, что расчёты занимают мало места и в них сложнее ошибиться, но метод треугольника требует бо́льшего количества операций.

Пример преобразования таблицы истинности в полином Жегалкина для функции трёх переменных <tex>P(A,B,C)</tex> показан на рисунке.

[[Файл:Преобразование таблицы истинности в полином Жегалкина методом треугольника.gif]]

Чтобы получить формулу, по которой рассчитывается какой-либо коэффициент, нужно из клетки, в которой он записан, пройтись всеми возможными путями влево, до столбца <tex>''P''</tex> таблицы истинности, делая ходы влево и влево-вниз, записать значения в конечных ячейках и сложить их все между собой по модулю 2.

Таким образом, в первом столбце сверху записан коэффициент <tex> a_0 = P(0,0,0) </tex>,

во втором — <tex> a_1 = P(0,0,0) \oplus P(0,0,1) </tex>,

в третьем — <tex> a_2 = P(0,0,0) \oplus P(0,0,1) \oplus P(0,0,1) \oplus P(0,1,0) = P(0,0,0) \oplus P(0,1,0) </tex>,

в четвёртом —

<tex> a_3 = P(0,0,0) \oplus P(0,0,1) \oplus P(0,0,1) \oplus P(0,0,1) \oplus P(0,1,0) \oplus P(0,1,0) \oplus P(0,1,0) \oplus P(0,1,1) = P(0,0,0) \oplus P(0,1,0) \oplus P(0,1,0) \oplus P(0,1,1), </tex>

и так далее, то есть при построении вспомогательной таблицы коэффициенты полинома просчитываются автоматически.

=== Преобразование Мёбиуса ===
Пусть задана [[Определение булевой функции|булева функция]] <tex>f: B^n \rightarrow B, \;\; B=\{ 0; 1 \}</tex>.
Любая булева функция представима в виде полинома Жегалкина, притом единственным образом.

Пусть <tex> i = (i_1, i_2, .. i_n), \;\; i_k \in \{0 ; 1\}</tex>, и введем обозначение <tex> x ^{i_k} \sim \left\{\begin{matrix} x, \;\; i_k=1
\\ 1, \;\; i_k=0
\end{matrix}\right. </tex>

Тогда полином Жегалкина можно записать как:
<tex> f(x) = \bigoplus\limits_i \alpha_i \cdot x_1^{i_1} \cdot x_2^{i_2} \cdot</tex><tex>\dots</tex><tex>\cdot x_n^{i_n}</tex>, где <tex>\alpha_i \in \{ 0; 1 \}</tex>.

Множество коэффициентов <tex>\{\alpha _i\}</tex> можно рассматривать как функцию <tex>\alpha</tex>, заданной на множестве индексов <tex> i = (i_1, i_2, \dots i_n)</tex>, то есть <tex>\alpha: i \mapsto \alpha_i</tex>.

Очевидно, функцию <tex> f </tex> можно записать и следующим образом: <tex> f(x) = \bigoplus \limits_i \alpha_i \cdot [x_1 , \; </tex> если <tex> \;\; i_1] \cdot [x_2 , \; </tex> если <tex> \;\; i_2] \cdot</tex><tex>\dots</tex><tex>\cdot [x_n , \; </tex> если <tex> \;\; i_n]</tex>.

Тут запись <tex>[x_k , \; </tex> если <tex> \; i_k]</tex> означает, что элелемент <tex> x_k </tex> присутствует в соответствующем члене полинома только если <tex> i_k = 1 </tex>.
Тогда если для какого-то <tex>x</tex>, <tex>i \succ x</tex>* ,то в слагаемом будет существовать хотя бы один множитель, равный нулю, и такое слагаемое на сумму не повлияет.
Отсюда ясно, что <tex> f(x) = \bigoplus \limits_{i \preceq x} \alpha_i </tex>  <tex> (2) </tex>
Найдем отображение <tex> f \mapsto \alpha</tex> (То есть такое, которое по заданной функции вычисляет значения всех коэффициентов).

<tex>*</tex> <tex>i \succ x</tex> обозначает, что <tex>x</tex> "меньше" <tex>i</tex> как последовательность бит

{{Теорема
|statement=Пусть задана функция <tex> f </tex>. Тогда функцию <tex> \alpha_x </tex> можно найти по формуле: <tex>\alpha_x = \bigoplus \limits_{j\preceq x} f(j)</tex>     <tex> (3) </tex>.
||proof=Докажем при помощи индукции по количеству единиц в векторе <tex> x </tex> ( иначе говоря, по сумме <tex>x_1+x_2+</tex><tex>\dots</tex><tex>+x_n</tex> ) и для удобства обозначим это количество единиц(сумму) <tex> wt(x) </tex>.

'''1)''' База: если <tex> x = 0 </tex>, то, очевидно <tex> f(0) = \alpha_0 </tex>

'''2)''' Пускай теорема справедлива для всех сумм <tex>wt(x) < k</tex>. Покажем, что в таком случае она верна и для <tex>wt(x) = k</tex>. По <tex> (2) </tex>, а далее по предположению индукции видим: <tex> f(x) = \bigoplus \limits_{i \preceq x} \alpha_i = \left [ \bigoplus \limits_{i \prec x} \bigoplus \limits_{j\preceq i} f(j) \right ] \oplus \alpha_x</tex> .

Рассмотрим сумму <tex> \left [ \bigoplus \limits_{i \prec x} \bigoplus \limits_{j\preceq i} f(j) \right ] </tex>. Каждый элемент <tex> f(j) </tex> содержится в ней, только если <tex> j \prec x </tex>, и для фиксированных <tex> j</tex> и <tex> x </tex> элемент <tex> f(j)</tex> встречается ровно столько раз, сколько существует <tex> i </tex> , таких, что <tex> j \preceq i \prec x</tex>. Несложно увидеть, что таких <tex> i </tex> существует ровно <tex> 2^{wt(x)-wt(j)}-1 </tex>, то есть нечетное количество раз. Тогда <tex> \left [ \bigoplus \limits_{i \prec x} \bigoplus \limits_{j\preceq i} f(j) \right ] = \bigoplus \limits_{j\prec x} f(j) </tex>.
Но тогда <tex> f(x) = \left [ \bigoplus \limits_{j\prec x} f(j) \right ] \oplus \alpha_x \Leftrightarrow f(x) \oplus \bigoplus \limits_{j\prec x} f(j) = \alpha_x \Leftrightarrow \alpha_x = \bigoplus \limits_{j\preceq x} f(j)</tex>.
То есть при <tex>wt(x) = k</tex> формула также выполняется, значит при любых <tex> x </tex> выполняется <tex>\alpha_x = \bigoplus \limits_{j\preceq x} f(j)</tex>.

}}
Отображение <tex> f \rightarrow \alpha</tex> также называется преобразованием Мёбиуса.

Видно, что <tex> (2) </tex> и <tex> (3) </tex> — это одно и тоже преобразование. Значит, если применить преобразование Мёбиуса к функции, а затем вновь применить то же преобразование к получившейся функции, тогда вновь получим исходную функцию <tex>f</tex>. То есть преобразование Мёбиуса обратно самому себе, иными словами, является инволюцией.

== Источники информации ==

* [http://www.stat-mat.com/?p=330 Cтатистика | Математика НГУ]
* [http://ru.wikipedia.org/wiki/Полином_Жегалкина Википедия {{---}} Полином Жегалкина]
* [http://dvo.sut.ru/libr/himath/w163rabk/index.htm Е.Л Рабкин, Ю.Б. Фарфоровская, дискретная математика]
* Логачёв О.А, Сальников А.А., Ященко В.В. Булевы фунции в теории кодирования и криптологии — МЦНМО, 2004. - 470с. — ISBN 5-94057-117-4.

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Булевы функции]]

Полином Жегалкина

2016-01-18T07:44:51Z

Nikitaevg: /* Преобразование дизъюнктивной нормальной формы */ исправлено написание "Де-Морган"

'''Полином Жегалкина''' (англ. ''Zhegalkin polynomial'') — полином с коэффициентами вида <tex>0</tex> и <tex>1</tex>, где в качестве произведения берётся конъюнкция, а в качестве сложения исключающее или. Полином был предложен в 1927 году И. И. Жегалкиным в качестве средства для представления [[Определение булевой функции|функций булевой логики]]. Полином Жегалкина имеет следующий вид:

<tex>P = a_{000...000} \oplus a_{100...0} x_1 \oplus a_{010...0} x_2 \oplus ... \oplus a_{00...01} x_n \oplus a_{110...0} x_1 x_2 \oplus ... \oplus a_{00...011} x_{n-1} x_n \oplus ... \oplus a_{11..1} x_1 x_2 ... x_n </tex>

== Полнота ==

По [[Теорема Поста о полной системе функций|теореме Поста]], чтобы система булевых функций была полной, надо, чтобы в ней существовали

#Хотя бы одна функция, не сохраняющая <tex>0</tex>;
#Хотя бы одна функция, не сохраняющая <tex>1</tex>;
#Хотя бы одна нелинейная функция;
#Хотя бы одна немонотонная функция;
#Хотя бы одна несамодвойственная функция.

Исходя из этого, система функций <tex>\bigl\langle \wedge, \oplus, 1 \bigr\rangle</tex> является полной:

{| class="wikitable" style="width:8cm" border="1"
|-align="center" bgcolor=#EEEEFF
!<tex>x_0</tex>||<tex>x_1</tex>||<tex>\dots</tex>||<tex>x_n</tex>
|<tex>1</tex>||<tex>\land</tex>||<tex>\oplus</tex>
|-align="center"
!<tex>0</tex>||<tex>0</tex>||<tex>\dots</tex>||<tex>0</tex>
|<tex>1</tex>||<tex>0</tex>||<tex>0</tex>
|-align="center"
!<tex>1</tex>||<tex>0</tex>||<tex>\dots</tex>||<tex>0</tex>
|<tex>1</tex>||<tex>0</tex>||<tex>1</tex>
|-align="center"
!<tex>\vdots</tex>||<tex>\vdots</tex>||<tex>\vdots</tex>||<tex>\vdots</tex>
|<tex>\vdots</tex>||<tex>\vdots</tex>||<tex>\vdots</tex>
|-align="center"
!<tex>1</tex>||<tex>1</tex>||<tex>\dots</tex>||<tex>1</tex>
|<tex>1</tex>||<tex>1</tex>||<tex>0</tex>
|-align="center"
!colspan="4"|Сохраняет 0
|<tex>0</tex>||<tex>1</tex>||<tex>1</tex>
|-align="center"
!colspan="4"|Сохраняет 1
|<tex>1</tex>||<tex>1</tex>||<tex>0</tex>
|-align="center"
!colspan="4"|Самодвойственная
|<tex>0</tex>||<tex>0</tex>||<tex>0</tex>
|-align="center"
!colspan="4"|Монотонная
|<tex>1</tex>||<tex>1</tex>||<tex>0</tex>
|-align="center"
!colspan="4"|Линейная
|<tex>1</tex>||<tex>0</tex>||<tex>1</tex>
|}

На основе этой системы и строятся полиномы Жегалкина.

== Существование и единственность представления (теорема Жегалкина) ==
{{Теорема
|author=Жегалкина
|statement=
Каждая булева функция единственным образом представляется в виде полинома Жегалкина.
|proof=
Заметим, что различных булевых функций от <tex>n</tex> переменных <tex>2^{2^n}</tex> штук. При этом конъюнкций вида <tex>x_{i_1} \ldots x_{i_k}</tex> существует ровно <tex>2^n</tex>, так как из <tex>n</tex> возможных сомножителей каждый или входит в конъюнкцию, или нет. В полиноме у каждой такой конъюнкции стоит <tex>0</tex> или <tex>1</tex>, то есть существует <tex>2^{2^n}</tex> различных полиномов Жегалкина от <tex>n</tex> переменных.

Теперь достаточно лишь доказать, что различные полиномы реализуют различные функции. Предположим противное. Тогда приравняв два различных полинома и перенеся один из них в другую часть равенства, получим полином, тождественно равный нулю и имеющий ненулевые коэффициенты. Тогда рассмотрим слагаемое с единичным коэффициентом наименьшей длины, то есть с наименьшим числом переменных, входящих в него (любой один, если таких несколько). Подставив единицы на места этих переменных, и нули на места остальных, получим, что на этом наборе только одно это слагаемое принимает единичное значение, то есть нулевая функция на одном из наборов принимает значение 1. Противоречие. Значит, каждая булева функция реализуется полиномом Жегалкина единственным образом.
}}

== Построение полинома Жегалкина ==

Существует несколько способов построения полинома Жегалкина.

=== По таблице истинности ===
Пусть для функции <tex>f(x_1,x_2,\dots,x_n)</tex> задана таблица истинности. Запишем сначала данную функцию в виде полинома Жегалкина с неопределёнными коэффициентами. Затем по очереди подставляем всевозможные наборы в порядке увеличения количества единиц и находим коэффициенты с учётом того, что <tex> a \oplus 1 = \bar{a}</tex>, а <tex> a \oplus 0 = a</tex>. За каждую подстановку находим только один коэффициент.

'''Пример:'''
Дана функция <tex>f(x_1,x_2,x_3,x_4)</tex> и её таблица истинности:

{| class="wikitable" style="width:8cm" border="1"
|-
!class="dark" style="font-weight:normal"| <tex>x_1</tex>
!class="dark" style="font-weight:normal"| <tex>x_2</tex>
!class="dark" style="font-weight:normal"| <tex>x_3</tex>
!class="dark" style="font-weight:normal"| <tex>x_4</tex>
!class="dark" style="font-weight:normal"| <tex>f(x_1,x_2,x_3,x_4)</tex>
|- align="center"
||0||0||0||0||0
|- align="center"
||0||0||0||1||0
|- align="center"
||0||0||1||0||0
|- align="center"
||0||0||1||1||0
|- align="center"
||0||1||0||0||0
|- align="center"
||0||1||0||1||0
|- align="center"
||0||1||1||0||1
|- align="center"
||0||1||1||1||0
|- align="center"
||1||0||0||0||1
|- align="center"
||1||0||0||1||0
|- align="center"
||1||0||1||0||0
|- align="center"
||1||0||1||1||1
|- align="center"
||1||1||0||0||1
|- align="center"
||1||1||0||1||0
|- align="center"
||1||1||1||0||1
|- align="center"
||1||1||1||1||0
|}
Построим для неё полином Жегалкина:

<tex>f(x_1,x_2,x_3,x_4) = a_{0000} \oplus a_{1000} x_1 \oplus a_{0100} x_2 \oplus a_{0010} x_3 \oplus a_{0001} x_4 \oplus a_{1100} x_1 x_2 \oplus a_{1010} x_1 x_3 \oplus a_{1001} x_1 x_4 \oplus a_{0110} x_2 x_3 \oplus a_{0101} x_2 x_4 \oplus a_{0011} x_3 x_4 \oplus a_{1110} x_1 x_2 x_3 \oplus a_{1101} x_1 x_2 x_4 \oplus a_{1011} x_1 x_3 x_4 \oplus a_{0111} x_2 x_3 x_4 \oplus a_{1111} x_1 x_2 x_3 x_4</tex>

Так как <tex>f(0,0,0,0) = 0</tex>, то <tex>a_{0000} = 0</tex>.
Далее подставляем все остальные наборы в порядке возрастания числа единиц, подставляя вновь полученные значения в следующие формулы:

<tex>f(1,0,0,0) = a_{0000} \oplus a_{1000} = 1 \Rightarrow a_{1000} = 1</tex>

<tex>f(0,1,0,0) = a_{0000} \oplus a_{0100} = 0 \Rightarrow a_{0100} = 0</tex>

<tex>f(0,0,1,0) = a_{0000} \oplus a_{0010} = 0 \Rightarrow a_{0010} = 0</tex>

<tex>f(0,0,0,1) = a_{0000} \oplus a_{0001} = 0 \Rightarrow a_{0001} = 0</tex>

<tex>f(1,1,0,0) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{1100} = 1 \Rightarrow a_{1100} = 0</tex>

<tex>f(1,0,1,0) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{1010} = 0 \Rightarrow a_{1010} = 1</tex>

<tex>f(1,0,0,1) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{1001} = 0 \Rightarrow a_{1001} = 1</tex>

<tex>f(0,1,1,0) = a_{0000} \oplus a_{0100} \oplus a_{0010} \oplus a_{0110} = 1 \Rightarrow a_{0110} = 1</tex>

<tex>f(0,1,0,1) = a_{0000} \oplus a_{0100} \oplus a_{0001} \oplus a_{0101} = 0 \Rightarrow a_{0101} = 0</tex>

<tex>f(0,0,1,1) = a_{0000} \oplus a_{0010} \oplus a_{0001} \oplus a_{0011} = 0 \Rightarrow a_{0011} = 0</tex>

<tex>f(1,1,1,0) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{0010} \oplus a_{1100} \oplus a_{1010} \oplus a_{0110} \oplus a_{1110} = 1 \Rightarrow a_{1110} = 0</tex>

<tex>f(1,1,0,1) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{0001} \oplus a_{1100} \oplus a_{1001} \oplus a_{0101} \oplus a_{1101} = 0 \Rightarrow a_{1101} = 0</tex>

<tex>f(1,0,1,1) = a_{0000} \oplus a_{1000} \oplus a_{0010} \oplus a_{0001} \oplus a_{1010} \oplus a_{1001} \oplus a_{0011} \oplus a_{1011} = 1 \Rightarrow a_{1011} = 0</tex>

<tex>f(0,1,1,1) = a_{0000} \oplus a_{0100} \oplus a_{0010} \oplus a_{0001} \oplus a_{0110} \oplus a_{0101} \oplus a_{0011} \oplus a_{0111} = 0 \Rightarrow a_{0111} = 1</tex>

<tex>f(1,1,1,1) = a_{0000} \oplus a_{1000} \oplus a_{0100} \oplus a_{0010} \oplus a_{0001} \oplus a_{1100} \oplus a_{1010} \oplus a_{1001} \oplus a_{0110} \oplus a_{0101} \oplus a_{0011} \oplus a_{1110} \oplus a_{1101} \oplus a_{1011} \oplus a_{0111} \oplus a_{1111} = 0 \Rightarrow a_{1111} = 1</tex>

Таким образом, полином Жегалкина выглядит так:

<tex>f(x_1,x_2,x_3,x_4) = x_1 \oplus x_1 x_3 \oplus x_1 x_4 \oplus x_2 x_3 \oplus x_2 x_3 x_4 \oplus x_1 x_2 x_3 x_4</tex>

=== Преобразование [[Определение_булевой_функции#Дизъюнктивная нормальная форма (ДНФ)|дизъюнктивной нормальной формы]] ===
Этот способ основан на том, что <tex> X \oplus 1 = \bar{X} </tex>. Если функция задана в виде ДНФ, то можно сначала убрать дизъюнкцию, используя правило де Моргана, а все отрицания заменить прибавлением единицы по модулю два, после чего раскрыть скобки по обычным правилам, при этом учитывая, что четное число одинаковых слагаемых равно нулю (так как <tex> X \oplus X = 0 </tex>), а нечетное число одинаковых слагаемых равно одному такому слагаемому. Либо же можно заменить дизъюнкцию по следующему правилу:
<tex> A \lor B = AB \oplus A \oplus B </tex>   <tex> (1) </tex>.

Если функция задана в СДНФ, то так как при любых значениях входных переменных в единицу обращается не более одного члена выражения, то достаточно просто заменить все дизъюнкции исключающим ИЛИ.

'''Пример:'''
Дана функция в ДНФ <tex> f(x_1,x_2,x_3,x_4) = (x_1 \land x_2 \land \neg x_3 \land x_4) \lor (\neg x_1 \land \neg x_4) \lor (x_1 \land x_2) \lor x_2 </tex>, построим полином Жегалкина.

Запишем функцию так:

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_2 \neg x_3 x_4 + \neg x_1 \neg x_4 + x_1 x_2 + x_2</tex>;

Сгруппируем слагаемые и воспользуемся преобразованием (1):

<tex>f(x_1,x_2,x_3,x_4) = (x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4 \oplus x_1 x_2 \neg x_3 x_4 \neg x_1 \neg x_4) + (x_1 x_2 \oplus x_2 \oplus \oplus x_1 x_2 x_2)</tex>

Воспользуемся свойствами конъюнкции <tex>A \land A = A</tex> и <tex>\neg A \land A = 0</tex>, а также тем, что <tex>A \oplus A = 0</tex>, и упростим выражение:

<tex>f(x_1,x_2,x_3,x_4) = (x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4) + x_2</tex>

Ещё раз воспользуемся преобразованием (1):

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4 \oplus x_2 \oplus (x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4) x_2</tex>

Раскроем скобку по алгебраическим правилам:

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_2 \neg x_3 x_4 \oplus \neg x_1 \neg x_4 \oplus x_2 \oplus x_1 x_2 x_2 \neg x_3 x_4 \oplus \neg x_1 x_2 \neg x_4</tex>

Снова воспользуемся свойствами конъюнкции и исключающего ИЛИ:

<tex>f(x_1,x_2,x_3,x_4) = \neg x_1 \neg x_4 \oplus x_2 \oplus \neg x_1 x_2 \neg x_4</tex>

Заменим отрицание на прибавление <tex>1</tex>:

<tex>f(x_1,x_2,x_3,x_4) = (x_1 \oplus 1) (x_4 \oplus 1) \oplus x_2 \oplus (x_1 \oplus 1) x_2 (x_4 \oplus 1)</tex>

Раскроем скобки:

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_4 \oplus x_1 \oplus x_4 \oplus 1 \oplus x_2 \oplus x_1 x_2 x_4 \oplus x_1 x_2 \oplus x_2 x_4 \oplus x_2</tex>

Выкинем парные слагаемые и получим окончательную формулу:

<tex>f(x_1,x_2,x_3,x_4) = x_1 x_2 x_4 \oplus x_1 x_2 \oplus x_1 x_4 \oplus x_2 x_4 \oplus x_1 \oplus x_4 \oplus 1</tex>

=== Метод треугольника === 
Метод треугольника позволяет преобразовать таблицу истинности в полином Жегалкина путём построения вспомогательной треугольной таблицы в соответствии со следующими правилами:
# Строится полная таблица истинности, в которой строки идут в порядке возрастания двоичных кодов от <tex>000\dots00</tex> до <tex>111\dots11</tex>.
# Строится вспомогательная треугольная таблица, в которой первый столбец совпадает со столбцом значений функции в таблице истинности.
# Ячейка в каждом последующем столбце получается путём сложения по модулю 2 двух ячеек предыдущего столбца — стоящей в той же строке и строкой ниже.
# Столбцы вспомогательной таблицы нумеруются двоичными кодами в том же порядке, что и строки таблицы истинности.
# Каждому двоичному коду ставится в соответствие один из членов полинома Жегалкина в зависимости от позиций кода, в которых стоят единицы. Например, ячейке <tex>111</tex> соответствует член <tex>ABC</tex>, ячейке <tex>101</tex> — член <tex>AC</tex>, ячейке <tex>010</tex> — член <tex>B</tex>, ячейке <tex>000</tex> — член <tex>1</tex> и т.д.
# Если в верхней строке какого-либо столбца стоит единица, то соответствующий член присутствует в полиноме Жегалкина.

Фактически, этот метод является модификацией метода построения по таблице истинности, описанного выше. По сравнению с ним он удобнее тем, что расчёты занимают мало места и в них сложнее ошибиться, но метод треугольника требует бо́льшего количества операций.

Пример преобразования таблицы истинности в полином Жегалкина для функции трёх переменных <tex>P(A,B,C)</tex> показан на рисунке.

[[Файл:Преобразование таблицы истинности в полином Жегалкина методом треугольника.gif]]

Чтобы получить формулу, по которой рассчитывается какой-либо коэффициент, нужно из клетки, в которой он записан, пройтись всеми возможными путями влево, до столбца <tex>''P''</tex> таблицы истинности, делая ходы влево и влево-вниз, записать значения в конечных ячейках и сложить их все между собой по модулю 2.

Таким образом, в первом столбце сверху записан коэффициент <tex> a_0 = P(0,0,0) </tex>,

во втором — <tex> a_1 = P(0,0,0) \oplus P(0,0,1) </tex>,

в третьем — <tex> a_2 = P(0,0,0) \oplus P(0,0,1) \oplus P(0,0,1) \oplus P(0,1,0) = P(0,0,0) \oplus P(0,1,0) </tex>,

в четвёртом —

<tex> a_3 = P(0,0,0) \oplus P(0,0,1) \oplus P(0,0,1) \oplus P(0,0,1) \oplus P(0,1,0) \oplus P(0,1,0) \oplus P(0,1,0) \oplus P(0,1,1) = P(0,0,0) \oplus P(0,1,0) \oplus P(0,1,0) \oplus P(0,1,1), </tex>

и так далее, то есть при построении вспомогательной таблицы коэффициенты полинома просчитываются автоматически.

=== Преобразование Мёбиуса ===
Пусть задана [[Определение булевой функции|булева функция]] <tex>f: B^n \rightarrow B, \;\; B=\{ 0; 1 \}</tex>.
Любая булева функция представима в виде полинома Жегалкина, притом единственным образом.

Пусть <tex> i = (i_1, i_2, .. i_n), \;\; i_k \in \{0 ; 1\}</tex>, и введем обозначение <tex> x ^{i_k} \sim \left\{\begin{matrix} x, \;\; i_k=1
\\ 1, \;\; i_k=0
\end{matrix}\right. </tex>

Тогда полином Жегалкина можно записать как:
<tex> f(x) = \bigoplus\limits_i \alpha_i \cdot x_1^{i_1} \cdot x_2^{i_2} \cdot</tex><tex>\dots</tex><tex>\cdot x_n^{i_n}</tex>, где <tex>\alpha_i \in \{ 0; 1 \}</tex>.

Множество коэффициентов <tex>\{\alpha _i\}</tex> можно рассматривать как функцию <tex>\alpha</tex>, заданной на множестве индексов <tex> i = (i_1, i_2, \dots i_n)</tex>, то есть <tex>\alpha: i \mapsto \alpha_i</tex>.

Очевидно, функцию <tex> f </tex> можно записать и следующим образом: <tex> f(x) = \bigoplus \limits_i \alpha_i \cdot [x_1 , \; </tex> если <tex> \;\; i_1] \cdot [x_2 , \; </tex> если <tex> \;\; i_2] \cdot</tex><tex>\dots</tex><tex>\cdot [x_n , \; </tex> если <tex> \;\; i_n]</tex>.

Тут запись <tex>[x_k , \; </tex> если <tex> \; i_k]</tex> означает, что элелемент <tex> x_k </tex> присутствует в соответствующем члене полинома только если <tex> i_k = 1 </tex>.
Тогда если для какого-то <tex>x</tex>, <tex>i \succ x</tex>* ,то в слагаемом будет существовать хотя бы один множитель, равный нулю, и такое слагаемое на сумму не повлияет.
Отсюда ясно, что <tex> f(x) = \bigoplus \limits_{i \preceq x} \alpha_i </tex>  <tex> (2) </tex>
Найдем отображение <tex> f \mapsto \alpha</tex> (То есть такое, которое по заданной функции вычисляет значения всех коэффициентов).

<tex>*</tex> <tex>i \succ x</tex> обозначает, что <tex>x</tex> "меньше" <tex>i</tex> как последовательность бит

{{Теорема
|statement=Пусть задана функция <tex> f </tex>. Тогда функцию <tex> \alpha_x </tex> можно найти по формуле: <tex>\alpha_x = \bigoplus \limits_{j\preceq x} f(j)</tex>     <tex> (3) </tex>.
||proof=Докажем при помощи индукции по количеству единиц в векторе <tex> x </tex> ( иначе говоря, по сумме <tex>x_1+x_2+</tex><tex>\dots</tex><tex>+x_n</tex> ) и для удобства обозначим это количество единиц(сумму) <tex> wt(x) </tex>.

'''1)''' База: если <tex> x = 0 </tex>, то, очевидно <tex> f(0) = \alpha_0 </tex>

'''2)''' Пускай теорема справедлива для всех сумм <tex>wt(x) < k</tex>. Покажем, что в таком случае она верна и для <tex>wt(x) = k</tex>. По <tex> (2) </tex>, а далее по предположению индукции видим: <tex> f(x) = \bigoplus \limits_{i \preceq x} \alpha_i = \left [ \bigoplus \limits_{i \prec x} \bigoplus \limits_{j\preceq i} f(j) \right ] \oplus \alpha_x</tex> .

Рассмотрим сумму <tex> \left [ \bigoplus \limits_{i \prec x} \bigoplus \limits_{j\preceq i} f(j) \right ] </tex>. Каждый элемент <tex> f(j) </tex> содержится в ней, только если <tex> j \prec x </tex>, и для фиксированных <tex> j</tex> и <tex> x </tex> элемент <tex> f(j)</tex> встречается ровно столько раз, сколько существует <tex> i </tex> , таких, что <tex> j \prec i \prec x</tex>. Несложно увидеть, что таких <tex> i </tex> существует ровно <tex> 2^{wt(x)-wt(j)}-1 </tex>, то есть нечетное количество раз. Тогда <tex> \left [ \bigoplus \limits_{i \prec x} \bigoplus \limits_{j\preceq i} f(j) \right ] = \bigoplus \limits_{j\prec x} f(j) </tex>.
Но тогда <tex> f(x) = \left [ \bigoplus \limits_{j\prec x} f(j) \right ] \oplus \alpha_x \Leftrightarrow f(x) \oplus \bigoplus \limits_{j\prec x} f(j) = \alpha_x \Leftrightarrow \alpha_x = \bigoplus \limits_{j\preceq x} f(j)</tex>.
То есть при <tex>wt(x) = k</tex> формула также выполняется, значит при любых <tex> x </tex> выполняется <tex>\alpha_x = \bigoplus \limits_{j\preceq x} f(j)</tex>.

}}
Отображение <tex> f \rightarrow \alpha</tex> также называется преобразованием Мёбиуса.

Видно, что <tex> (2) </tex> и <tex> (3) </tex> — это одно и тоже преобразование. Значит, если применить преобразование Мёбиуса к функции, а затем вновь применить то же преобразование к получившейся функции, тогда вновь получим исходную функцию <tex>f</tex>. То есть преобразование Мёбиуса обратно самому себе, иными словами, является инволюцией.

== Источники информации ==

* [http://www.stat-mat.com/?p=330 Cтатистика | Математика НГУ]
* [http://ru.wikipedia.org/wiki/Полином_Жегалкина Википедия {{---}} Полином Жегалкина]
* [http://dvo.sut.ru/libr/himath/w163rabk/index.htm Е.Л Рабкин, Ю.Б. Фарфоровская, дискретная математика]
* Логачёв О.А, Сальников А.А., Ященко В.В. Булевы фунции в теории кодирования и криптологии — МЦНМО, 2004. - 470с. — ISBN 5-94057-117-4.

[[Категория: Дискретная математика и алгоритмы]]
[[Категория: Булевы функции]]

Алгоритм Хьюи

2016-01-17T11:06:46Z

Nikitaevg:

{{Задача
|definition=Дано [[Основные определения теории графов#oriented_grath|ориентированное]] [[Дерево, эквивалентные определения#tree|дерево]], вершины которого раскрашены в цвета. Найти <tex>dc:V\rightarrow \{1\ldots k\}</tex>, где <tex>dc(u) -</tex> число различных цветов в поддереве с корнем в вершине <tex>u</tex>. Время работы: <tex>O(V)</tex>}}

__TOC__

==Простое решение==
Ответ на задачу можно получить достаточно просто с помощью битовых масок. Для начала в каждую вершину поместим битовую маску с цветом данной вершины. Запустим [[Обход в глубину, цвета вершин|обход в глубину]] и на выходе из каждой вершины будем записывать в неё результат побитового <tex>OR</tex> масок её детей и её самой. Таким образом в каждой вершине будет храниться битовая маска с цветами, лежащими в данном поддереве. Общая сложность алгоритма будет <tex>O(V \cdot K)</tex>, где <tex>K\ -</tex> количество цветов. Если количество цветов меньше размера машинного слова, то сложность составит <tex>O(V)</tex>.

==Алгоритм решения==
Будем в каждой вершине дерева хранить по числу, так, чтобы для каждого поддерева ответом была сумма всех значений в вершинах в данном поддереве. Для начала каждой вершине в качестве значения присвоим <tex>1</tex>. Теперь, если бы все вершины имели различные цвета, надо было бы пройти снизу вверх по дереву и просуммировать для каждой вершины числа, записанные в её детях. Но некоторые вершины будут иметь одинаковые цвета, и это надо как-то учитывать.

Для этого запустим обход в глубину. Также будем хранить для каждого цвета последнюю посещенную вершину данного цвета в массиве <tex>last[k]</tex>. Теперь, заходя в <tex>i</tex>-ую вершину с цветом <tex>col</tex>, смотрим: если вершина с таким цветом еще не встречалась, то просто присваиваем <tex>last[col]=i</tex>, иначе, если вершина с данным цветом уже встречалась, то находим [[Сведение задачи LCA к задаче RMQ|наименьшего общего предка]] данной вершины и последней вершины с таким цветом и вычитаем из их предка <tex>1</tex>, присваиваем <tex>last[col]=i</tex>. Теперь при выходе из вершины можно просуммировать числа в ее детях и получить ответ для данной вершины, так как для нее все дети уже подсчитаны.

Таким образом, алгоритм запускает один обход в глубину, на каждой итерации которого ищет наименьшего общего предка. Если искать наименьшего общего предка за <tex>O(1)</tex>, к примеру [[Алгоритм Фарака-Колтона и Бендера|алгоритмом Фарака-Колтона и Бендера]], то сложность работы алгоритма будет <tex>O(V)</tex>.

==Пример==

{| class = "wikitable"
! № шага !! Изображение !! Описание
|-align="center"
| 0
| [[Файл:algo_0.png|300px]]
| Расставим у каждой вершины <tex>1</tex>.
|-align="center"
| 1
| [[Файл:algo_1.png|300px]]
| Выходим из <tex>8</tex>-ой вершины. Так как желтых вершин еще не было, запоминаем её как последнюю желтую.
|-align="center"
| 2
| [[Файл:algo_2.png|300px]]
| <tex>4</tex>-ая вершина. Последняя желтая <tex>-\ 8</tex>-ая. Их LCA <tex>\ -4</tex>-ая вершина. Вычитаем из значения <tex>4</tex>-ой вершины <tex>1</tex> и запоминаем текущую как последнюю желтую.
|-align="center"
| 8
| [[Файл:8.png|300px]]
| Пропустим несколько тривиальных шагов. Выходим из <tex>11</tex>-ой вершины. Последней посещенной зеленой была <tex>5</tex>-ая (не <tex>3</tex>-я). Вычитаем из их LCA (<tex>1</tex>-ой вершины) <tex>1</tex> и запоминаем <tex>11</tex>-ую как последнюю зеленую.
|-align="center"
| 9
| [[Файл:9.png|300px]]
| Выходим из <tex>7</tex>-ой вершины. Последней синей была <tex>2</tex>-ая. Вычтем из их LCA <tex>1</tex> и запомним <tex>7</tex>-ую как последнюю синюю.
|-align="center"
| суммирование
| [[Файл:algo_12.png|300px]]
|Пропустим еще два шага. В результате суммирования получаем в каждой вершине ответ на задачу для поддерева.
|-
|}

==Псевдокод==
'''int''' col[MAX_COL], used[MAX_N], sum[MAX_N]

'''func''' dfs('''Node''' v)''':'''
used[v] = ''true''
'''for''' <tex>u \in</tex> v.children
'''if''' !used[u]
dfs(u)
sum[v] += sum[u]
'''if''' last[col[v]] != -1
sum[lca(v, last[col[v]])]--
last[col[v]] = v

'''func''' hugh('''int''' n, '''int''' k, '''Node''' root)''':'''
'''for''' <tex>v \in V</tex>
used[v] = ''false''
sum[v] = 1
'''for''' i = 1 '''to''' k
last[i] = -1
dfs(root)

==Обоснование корректности==
{{Лемма
|statement = Наименьшим общим предком вершины и группы вершин, предшествующих по времени выхода, является наименьший общий предок данной вершины и последней, предшествующей ей из группы.
|proof = Рассмотрим дерево как последовательность букв, когда при входе в вершину или выходе из нее записывается ее буква. Пусть рассматриваемая вершина <tex>-\ u</tex>, а последняя рассмотренная из той же группы <tex> -\ v</tex>, их наименьший общий предок <tex>-\ w</tex>. Рассмотрим два варианта расположения этих двух вершин.

[[Файл:proof_1.png|200px]]
[[Файл:proof_2.png|200px]]

Теперь возьмем вершину <tex>z</tex>, которая встречается до выхода из <tex>v</tex>. Перебрав несложные пять случаев, можно легко убедиться, что наименьший общий предок <tex>u</tex> и <tex>v</tex> будет ниже, чем наименьший общий предок <tex>u</tex> и <tex>x</tex>.
}}

Для того, чтобы учитывать вершины с одинаковым цветом, для каждой вершины требуется найти наименьшего общего предка этой вершины и вершин, предшествующих данной по времени выхода с таким же цветом и вычесть из значения этого предка <tex>1</tex>. Так, при конечном подсчете значение наименьшего общего предка данной вершины и любой вершины, предшествующей данной с тем же цветом, уменьшится на <tex>1</tex>, так как наименьший предок этой точки и любой предшествующей того же цвета находится на пути из наименьшего общего предка этой группы точек. А как раз это и требуется <tex>-</tex> для каждой пары точек одного цвета учесть данный факт в их наименьшем общем предке. И по лемме, чтобы взять наименьшего общего предка текущей вершины и всех предшествующих вершин с данным цветом, надо взять наименьшего общего предка данной вершины и предыдущей вершины с данным цветом, он будет наименьшим для всех.

[[Файл:hugh.png|300px]]

==См. также==
*[[Алгоритм Тарьяна поиска LCA за O(1) в оффлайн]]

*[[Метод двоичного подъема]]

[[Категория: Алгоритмы и структуры данных]]

[[Категория: Задача о наименьшем общем предке]]

Алгоритм Хьюи

2016-01-17T11:02:48Z

Nikitaevg:

{{Задача
|definition=Дано [[Основные определения теории графов#oriented_grath|ориентированное]] [[Дерево, эквивалентные определения#tree|дерево]], вершины которого раскрашены в цвета. Найти <tex>dc:V\rightarrow \{1\ldots k\}</tex>, где <tex>dc(u) -</tex> число различных цветов в поддереве с корнем в вершине <tex>u</tex>. Время работы: <tex>O(V)</tex>}}

__TOC__

==Простое решение==
Ответ на задачу можно получить достаточно просто с помощью битовых масок. Для начала в каждую вершину поместим битовую маску с цветом данной вершины. Запустим [[Обход в глубину, цвета вершин|обход в глубину]] и на выходе из каждой вершины будем записывать в неё результат побитового <tex>OR</tex> масок её детей и её самой. Таким образом в каждой вершине будет храниться битовая маска с цветами, лежащими в данном поддереве. Общая сложность алгоритма будет <tex>O(V \cdot K)</tex>, где <tex>K\ -</tex> количество цветов. Если количество цветов меньше размера машинного слова, то сложность будет <tex>O(V)</tex>.

==Алгоритм решения==
Будем в каждой вершине дерева хранить по числу, так, чтобы для каждого поддерева ответом была сумма всех значений в вершинах в данном поддереве. Для начала каждой вершине в качестве значения присвоим <tex>1</tex>. Теперь, если бы все вершины имели различные цвета, надо было бы пройти снизу вверх по дереву и просуммировать для каждой вершины числа, записанные в её детях. Но некоторые вершины будут иметь одинаковые цвета, и это надо как-то учитывать.

Для этого запустим обход в глубину. Также будем хранить для каждого цвета последнюю посещенную вершину данного цвета в массиве <tex>last[k]</tex>. Теперь, заходя в <tex>i</tex>-ую вершину с цветом <tex>col</tex>, смотрим: если вершина с таким цветом еще не встречалась, то просто присваиваем <tex>last[col]=i</tex>, иначе, если вершина с данным цветом уже встречалась, то находим [[Сведение задачи LCA к задаче RMQ|наименьшего общего предка]] данной вершины и последней вершины с таким цветом и вычитаем из их предка <tex>1</tex>, присваиваем <tex>last[col]=i</tex>. Теперь при выходе из вершины можно просуммировать числа в ее детях и получить ответ для данной вершины, так как для нее все дети уже подсчитаны.

Таким образом, алгоритм запускает один обход в глубину, на каждой итерации которого ищет наименьшего общего предка. Если искать наименьшего общего предка за <tex>O(1)</tex>, к примеру [[Алгоритм Фарака-Колтона и Бендера|алгоритмом Фарака-Колтона и Бендера]], то сложность работы алгоритма будет <tex>O(V)</tex>.

==Пример==

{| class = "wikitable"
! № шага !! Изображение !! Описание
|-align="center"
| 0
| [[Файл:algo_0.png|300px]]
| Расставим у каждой вершины <tex>1</tex>.
|-align="center"
| 1
| [[Файл:algo_1.png|300px]]
| Выходим из <tex>8</tex>-ой вершины. Так как желтых вершин еще не было, запоминаем её как последнюю желтую.
|-align="center"
| 2
| [[Файл:algo_2.png|300px]]
| <tex>4</tex>-ая вершина. Последняя желтая <tex>-\ 8</tex>-ая. Их LCA <tex>\ -4</tex>-ая вершина. Вычитаем из значения <tex>4</tex>-ой вершины <tex>1</tex> и запоминаем текущую как последнюю желтую.
|-align="center"
| 8
| [[Файл:8.png|300px]]
| Пропустим несколько тривиальных шагов. Выходим из <tex>11</tex>-ой вершины. Последней посещенной зеленой была <tex>5</tex>-ая (не <tex>3</tex>-я). Вычитаем из их LCA (<tex>1</tex>-ой вершины) <tex>1</tex> и запоминаем <tex>11</tex>-ую как последнюю зеленую.
|-align="center"
| 9
| [[Файл:9.png|300px]]
| Выходим из <tex>7</tex>-ой вершины. Последней синей была <tex>2</tex>-ая. Вычтем из их LCA <tex>1</tex> и запомним <tex>7</tex>-ую как последнюю синюю.
|-align="center"
| суммирование
| [[Файл:algo_12.png|300px]]
|Пропустим еще два шага. В результате суммирования получаем в каждой вершине ответ на задачу для поддерева.
|-
|}

==Псевдокод==
'''int''' col[MAX_COL], used[MAX_N], sum[MAX_N]

'''func''' dfs('''Node''' v)''':'''
used[v] = true
'''for''' <tex>u \in</tex> v.children
'''if''' !used[u]
dfs(u)
sum[v] += sum[u]
'''if''' last[col[v]] != -1
sum[lca(v, last[col[v]])]--
last[col[v]] = v

'''func''' hugh('''int''' n, '''int''' k, '''Node''' root)''':'''
'''for''' <tex>v \in V</tex>
used[v] = false
sum[v] = 1
'''for''' i = 1 to k
last[i] = -1
dfs(root)

==Обоснование корректности==
{{Лемма
|statement = Наименьшим общим предком вершины и группы вершин, предшествующих по времени выхода, является наименьший общий предок данной вершины и последней, предшествующей ей из группы.
|proof = Рассмотрим дерево как последовательность букв, когда при входе в вершину или выходе из нее записывается ее буква. Пусть рассматриваемая вершина <tex>-\ u</tex>, а последняя рассмотренная из той же группы <tex> -\ v</tex>, их наименьший общий предок <tex>-\ w</tex>. Рассмотрим два варианта расположения этих двух вершин.

[[Файл:proof_1.png|200px]]
[[Файл:proof_2.png|200px]]

Теперь возьмем вершину <tex>z</tex>, которая встречается до выхода из <tex>v</tex>. Перебрав несложные пять случаев, можно легко убедиться, что наименьший общий предок <tex>u</tex> и <tex>v</tex> будет ниже, чем наименьший общий предок <tex>u</tex> и <tex>x</tex>.
}}

Для того, чтобы учитывать вершины с одинаковым цветом, для каждой вершины требуется найти наименьшего общего предка этой вершины и вершин, предшествующих данной по времени выхода с таким же цветом и вычесть из значения этого предка <tex>1</tex>. Так, при конечном подсчете значение наименьшего общего предка данной вершины и любой вершины, предшествующей данной с тем же цветом, уменьшится на <tex>1</tex>, так как наименьший предок этой точки и любой предшествующей того же цвета находится на пути из наименьшего общего предка этой группы точек. А как раз это и требуется <tex>-</tex> для каждой пары точек одного цвета учесть данный факт в их наименьшем общем предке. И по лемме, чтобы взять наименьшего общего предка текущей вершины и всех предшествующих вершин с данным цветом, надо взять наименьшего общего предка данной вершины и предыдущей вершины с данным цветом, он будет наименьшим для всех.

[[Файл:hugh.png|300px]]

==См. также==
*[[Алгоритм Тарьяна поиска LCA за O(1) в оффлайн]]

*[[Метод двоичного подъема]]

[[Категория: Алгоритмы и структуры данных]]

[[Категория: Задача о наименьшем общем предке]]

Алгоритм Хьюи

2016-01-17T11:01:00Z

Nikitaevg:

{{Задача
|definition=Дано [[Основные определения теории графов#oriented_grath|ориентированное]] [[Дерево, эквивалентные определения#tree|дерево]], вершины которого раскрашены в цвета. Найти <tex>dc:V\rightarrow \{1\ldots k\}</tex>, где <tex>dc(u) -</tex> число различных цветов в поддереве с корнем в вершине <tex>u</tex>. Время работы: <tex>O(V)</tex>}}

__TOC__

==Простое решение==
Ответ на задачу можно получить достаточно просто с помощью битовых масок. Для начала в каждую вершину поместим битовую маску с цветом данной вершины. Запустим [[Обход в глубину, цвета вершин|обход в глубину]] и на выходе из каждой вершины будем записывать в неё результат побитового <tex>OR</tex> масок её детей и её самой. Таким образом в каждой вершине будет храниться битовая маска с цветами, лежащими в данном поддереве. Общая сложность алгоритма будет <tex>O(V \cdot K)</tex>, где <tex>K</tex> - количество цветов. Если количество цветов меньше размера машинного слова, то сложность будет <tex>O(V)</tex>.

==Алгоритм решения==
Будем в каждой вершине дерева хранить по числу, так, чтобы для каждого поддерева ответом была сумма всех значений в вершинах в данном поддереве. Для начала каждой вершине в качестве значения присвоим <tex>1</tex>. Теперь, если бы все вершины имели различные цвета, надо было бы пройти снизу вверх по дереву и просуммировать для каждой вершины числа, записанные в её детях. Но некоторые вершины будут иметь одинаковые цвета, и это надо как-то учитывать.

Для этого запустим обход в глубину. Также будем хранить для каждого цвета последнюю посещенную вершину данного цвета в массиве <tex>last[k]</tex>. Теперь, заходя в <tex>i</tex>-ую вершину с цветом <tex>col</tex>, смотрим: если вершина с таким цветом еще не встречалась, то просто присваиваем <tex>last[col]=i</tex>, иначе, если вершина с данным цветом уже встречалась, то находим [[Сведение задачи LCA к задаче RMQ|наименьшего общего предка]] данной вершины и последней вершины с таким цветом и вычитаем из их предка <tex>1</tex>, присваиваем <tex>last[col]=i</tex>. Теперь при выходе из вершины можно просуммировать числа в ее детях и получить ответ для данной вершины, так как для нее все дети уже подсчитаны.

Таким образом, алгоритм запускает один обход в глубину, на каждой итерации которого ищет наименьшего общего предка. Если искать наименьшего общего предка за <tex>O(1)</tex>, к примеру [[Алгоритм Фарака-Колтона и Бендера|алгоритмом Фарака-Колтона и Бендера]], то сложность работы алгоритма будет <tex>O(V)</tex>.

==Пример==

{| class = "wikitable"
! № шага !! Изображение !! Описание
|-align="center"
| 0
| [[Файл:algo_0.png|300px]]
| Расставим у каждой вершины <tex>1</tex>.
|-align="center"
| 1
| [[Файл:algo_1.png|300px]]
| Выходим из <tex>8</tex>-ой вершины. Так как желтых вершин еще не было, запоминаем её как последнюю желтую.
|-align="center"
| 2
| [[Файл:algo_2.png|300px]]
| <tex>4</tex>-ая вершина. Последняя желтая <tex>-\ 8</tex>-ая. Их LCA <tex>\ -4</tex>-ая вершина. Вычитаем из значения <tex>4</tex>-ой вершины <tex>1</tex> и запоминаем текущую как последнюю желтую.
|-align="center"
| 8
| [[Файл:8.png|300px]]
| Пропустим несколько тривиальных шагов. Выходим из <tex>11</tex>-ой вершины. Последней посещенной зеленой была <tex>5</tex>-ая (не <tex>3</tex>-я). Вычитаем из их LCA (<tex>1</tex>-ой вершины) <tex>1</tex> и запоминаем <tex>11</tex>-ую как последнюю зеленую.
|-align="center"
| 9
| [[Файл:9.png|300px]]
| Выходим из <tex>7</tex>-ой вершины. Последней синей была <tex>2</tex>-ая. Вычтем из их LCA <tex>1</tex> и запомним <tex>7</tex>-ую как последнюю синюю.
|-align="center"
| суммирование
| [[Файл:algo_12.png|300px]]
|Пропустим еще два шага. В результате суммирования получаем в каждой вершине ответ на задачу для поддерева.
|-
|}

==Псевдокод==
'''int''' col[MAX_COL], used[MAX_N], sum[MAX_N]

'''func''' dfs('''Node''' v)''':'''
used[v] = true
'''for''' <tex>u \in</tex> v.children
'''if''' !used[u]
dfs(u)
sum[v] += sum[u]
'''if''' last[col[v]] != -1
sum[lca(v, last[col[v]])]--
last[col[v]] = v

'''func''' hugh('''int''' n, '''int''' k, '''Node''' root)''':'''
'''for''' <tex>v \in V</tex>
used[v] = false
sum[v] = 1
'''for''' i = 1 to k
last[i] = -1
dfs(root)

==Обоснование корректности==
{{Лемма
|statement = Наименьшим общим предком вершины и группы вершин, предшествующих по времени выхода, является наименьший общий предок данной вершины и последней, предшествующей ей из группы.
|proof = Рассмотрим дерево как последовательность букв, когда при входе в вершину или выходе из нее записывается ее буква. Пусть рассматриваемая вершина <tex>-\ u</tex>, а последняя рассмотренная из той же группы <tex> -\ v</tex>, их наименьший общий предок <tex>-\ w</tex>. Рассмотрим два варианта расположения этих двух вершин.

[[Файл:proof_1.png|200px]]
[[Файл:proof_2.png|200px]]

Теперь возьмем вершину <tex>z</tex>, которая встречается до выхода из <tex>v</tex>. Перебрав несложные пять случаев, можно легко убедиться, что наименьший общий предок <tex>u</tex> и <tex>v</tex> будет ниже, чем наименьший общий предок <tex>u</tex> и <tex>x</tex>.
}}

Для того, чтобы учитывать вершины с одинаковым цветом, для каждой вершины требуется найти наименьшего общего предка этой вершины и вершин, предшествующих данной по времени выхода с таким же цветом и вычесть из значения этого предка <tex>1</tex>. Так, при конечном подсчете значение наименьшего общего предка данной вершины и любой вершины, предшествующей данной с тем же цветом, уменьшится на <tex>1</tex>, так как наименьший предок этой точки и любой предшествующей того же цвета находится на пути из наименьшего общего предка этой группы точек. А как раз это и требуется <tex>-</tex> для каждой пары точек одного цвета учесть данный факт в их наименьшем общем предке. И по лемме, чтобы взять наименьшего общего предка текущей вершины и всех предшествующих вершин с данным цветом, надо взять наименьшего общего предка данной вершины и предыдущей вершины с данным цветом, он будет наименьшим для всех.

[[Файл:hugh.png|300px]]

==См. также==
*[[Алгоритм Тарьяна поиска LCA за O(1) в оффлайн]]

*[[Метод двоичного подъема]]

[[Категория: Алгоритмы и структуры данных]]

[[Категория: Задача о наименьшем общем предке]]

Алгоритм Хьюи

2016-01-16T18:17:34Z

Nikitaevg:

{{Задача
|definition=Дано [[Основные определения теории графов#oriented_grath|ориентированный]] [[Дерево, эквивалентные определения#tree|дерево]], вершины которого раскрашены в цвета. Найти <tex>dc:V\rightarrow \{1\ldots k\}</tex>, где <tex>dc(u) -</tex> число различных цветов в поддереве с корнем в вершине <tex>u</tex>. Время работы: <tex>O(V)</tex>}}

__TOC__

==Алгоритм решения==
Будем в каждой вершине дерева хранить по числу, так, чтобы для каждого поддерева ответом была сумма всех значений в вершинах в данном поддереве. Для начала каждой вершине в качестве значения присвоим <tex>1</tex>. Теперь, если бы все вершины имели различные цвета, надо было бы пройти снизу вверх по дереву и просуммировать для каждой вершины числа, записанные в её детях. Но некоторые вершины будут иметь одинаковые цвета, и это надо как-то учитывать. Для этого запустим [[Обход в глубину, цвета вершин|обход в глубину]]. Также будем хранить для каждого цвета последнюю посещенную вершину данного цвета в массиве <tex>last[k]</tex>. Теперь, заходя в <tex>i</tex>-ую вершину с цветом <tex>col</tex>, смотрим: если вершина с таким цветом еще не встречалась, то просто присваиваем <tex>last[col]=i</tex>, иначе, если вершина с данным цветом уже встречалась, то находим [[Сведение задачи LCA к задаче RMQ|наименьшего общего предка]] данной вершины и последней вершины с таким цветом и вычитаем из их предка <tex>1</tex>, присваиваем <tex>last[col]=i</tex>. Теперь при выходе из вершины можно просуммировать числа в ее детях и получить ответ для данной вершины, так как для нее все дети уже подсчитаны. Таким образом, алгоритм запускает один обход в глубину, на каждой итерации которого ищет наименьшего общего предка. Если искать наименьшего общего предка за <tex>O(1)</tex>, к примеру [[Алгоритм Фарака-Колтона и Бендера|алгоритмом Фарака-Колтона и Бендера]], то сложность работы алгоритма будет <tex>O(V)</tex>.

==Пример==

{| class = "wikitable"
! № шага !! Изображение !! Описание
|-align="center"
| 0
| [[Файл:algo_0.png|300px]]
| Расставим у каждой вершины <tex>1</tex>.
|-align="center"
| 1
| [[Файл:algo_1.png|300px]]
| Выходим из <tex>8</tex>-ой вершины. Так как желтых вершин еще не было, запоминаем её как последнюю желтую.
|-align="center"
| 2
| [[Файл:algo_2.png|300px]]
| <tex>4</tex>-ая вершина. Последняя желтая <tex>-\ 8</tex>-ая. Их LCA <tex>\ -4</tex>-ая вершина. Вычитаем из значения <tex>4</tex>-ой вершины <tex>1</tex> и запоминаем текущую как последнюю желтую.
|-align="center"
| 8
| [[Файл:8.png|300px]]
| Пропустим несколько тривиальных шагов. Выходим из <tex>11</tex>-ой вершины. Последней посещенной зеленой была <tex>5</tex>-ая (не <tex>3</tex>-я). Вычитаем из их LCA (<tex>1</tex>-ой вершины) <tex>1</tex> и запоминаем <tex>11</tex>-ую как последнюю зеленую.
|-align="center"
| 9
| [[Файл:9.png|300px]]
| Выходим из <tex>7</tex>-ой вершины. Последней синей была <tex>2</tex>-ая. Вычтем из их LCA <tex>1</tex> и запомним <tex>7</tex>-ую как последнюю синюю.
|-align="center"
| суммирование
| [[Файл:algo_12.png|300px]]
|Пропустим еще два шага. В результате суммирования получаем в каждой вершине ответ на задачу для поддерева.
|-
|}

==Псевдокод==
'''int''' col[MAX_COL], used[MAX_N], sum[MAX_N]

'''func''' dfs('''Node''' v)''':'''
used[v] = true
'''for''' <tex>u \in v.children</tex>
'''if''' !used[u]
dfs(u)
sum[v] += sum[u]
'''if''' last[col[v]] != -1
sum[lca(v, last[col[v]])]--
last[col[v]] = v

'''func''' hugh('''int''' n, '''int''' k, '''Node''' root)''':'''
'''for''' <tex>v \in V</tex>
used[v] = false
sum[v] = 1
'''for''' i = 1 to k
last[i] = -1
dfs(root)

==Обоснование корректности==
{{Лемма
|statement = Наименьшим общим предком вершины и группы вершин, предшествующих по времени выхода, является наименьший общий предок данной вершины и последней, предшествующей ей из группы.
|proof = Рассмотрим дерево как последовательность букв, когда при входе в вершину или выходе из нее записывается ее буква. Пусть рассматриваемая вершина <tex>-\ u</tex>, а последняя рассмотренная из той же группы <tex> -\ v</tex>, их наименьший общий предок <tex>-\ w</tex>. Рассмотрим два варианта расположения этих двух вершин.

[[Файл:proof_1.png|200px]]
[[Файл:proof_2.png|200px]]

Теперь возьмем вершину <tex>z</tex>, которая встречается до выхода из <tex>v</tex>. Перебрав несложные пять случаев, можно легко убедиться, что наименьший общий предок <tex>u</tex> и <tex>v</tex> будет ниже, чем наименьший общий предок <tex>u</tex> и <tex>x</tex>.
}}

Для того, чтобы учитывать вершины с одинаковым цветом, для каждой вершины требуется найти наименьшего общего предка этой вершины и вершин, предшествующих данной по времени выхода с таким же цветом и вычесть из значения этого предка <tex>1</tex>. Так, при конечном подсчете значение наименьшего общего предка данной вершины и любой вершины, предшествующей данной с тем же цветом, уменьшится на <tex>1</tex>, так как наименьший предок этой точки и любой предшествующей того же цвета находится на пути из наименьшего общего предка этой группы точек. А как раз это и требуется - для каждой пары точек одного цвета учесть данный факт в их наименьшем общем предке. И по лемме, чтобы взять наименьшего общего предка текущей вершины и всех предшествующих вершин с данным цветом, надо взять наименьшего общего предка данной вершины и предыдущей вершины с данным цветом, он будет наименьшим для всех.

[[Файл:hugh.png|300px]]

==См. также==
[[Алгоритм Тарьяна поиска LCA за O(1) в оффлайн]]

[[Метод двоичного подъема]]

[[Категория: Алгоритмы и структуры данных]]

Файл:Algo 12.png

2016-01-16T17:22:30Z

Nikitaevg:

Файл:Algo 11.png

2016-01-16T17:18:44Z

Nikitaevg:

Файл:9.png

2016-01-16T17:06:33Z

Nikitaevg:

Файл:8.png

2016-01-16T16:52:19Z

Nikitaevg:

Файл:4.png

2016-01-16T16:43:58Z

Nikitaevg:

Файл:Algo 3.png

2016-01-16T16:40:39Z

Nikitaevg: загружена новая версия «Файл:Algo 3.png»

Файл:Algo 2.png

2016-01-16T16:30:58Z

Nikitaevg: загружена новая версия «Файл:Algo 2.png»

Файл:Algo 1.png

2016-01-16T16:27:47Z

Nikitaevg: загружена новая версия «Файл:Algo 1.png»

Алгоритм Хьюи

2016-01-02T08:06:18Z

Nikitaevg:

{{Задача
|definition=Дано ориентированное дерево, вершины которого раскрашены в цвета. Найти <tex>dc:V\rightarrow \{1..k\}</tex>, где <tex>dc(u) -</tex> число различных цветов в поддереве с корнем в вершине <tex>u</tex>. Время работы: <tex>O(V)</tex>}}

__TOC__

==Алгоритм решения==
Для начала в каждой вершине поставим 1. Теперь, если бы все вершины имели различные цвета, надо было бы пройти снизу вверх по дереву и просуммировать для каждой вершины числа, записанные в ее детях. Но некоторые вершины будут иметь одинаковые цвета, и это надо как-то учитывать. Для этого запустим [[Обход в глубину, цвета вершин|обход в глубину]]. Также будем хранить для каждого цвета последнюю посещенную вершину данного цвета в массиве <tex>last[k]</tex>. Теперь, заходя в <tex>i</tex>-ую вершину с цветом <tex>col</tex>, смотрим: если вершина с таким цветом еще не встречалась, то просто записываем в <tex>last[col]\ i</tex>, иначе, если вершина с данным цветом уже встречалась, то находим [[Сведение задачи LCA к задаче RMQ|наименьшего общего предка]] данной вершины и последней вершины с таким цветом и вычитаем из их предка 1, и записываем в <tex>last[col]\ i</tex>. Теперь при выходе из вершины можно просуммировать числа в ее детях и получить ответ для данной вершины, так как для нее все дети уже подсчитаны. Таким образом, алгоритм запускает один обход в глубину, на каждой итерации которого ищет наименьшего общего предка. Если искать наименьшего общего предка за <tex>O(1)</tex>, к примеру [[Алгоритм Фарака-Колтона и Бендера|алгоритмом Фарака-Колтона и Бендера]], то сложность работы алгоритма будет <tex>O(V)</tex>

Пример:

Шаг 0:
[[Файл:algo_0.png|200px]]

Шаг 1:
[[Файл:algo_1.png|200px]]

Шаг 2:
[[Файл:algo_2.png|200px]]

Шаг 3:
[[Файл:algo_3.png|200px]]

Шаг n:
[[Файл:algo_n-1.png|200px]]

Окончательное суммирование
[[Файл:algo_n.png|200px]]

==Псевдокод==
'''func''' dfs (Node v)''':'''
used[v] := true
'''for''' <tex>u \in v.children</tex>
'''if''' !used[u]
dfs(u)
sum[v] := sum[v] + sum[u]
'''if''' last[col[v]] != -1
sum[lca(v, last[col[v]])] -= 1
last[col[v]] := v

'''func''' hugh (int n, int k, Node root)''':'''
'''for''' <tex>v \in V</tex>
used[v] := false
sum[v] := 1
'''for''' k := 1 to k
last[k] := -1
dfs (root)

==Обоснование корректности==
{{Лемма
|statement = Наименьшим общим предком вершины и группы вершин, предшествующих по времени выхода, является наименьший общий предок данной вершины и последней, предшествующей ей из группы.
|proof = Рассмотрим дерево как последовательность букв, когда при входе в вершину или выходе из нее записывается ее буква. Пусть рассматриваемая вершина <tex>-\ u</tex>, а последняя рассмотренная из той же группы <tex> -\ v</tex>, их наименьший общий предок <tex>-\ w</tex>. Рассмотрим два варианта расположения этих двух вершин.

[[Файл:proof_1.png|200px]]
[[Файл:proof_2.png|200px]]

Теперь возьмем вершину <tex>z</tex>, которая встречается до выхода из <tex>v</tex>. Перебрав несложные пять случаев, можно легко убедиться, что наименьший общий предок <tex>u</tex> и <tex>v</tex> будет ниже, чем наименьший общий предок <tex>u</tex> и <tex>x</tex>.
}}

Для того, чтобы учитывать вершины с одинаковым цветом, для каждой вершины требуется найти наименьшего общего предка этой вершины и вершин, предшествующих данной по времени выхода с таким же цветом и вычесть из значения этого предка 1. Так, при конечном подсчете значение наименьшего общего предка данной вершины и любой вершины, предшествующей данной с тем же цветом, уменьшится на 1, так как наименьший предок этой точки и любой предшествующей того же цвета находится на пути из наименьшего общего предка этой группы точек. А как раз это и требуется - для каждой пары точек одного цвета учесть данный факт в их наименьшем общем предке. И по лемме, чтобы взять наименьшего общего предка текущей вершины и всех предшествующих вершин с данным цветом, надо взять наименьшего общего предка данной вершины и предыдущей вершины с данным цветом, он будет наименьшим для всех.

[[Файл:hugh.png|300px]]

==См. также==

Алгоритм Хьюи

2015-12-30T19:36:37Z

Nikitaevg:

{{Задача
|definition=Дано ориентированное дерево, вершины которого раскрашены в цвета. Найти <tex>dc:V\rightarrow \{1..k\}</tex>, где <tex>dc(u) -</tex> число различных цветов в поддереве с корнем в вершине <tex>u</tex>. Время работы: <tex>O(V)</tex>}}

__TOC__

==Алгоритм решения==
Для начала в каждой вершине поставим единицу. Теперь, если бы все вершины имели различные цвета, надо было бы пройти снизу вверх по дереву и просуммировать для каждой вершины числа, записанные в ее детях. Но некоторые вершины будут иметь одинаковые цвета, и это надо как-то учитывать. Для этого запустим [[Обход в глубину, цвета вершин|обход в глубину]]. Также будем хранить для каждого цвета последнюю посещенную вершину данного цвета в массиве <tex>last[k]</tex>. Теперь, заходя в <tex>i</tex>-ую вершину с цветом <tex>col</tex>, смотрим: если вершина с таким цветом еще не встречалась, то просто записываем в <tex>last[col]\ i</tex>, иначе, если вершина с данным цветом уже встречалась, то находим [[Сведение задачи LCA к задаче RMQ|наименьшего общего предка]] данной вершины и последней вершины с таким цветом и вычитаем из их предка 1, и записываем в <tex>last[col]\ i</tex>. Теперь при выходе из вершины можно просуммировать числа в ее детях и получить ответ для данной вершины, так как для нее все дети уже подсчитаны.

Пример:

Шаг 0:
[[Файл:algo_0.png|200px]]

Шаг 1:
[[Файл:algo_1.png|200px]]

Шаг 2:
[[Файл:algo_2.png|200px]]

Шаг 3:
[[Файл:algo_3.png|200px]]

Шаг n:
[[Файл:algo_n-1.png|200px]]

Окончательное суммирование
[[Файл:algo_n.png|200px]]

==Псевдокод==
'''func''' dfs (Node v)''':'''
used[v] := true
'''for''' <tex>u \in v.children</tex>
'''if''' !used[u]
dfs(u)
sum[v] := sum[v] + sum[u]
'''if''' last[col[v]] != -1
sum[lca(v, last[col[v]])] -= 1
last[col[v]] := v

'''func''' hugh (int n, int k, Node root)''':'''
'''for''' <tex>v \in V</tex>
used[v] := false
sum[v] := 1
'''for''' k := 1 to k
last[k] := -1
dfs (root)

==Обоснование корректности==
{{Лемма
|statement = Наименьшим общим предком вершины и группы вершин, предшествующих по времени выхода, является наименьший общий предок данной вершины и последней, предшествующей ей из группы.
|proof = Рассмотрим дерево как последовательность букв, когда при входе в вершину или выходе из нее записывается ее буква. Пусть рассматриваемая вершина <tex>-\ u</tex>, а последняя рассмотренная из той же группы <tex> -\ v</tex>, их наименьший общий предок <tex>-\ w</tex> Рассмотрим два варианта расположения этих двух вершин.

[[Файл:proof_1.png|200px]]
[[Файл:proof_2.png|200px]]

Теперь возьмем вершину <tex>z</tex>, которая встречается до выхода из <tex>v</tex>. Перебрав несложные пять случаев, можно легко убедиться, что наименьший общий предок <tex>u</tex> и <tex>v</tex> будет ниже, чем наименьший общий предок <tex>u</tex> и <tex>x</tex>.
}}

Для того, чтобы учитывать две вершины с одинаковым цветом, для каждой вершины требуется найти наименьшего общего предка этой вершины и вершин, предшествующих данной по времени выхода с таким же цветом и вычесть из значения этого предка 1. Так, при конечном подсчете значение наименьшего общего предка данной вершины и любой вершины, предшествующей данной с тем же цветом, уменьшится на единицу, так как наименьший предок этой точки и любой предшествующей того же цвета находится на пути из наименьшего общего предка всех этих вершин до корня. А как раз это и требуется - для каждой пары точек одного цвета учесть данный факт в их наименьшем общем предке. И по лемме, чтобы взять наименьшего общего предка текущей вершины и всех предшествующих вершин с данным цветом, надо взять наименьшего общего предка данной вершины и предыдущей вершины с данным цветом, он будет наименьшим для всех.

[[Файл:hugh.png|300px]]

Алгоритм Хьюи

2015-12-30T19:27:02Z

Nikitaevg: Новая страница: «{{Задача |definition=Дано ориентированное дерево, вершины которого раскрашены в цвета. Найти <t...»

{{Задача
|definition=Дано ориентированное дерево, вершины которого раскрашены в цвета. Найти <tex>dc:V\rightarrow \{1..k\}</tex>, где <tex>dc(u) -</tex> число различных цветов в поддереве с корнем в вершине <tex>u</tex>. Время работы: <tex>O(V)</tex>}}

__TOC__

==Алгоритм решения==
Для начала в каждой вершине поставим единицу. Теперь, если бы все вершины имели различные цвета, надо было бы пройти снизу вверх по дереву и просуммировать для каждой вершины числа, записанные в ее детях. Но некоторые вершины будут иметь одинаковые цвета, и это надо как-то учитывать. Для этого запустим обход в глубину. Также будем хранить для каждого цвета последнюю посещенную вершину данного цвета в массиве <tex>last[k]</tex>. Теперь, заходя в <tex>i</tex>-ую вершину с цветом <tex>col</tex>, смотрим: если вершина с таким цветом еще не встречалась, то просто записываем в <tex>last[col]\ i</tex>, иначе, если вершина с данным цветом уже встречалась, то находим наименьшего общего предка данной вершины и последней вершины с таким цветом и вычитаем из их предка 1, и записываем в <tex>last[col]\ i</tex>. Теперь при выходе из вершины можно просуммировать числа в ее детях и получить ответ для данной вершины, так как для нее все дети уже подсчитаны.

Пример:

Шаг 0:
[[Файл:algo_0.png|200px]]

Шаг 1:
[[Файл:algo_1.png|200px]]

Шаг 2:
[[Файл:algo_2.png|200px]]

Шаг 3:
[[Файл:algo_3.png|200px]]

Шаг n:
[[Файл:algo_n-1.png|200px]]

Окончательное суммирование
[[Файл:algo_n.png|200px]]

==Псевдокод==
'''func''' dfs (Node v)''':'''
used[v] := true
'''for''' <tex>u \in v.children</tex>
'''if''' !used[u]
dfs(u)
sum[v] := sum[v] + sum[u]
'''if''' last[col[v]] != -1
sum[lca(v, last[col[v]])] -= 1
last[col[v]] := v

'''func''' hugh (int n, int k, Node root)''':'''
'''for''' <tex>v \in V</tex>
used[v] := false
sum[v] := 1
'''for''' k := 1 to k
last[k] := -1
dfs (root)

==Обоснование корректности==
{{Лемма
|statement = Наименьшим общим предком вершины и группы вершин, предшествующих по времени выхода, является наименьший общий предок данной вершины и последней, предшествующей ей из группы.
|proof = Рассмотрим дерево как последовательность букв, когда при входе в вершину или выходе из нее записывается ее буква. Пусть рассматриваемая вершина <tex>-\ u</tex>, а последняя рассмотренная из той же группы <tex> -\ v</tex>, их наименьший общий предок <tex>-\ w</tex> Рассмотрим два варианта расположения этих двух вершин.

[[Файл:proof_1.png|200px]]
[[Файл:proof_2.png|200px]]

Теперь возьмем вершину <tex>z</tex>, которая встречается до выхода из <tex>v</tex>. Перебрав несложные пять случаев, можно легко убедиться, что наименьший общий предок <tex>u</tex> и <tex>v</tex> будет ниже, чем наименьший общий предок <tex>u</tex> и <tex>x</tex>.
}}

Для того, чтобы учитывать две вершины с одинаковым цветом, для каждой вершины требуется найти наименьшего общего предка этой вершины и вершин, предшествующих данной по времени выхода с таким же цветом и вычесть из значения этого предка 1. Так, при конечном подсчете значение наименьшего общего предка данной вершины и любой вершины, предшествующей данной с тем же цветом, уменьшится на единицу, так как наименьший предок этой точки и любой предшествующей того же цвета находится на пути из наименьшего общего предка всех этих вершин до корня. А как раз это и требуется - для каждой пары точек одного цвета учесть данный факт в их наименьшем общем предке. И по лемме, чтобы взять наименьшего общего предка текущей вершины и всех предшествующих вершин с данным цветом, надо взять наименьшего общего предка данной вершины и предыдущей вершины с данным цветом, он будет наименьшим для всех.

[[Файл:hugh.png|300px]]

Файл:Algo 3.png

2015-12-30T19:23:54Z

Nikitaevg: загружена новая версия «Файл:Algo 3.png»

Файл:Algo 3.png

2015-12-30T19:22:05Z

Nikitaevg:

Файл:Hugh.png

2015-12-30T19:11:45Z

Nikitaevg:

Файл:Algo n.png

2015-12-30T18:49:30Z

Nikitaevg: