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

http://neerc.ifmo.ru/wiki/api.php?action=feedcontributions&feedformat=atom&user=System29a Викиконспекты - Вклад участника [ru] 2026-06-11T17:51:51Z Вклад участника MediaWiki 1.30.0 http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:System29a&diff=27119 Участник:System29a 2012-06-27T12:35:09Z

<p>System29a: </p> <hr /> <div>Артём Попов, 2538<br /> <br /> [[Участник:System29a/Вычисление погрешностей]]<br /> <br /> {{Теорема<br /> |author=Крупина<br /> |statement= <tex>a\!\not\vdots\: b \Longrightarrow \not\exists n \in \mathbb{Z}: a = b \cdot n</tex> (поделить нельзя неделимое)<br /> }}</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5:%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%96%D0%BE%D1%80%D0%B4%D0%B0%D0%BD%D0%B0&diff=27082 Обсуждение:Теорема Жордана 2012-06-26T17:07:38Z

<p>System29a: </p> <hr /> <div>Правда ли, что <tex>\|f\|_c</tex> {{---}} супремум? --[[Участник:Komarov|Андрей Комаров]] 21:41, 25 июня 2012 (GST)<br /> : Правда --[[Участник:Komarov|Андрей Комаров]] 21:43, 25 июня 2012 (GST)<br /> :: Спасибо! --[[Участник:Komarov|Андрей Комаров]] 21:43, 25 июня 2012 (GST)<br /> <br /> В первом утверждении бред на бреде и бредом погоняет. В условии — суммы Фейера, а в доказательстве — частичные суммы. Рассматривается норма функции, не являющейся непрерывной, в пространстве непрерывных функций. Полиномом наилучшего приближения <tex> f </tex> в <tex> C </tex> является обычный полином, а не тригонометрический, соответственно, теорема Вейерштрасса для него неприменима. Переход от модуля к норме тоже какой-то мутный. Что делать будем? --[[Участник:Sementry|Мейнстер Д.]] 20:03, 26 июня 2012 (GST)<br /> : \sigma (f) — ряд Фурье, а не суммы Фейера. И Виталя с Артемом говорят, что то, что мы берем норму || ||_C у функции не в C — это нормально.--[[Участник:Dgerasimov|Дмитрий Герасимов]] 20:40, 26 июня 2012 (GST)<br /> <br /> Ребят, мне кажется, или доказательство утверждения про равномерную сходимость ряда фурье нифига не расписано? --[[Участник:System29a|System29a]] 21:07, 26 июня 2012 (GST)</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%90%D1%85%D0%BE-%D0%9A%D0%BE%D1%80%D0%B0%D1%81%D0%B8%D0%BA&diff=26418 Алгоритм Ахо-Корасик 2012-06-21T19:43:31Z

<p>System29a: </p> <hr /> <div>== Задача алгоритма ==<br /> Найти для каждого образца из заданного множества образцов (размером <tex>k</tex>) все его вхождения в текст за время <tex>O(m+n+a)</tex>, где <tex>m</tex> {{---}} суммарная длина образцов, <tex>n</tex> {{---}} длина текста, <tex>a</tex> {{---}} размер ответа (количество пар). В худшем случае <tex>a=nk</tex>, но на практике он встречается редко.<br /> <br /> == Шаг 1 ==<br /> Строим [[Бор|бор]] из образцов.<br /><br /> Построение выполняется за время <tex>O(m)</tex>, где <tex>m</tex> {{---}} суммарная длина образцов.<br /> <br /> === Пример построенного бора ===<br /> Бор для набора образцов {he, she, his, hers}:<br /><br /> [[Файл:Aho-corasick1.jpg‎]]<br /> <br /> == Шаг 2 ==<br /> Превращаем бор в автомат.<br /><br /> Узлы бора становятся состояниями автомата; корень {{---}} начальное состояние.<br /><br /> Узлы бора, в которых заканчиваются образцы, становятся терминалами.<br /><br /><br /> Для переходов по автомату заведём в узлах несколько функций:<br /><br /> 1) <tex>parent(u)</tex> {{---}} возвращает родителя вершины <tex>u</tex>;<br /><br /> 2) <tex>\pi(u) = \delta(\pi(parent(u)), c)</tex> {{---}} суффиксная ссылка; здесь <tex>u</tex> {{---}} сын <tex>parent(u)</tex> по символу <tex>c</tex>;<br /><br /> 3) <tex>\delta(u, c) = <br /> \begin{cases}<br /> v\text{, if $v$ is son by symbol $c$ in trie;}\\<br /> \delta(\pi(u), c)\text{, else.}<br /> \end{cases}</tex> {{---}} функция перехода.<br /><br /><br /> Суффиксная ссылка <tex>\pi(u) = v</tex>, если <tex>[v]</tex> {{---}} максимальный суффикс <tex>[u]</tex>, <tex>[v]\neq[u]</tex>. Обозначение: <tex>[u]</tex> {{---}} слово, приводящее в вершину <tex>u</tex> в боре.<br /><br /> Функции перехода и суффиксные ссылки можно найти либо алгоритмом обхода в глубину с ленивыми вычислениями, либо с помощью алгоритма обхода в ширину.<br /> === Пример автомата Ахо-Корасик ===<br /> [[Файл:Aho-corasick2.jpg]]<br /><br /> Пунктиром обозначены суффиксные ссылки. Из вершин, для которых они не показаны, суффиксные ссылки идут в корень.<br /> <br /> == Шаг 3 ==<br /> Построение сжатых суффиксных ссылок.<br /><br /> <tex>up(u) = <br /> \begin{cases}<br /> \pi(u)\text{, if $\pi(u)$ is terminal;}\\<br /> \emptyset\text{, if $\pi(u)$ is root;}\\<br /> up(\pi(u))\text{, else.}<br /> \end{cases}</tex> {{---}} сжатая суффиксная ссылка, т.е. ближайшее допускающее состояние (терминал) перехода по суффиксным ссылкам.<br /><br /><br /> Сжатые суффиксные ссылки могут отыскиваться при помощи ленивой рекурсии.<br /> <br /> == Использование автомата ==<br /> По очереди просматриваем символы текста. Для очередного символа <tex>c</tex> переходим из текущего состояния <tex>u</tex> в состояние, которое вернёт функция <tex>\delta(u, c)</tex>. Оказавшись в новом состоянии, отмечаем по сжатым суффиксным ссылкам образцы, которые нам встретились и их позицию (если требуется). Если новое состояние является терминалом, то соответствующие ему образцы тоже отмечаем.<br /><br /> ''Примечание.'' Если требуется найти только первое вхождение образца в текст, то существенно ускорить работу алгоритма могут пометки о посещённости узла, т.е. если узел посещён, то не переходить по сжатым суффиксным ссылкам. Вместо хранения пометок можно просто сбрасывать сжатую суффиксную ссылку.<br /> <br /> == Пример реализации ==<br /> Ниже представлена реализация на C++ некоторых функций (используется ленивая рекурсия).<br /><br /><br /> '''Структура вершины:'''<br /> struct Node {<br /> Node* son[SZ]; <font color=green>// массив сыновей; SZ - это размер алфавита</font><br /> Node* go[SZ]; <font color=green>// массив переходов (запоминаем переходы в ленивой рекурсии)</font><br /> Node* parent; <font color=green>// вершина родитель</font><br /> Node* suffLink; <font color=green>// суффиксная ссылка (вычисляем в ленивой рекурсии)</font><br /> Node* up; <font color=green>// сжатая суффиксная ссылка</font><br /> char charToParent; <font color=green>// символ, ведущий к родителю</font><br /> bool leaf; <font color=green>// флаг, является ли вершина терминалом</font><br /> std::vector<int> leafPatternNumber; <font color=green>// номера образцов, за которые отвечает терминал</font><br /> };<br /> '''Функция, для вычисления суффиксной ссылки:'''<br /> Node* getSuffLink(Node* v) {<br /> if (!v->suffLink) { <font color=green>// если суффиксная ссылка ещё не вычислена</font><br /> if (v == root || v->parent == root) {<br /> v->suffLink = root;<br /> } else {<br /> v->suffLink = getGo(getSuffLink(v->parent), v->charToParent);<br /> }<br /> }<br /> return v->suffLink;<br /> }<br /> '''Функция, для вычисления перехода:'''<br /> Node* getGo(Node* v, char c) {<br /> if (!v->go[c]) { <font color=green>// если переход по символу c ещё не вычислен</font><br /> if (v->son[c]) {<br /> v->go[c] = v->son[c];<br /> } else {<br /> v->go[c] = (v == root) ? root : getGo(getSuffLink(v), c);<br /> }<br /> }<br /> return v->go[c];<br /> }<br /> '''Функция, для вычисления сжатой суффиксной ссылки:'''<br /> Node* getUp(Node* v) {<br /> if (!v->up) { <font color=green>// если сжатая суффиксная ссылка ещё не вычислена</font><br /> if (getSuffLink(v)->leaf) {<br /> v->up = getSuffLink(v);<br /> } else if (getSuffLink(v) == root) {<br /> v->up = 0;<br /> } else {<br /> v->up = getUp(getSuffLink(v));<br /> }<br /> }<br /> return v->up;<br /> }<br /> '''Функция, для добавление образца в бор:'''<br /> void addString(std::string const& s, int patternNumber) {<br /> Node* cur = root;<br /> for (int i = 0; i < s.length(); ++i) {<br /> char c = s[i] - 'a';<br /> if (cur->son[c] == 0) {<br /> cur->son[c] = new Node;<br /> <font color=green>/* здесь также нужно обнулить указатели на переходы и сыновей */</font><br /> cur->son[c]->suffLink = 0;<br /> cur->son[c]->up = 0;<br /> cur->son[c]->parent = cur;<br /> cur->son[c]->charToParent = c;<br /> cur->son[c]->leaf = false;<br /> }<br /> cur = cur->son[c];<br /> }<br /> cur->leaf = true;<br /> cur->leafPatternNumber.push_back(patternNumber);<br /> }<br /> '''Функция, для процессинга текста (поиск, встречается образец или нет):'''<br /> void processText(std::string const& t, std::vector<bool>& found) { <font color=green>// found - это вектор, длина которого равна количеству образцов</font><br /> found.assign(w, false); <font color=green>// w - количество образцов</font><br /> Node* cur = root;<br /> for (int i = 0; i < t.length(); ++i) {<br /> char c = t[i] - 'a';<br /> cur = getGo(cur, c);<br /> for (int j = 0; j < cur->leafPatternNumber.size(); ++j) {<br /> found[cur->leafPatternNumber[j]] = true;<br /> }<br /> <font color=green>/* В этом месте кода должен выполняться переход по '''сжатой''' суффиксной ссылке getUp(cur). Для вершины,<br /> обнаруженной по ней тоже ставим, что она найдена, затем повторяем для её сжатой суффиксной ссылки<br /> и так до корня. Хорошо ускорит программу сброс сжатых суффиксных ссылок для посещённых вершин. */</font><br /> }<br /> }<br /> Кроме этих функций требуется инициализация, но она имеет отношение только к кодированию, поэтому здесь приведена не будет.<br /> <br /> == Источники ==<br /> * http://e-maxx.ru/algo/aho_corasick<br /> * http://aho-corasick.narod.ru/<br /> <br /> [[Категория: Дискретная математика и алгоритмы]] <br /> [[Категория: Поиск подстроки в строке]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%91%D0%BE%D1%80&diff=26415 Бор 2012-06-21T19:24:58Z

<p>System29a: /* Сжатый бор */</p> <hr /> <div>'''Бор''' (trie, луч, нагруженное дерево) — структура данных для хранения набора строк, представляющая из себя подвешенное дерево с символами на ребрах. Строки получаются прохождением из корня по рёбрам, записывая соответствующие им символы, до терминальной вершины. Размер бора линейно<br /> зависит от суммы длин всех строк, а поиск в бору занимает время, пропорциональное длине образца.<br /> <br /> ==Пример==<br /> Бор для набора образцов {he, she, his, hers}:<br /><br /> [[Файл:Aho-corasick1.jpg‎]]<br /> <br /> ==Построение==<br /> Пусть <tex>P = \{P_1,...,P_k\} </tex> — набор строк, называемый словарем.<br /> <br /> Пусть <tex>n = \sum_{i=1}^k|P_i|</tex>.<br /> <br /> Начинаем с дерева из одной вершины (корня); добавляем шаблоны <tex>P_i</tex> один за другим:<br /> Следуем из корня по ребрам, отмеченным буквами из <tex>P_i</tex>, пока возможно.<br /> <br /> Если <tex>P_i</tex> заканчивается в <tex>v</tex>, сохраняем идентификатор <tex>P_i</tex> (например, <tex>i</tex>) в <tex>v</tex> и отмечаем вершину <tex>v</tex> как терминальную.<br /> <br /> Если ребра, отмеченного очередной буквой <tex>P_i</tex> нет, то создаем новые ребра и вершины для всех оставшихся символов <tex>P_i</tex>.<br /> <br /> Это занимает, очевидно, <tex>O (|P_1| + ... + |P_k|) = O (n)</tex> времени.<br /> <br /> ==Поиск строки в бору==<br /> Поиск строки <tex>S</tex> в бору: начинаем в корне, идем по ребрам, отмеченным символами <tex>S</tex>, пока возможно.<br /> Если с последним символом <tex>S</tex> мы приходим в вершину с сохраненным идентификатором, то <tex>S</tex> — слово из словаря.<br /> Если в какой-то момент ребра, отмеченного нужным символом, не находится, то строки S в словаре нет.<br /> Ясно, что это занимает <tex>O (|S|)</tex> времени. Таким образом, бор — это эффективный способ хранить словарь и искать в нем слова.<br /> <br /> ==Сжатый бор==<br /> Сжатый бор — структура данных для хранения набора строк, отличающаяся от бора<br /> следующим улучшением: если у некоторой вершины исходящая степень равна 1, то эту<br /> вершину, ребро, входящее в нее, и ребро, исходящее из нее, можно объединить в одно<br /> ребро с более чем одним символом.<br /> <br /> == Литература ==<br /> * Томас Х. Кормен, Чарльз И. Лейзерсон, Рональд Л. Ривест, Клиффорд Штайн Алгоритмы: построение и анализ — 2-е изд. — М.: «Вильямс», 2007. — ISBN 5-8489-0857-4<br /> <br /> [[Категория: Дискретная математика и алгоритмы]] <br /> [[Категория: Поиск подстроки в строке]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26410 J2pij1Lmax 2012-06-21T19:15:03Z

<p>System29a: /* Описание решения */</p> <hr /> <div>{{в разработке}}<br /> ==Условие задачи==<br /> В нотации Грэхема задача носит название <tex>J2\mid p_{ij} = 1\mid L_{max}</tex><br /> <br /> Дано <tex>n</tex> работ <tex>i = 1,\ldots,n</tex> и две машины, обозначенные как <tex>A</tex> и <tex>B</tex>. <br /> <br /> <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij}</tex> <tex>(j = 1,\ldots n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex> операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>.<br /> <br /> Задача заключается в том, что для данного каждой <tex>i</tex>-той работе дедлайна <tex>d_i \ge 0</tex> необходимо найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex><br /> <br /> ==Описание решения==<br /> Судя по условию, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машиной, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхнюю границу момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два списка <tex>A(t)</tex> и <tex>B(t) (t = 0,\ldots,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex> <tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>C_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,\ldots,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,\ldots,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i</tex> <tex>L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующий список (на самом деле это должен быть heap для хорошей асимптотики) <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j</tex> <tex>(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру списка <tex>k</tex> порядку, где операции из одного списка могут выполнятся в произвольном порядке.<br /> <br /> ==Алгоритм==<br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответствующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> '''main()'''<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\setminus\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z \setminus\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> '''schedule(<tex>O_{ij}</tex>)'''<br /> '''if''' <tex>\mu_{ij}</tex> == A<br /> '''if''' T1 < LAST(i) <br /> t = LAST(i)<br /> A(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T1;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>A(T_1)</tex> <tex>\ne \emptyset</tex><br /> T1 = T1 + 1;<br /> '''else'''<br /> '''if''' T2 < LAST(i)<br /> t = LAST(i)<br /> B(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T2;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>B(T_2) \ne \emptyset</tex><br /> T2 = T2 + 1;<br /> LAST(i) = t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex><br /> <br /> <br /> ==Источники==<br /> * Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 180 стр. {{---}} ISBN 978-3-540-69515-8<br /> <br /> [[Категория: Дискретная математика и алгоритмы]]<br /> [[Категория: Теория расписаний]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26409 J2pij1Lmax 2012-06-21T19:10:56Z

<p>System29a: /* Описание решения */</p> <hr /> <div>{{в разработке}}<br /> ==Условие задачи==<br /> В нотации Грэхема задача носит название <tex>J2\mid p_{ij} = 1\mid L_{max}</tex><br /> <br /> Дано <tex>n</tex> работ <tex>i = 1,\ldots,n</tex> и две машины, обозначенные как <tex>A</tex> и <tex>B</tex>. <br /> <br /> <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij}</tex> <tex>(j = 1,\ldots n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex> операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>.<br /> <br /> Задача заключается в том, что для данного каждой <tex>i</tex>-той работе дедлайна <tex>d_i \ge 0</tex> необходимо найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex><br /> <br /> ==Описание решения==<br /> Судя по условию, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машиной, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхнюю границу момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два списка <tex>A(t)</tex> и <tex>B(t) (t = 0,\ldots,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex> <tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,\ldots,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,\ldots,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i</tex> <tex>L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующий список (на самом деле это должен быть heap для хорошей асимптотики) <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j</tex> <tex>(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру списка <tex>k</tex> порядку, где операции из одного списка могут выполнятся в произвольном порядке.<br /> <br /> ==Алгоритм==<br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответствующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> '''main()'''<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\setminus\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z \setminus\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> '''schedule(<tex>O_{ij}</tex>)'''<br /> '''if''' <tex>\mu_{ij}</tex> == A<br /> '''if''' T1 < LAST(i) <br /> t = LAST(i)<br /> A(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T1;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>A(T_1)</tex> <tex>\ne \emptyset</tex><br /> T1 = T1 + 1;<br /> '''else'''<br /> '''if''' T2 < LAST(i)<br /> t = LAST(i)<br /> B(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T2;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>B(T_2) \ne \emptyset</tex><br /> T2 = T2 + 1;<br /> LAST(i) = t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex><br /> <br /> <br /> ==Источники==<br /> * Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 180 стр. {{---}} ISBN 978-3-540-69515-8<br /> <br /> [[Категория: Дискретная математика и алгоритмы]]<br /> [[Категория: Теория расписаний]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26408 J2pij1Lmax 2012-06-21T19:01:51Z

<p>System29a: /* Описание решения */</p> <hr /> <div>{{в разработке}}<br /> ==Условие задачи==<br /> В нотации Грэхема задача носит название <tex>J2\mid p_{ij} = 1\mid L_{max}</tex><br /> <br /> Дано <tex>n</tex> работ <tex>i = 1,\ldots,n</tex> и две машины, обозначенные как <tex>A</tex> и <tex>B</tex>. <br /> <br /> <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij}</tex> <tex>(j = 1,\ldots n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex> операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>.<br /> <br /> Задача заключается в том, что для данного каждой <tex>i</tex>-той работе дедлайна <tex>d_i \ge 0</tex> необходимо найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex><br /> <br /> ==Описание решения==<br /> Судя по условию, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машиной, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхнюю границу момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два списка <tex>A(t)</tex> и <tex>B(t) (t = 0,\ldots,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex> <tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,\ldots,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,\ldots,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующий список (на самом деле это должен быть heap для хорошей асимптотики) <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру списка <tex>k</tex> порядку, где операции из одного списка могут выполнятся в произвольном порядке.<br /> <br /> ==Алгоритм==<br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответствующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> '''main()'''<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\setminus\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z \setminus\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> '''schedule(<tex>O_{ij}</tex>)'''<br /> '''if''' <tex>\mu_{ij}</tex> == A<br /> '''if''' T1 < LAST(i) <br /> t = LAST(i)<br /> A(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T1;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>A(T_1)</tex> <tex>\ne \emptyset</tex><br /> T1 = T1 + 1;<br /> '''else'''<br /> '''if''' T2 < LAST(i)<br /> t = LAST(i)<br /> B(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T2;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>B(T_2) \ne \emptyset</tex><br /> T2 = T2 + 1;<br /> LAST(i) = t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex><br /> <br /> <br /> ==Источники==<br /> * Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 180 стр. {{---}} ISBN 978-3-540-69515-8<br /> <br /> [[Категория: Дискретная математика и алгоритмы]]<br /> [[Категория: Теория расписаний]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26407 J2pij1Lmax 2012-06-21T18:52:19Z

<p>System29a: /* Условие задачи */</p> <hr /> <div>{{в разработке}}<br /> ==Условие задачи==<br /> В нотации Грэхема задача носит название <tex>J2\mid p_{ij} = 1\mid L_{max}</tex><br /> <br /> Дано <tex>n</tex> работ <tex>i = 1,\ldots,n</tex> и две машины, обозначенные как <tex>A</tex> и <tex>B</tex>. <br /> <br /> <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij}</tex> <tex>(j = 1,\ldots n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex> операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>.<br /> <br /> Задача заключается в том, что для данного каждой <tex>i</tex>-той работе дедлайна <tex>d_i \ge 0</tex> необходимо найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex><br /> <br /> ==Описание решения==<br /> Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,\ldots,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>\emptyset</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,\ldots,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,\ldots,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> ==Алгоритм==<br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответствующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> '''main()'''<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\setminus\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z \setminus\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> '''schedule(<tex>O_{ij}</tex>)'''<br /> '''if''' <tex>\mu_{ij}</tex> == A<br /> '''if''' T1 < LAST(i) <br /> t = LAST(i)<br /> A(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T1;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>A(T_1)</tex> <tex>\ne \emptyset</tex><br /> T1 = T1 + 1;<br /> '''else'''<br /> '''if''' T2 < LAST(i)<br /> t = LAST(i)<br /> B(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T2;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>B(T_2) \ne \emptyset</tex><br /> T2 = T2 + 1;<br /> LAST(i) = t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex><br /> <br /> <br /> ==Источники==<br /> * Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 180 стр. {{---}} ISBN 978-3-540-69515-8<br /> <br /> [[Категория: Дискретная математика и алгоритмы]]<br /> [[Категория: Теория расписаний]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26406 J2pij1Lmax 2012-06-21T18:49:53Z

<p>System29a: /* Источники */</p> <hr /> <div>{{в разработке}}<br /> ==Условие задачи==<br /> В нотации Грэхема задача носит название <tex>J2\mid p_{ij} = 1\mid L_{max}</tex><br /> <br /> Дано <tex>n</tex> работ <tex>i = 1,\ldots,n</tex> и две машины, обозначенные как <tex>A</tex> и <tex>B</tex>. <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij} (j = 1,\ldots n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex> операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>.<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex><br /> <br /> ==Описание решения==<br /> Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,\ldots,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>\emptyset</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,\ldots,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,\ldots,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> ==Алгоритм==<br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответствующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> '''main()'''<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\setminus\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z \setminus\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> '''schedule(<tex>O_{ij}</tex>)'''<br /> '''if''' <tex>\mu_{ij}</tex> == A<br /> '''if''' T1 < LAST(i) <br /> t = LAST(i)<br /> A(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T1;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>A(T_1)</tex> <tex>\ne \emptyset</tex><br /> T1 = T1 + 1;<br /> '''else'''<br /> '''if''' T2 < LAST(i)<br /> t = LAST(i)<br /> B(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T2;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>B(T_2) \ne \emptyset</tex><br /> T2 = T2 + 1;<br /> LAST(i) = t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex><br /> <br /> <br /> ==Источники==<br /> * Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 180 стр. {{---}} ISBN 978-3-540-69515-8<br /> <br /> [[Категория: Дискретная математика и алгоритмы]]<br /> [[Категория: Теория расписаний]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26405 J2pij1Lmax 2012-06-21T18:48:39Z

<p>System29a: /* Условие задачи */</p> <hr /> <div>{{в разработке}}<br /> ==Условие задачи==<br /> В нотации Грэхема задача носит название <tex>J2\mid p_{ij} = 1\mid L_{max}</tex><br /> <br /> Дано <tex>n</tex> работ <tex>i = 1,\ldots,n</tex> и две машины, обозначенные как <tex>A</tex> и <tex>B</tex>. <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij} (j = 1,\ldots n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex> операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>.<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex><br /> <br /> ==Описание решения==<br /> Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,\ldots,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>\emptyset</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,\ldots,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,\ldots,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> ==Алгоритм==<br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответствующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> '''main()'''<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\setminus\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z \setminus\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> '''schedule(<tex>O_{ij}</tex>)'''<br /> '''if''' <tex>\mu_{ij}</tex> == A<br /> '''if''' T1 < LAST(i) <br /> t = LAST(i)<br /> A(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T1;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>A(T_1)</tex> <tex>\ne \emptyset</tex><br /> T1 = T1 + 1;<br /> '''else'''<br /> '''if''' T2 < LAST(i)<br /> t = LAST(i)<br /> B(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T2;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>B(T_2) \ne \emptyset</tex><br /> T2 = T2 + 1;<br /> LAST(i) = t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex><br /> <br /> <br /> ==Источники==<br /> * Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8<br /> <br /> [[Категория: Дискретная математика и алгоритмы]]<br /> [[Категория: Теория расписаний]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26404 J2pij1Lmax 2012-06-21T18:47:37Z

<p>System29a: /* Условие задачи */</p> <hr /> <div>{{в разработке}}<br /> ==Условие задачи==<br /> В нотации Грэхема задача носит название <tex>J2\mid p_{ij} = 1\mid L_{max}</tex><br /> <br /> Дано <tex>n</tex> работ <tex>i = 1,\ldots,n</tex> и две машины, обозначенные как <tex>A</tex> и <tex>B</tex>. <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij} (j = 1,\ldots n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex>операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>.<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex><br /> <br /> ==Описание решения==<br /> Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,\ldots,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>\emptyset</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,\ldots,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,\ldots,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> ==Алгоритм==<br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответствующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> '''main()'''<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\setminus\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z \setminus\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> '''schedule(<tex>O_{ij}</tex>)'''<br /> '''if''' <tex>\mu_{ij}</tex> == A<br /> '''if''' T1 < LAST(i) <br /> t = LAST(i)<br /> A(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T1;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>A(T_1)</tex> <tex>\ne \emptyset</tex><br /> T1 = T1 + 1;<br /> '''else'''<br /> '''if''' T2 < LAST(i)<br /> t = LAST(i)<br /> B(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T2;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>B(T_2) \ne \emptyset</tex><br /> T2 = T2 + 1;<br /> LAST(i) = t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex><br /> <br /> <br /> ==Источники==<br /> * Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8<br /> <br /> [[Категория: Дискретная математика и алгоритмы]]<br /> [[Категория: Теория расписаний]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%94%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0,_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B_%D0%B8_%D1%81%D1%82%D1%80%D1%83%D0%BA%D1%82%D1%83%D1%80%D1%8B_%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85&diff=26403 Дискретная математика, алгоритмы и структуры данных 2012-06-21T18:46:31Z

<p>System29a: /* Теория расписаний */</p> <hr /> <div>[[Категория:Дискретная математика и алгоритмы]]<br /> [[Категория: Алгоритмы и структуры данных]]<br /> <br /> Убедительная просьба читать [[Обсуждение:Дискретная_математика_и_алгоритмы | правила оформления вики-конспектов]].<br /> <br /> = Первый семестр =<br /> <br /> == Отношения ==<br /> *[[Определение отношения]]<br /> *[[Степень отношений]]<br /> *[[Композиция отношений|Композиция отношений. Обратное отношение]]<br /> *[[Рефлексивное отношение|Рефлексивное отношение. Антирефлексивное отношение.]]<br /> *[[Симметричное отношение]]<br /> *[[Антисимметричное отношение]]<br /> *[[Транзитивное отношение]]<br /> *[[Транзитивное замыкание|Транзитивное замыкание отношения]]<br /> *[[Алгоритм Флойда — Уоршелла|Алгоритм Флойда-Уоршалла построения транзитивного замыкания отношения]]<br /> *[[Транзитивный остов]]<br /> *[[Отношение порядка]]<br /> *[[Отношение эквивалентности]]<br /> <br /> == Булевы функции ==<br /> *[[Определение булевой функции]]<br /> *[[Суперпозиции]]<br /> *[[ДНФ]]<br /> *[[КНФ]]<br /> *[[Полином Жегалкина]]<br /> *[[Полные системы функций. Теорема Поста о полной системе функций]]<br /> *[[Сокращенная и минимальная ДНФ]]<br /> *[[Минимизация ДНФ с помощью покрытий гиперкуба и карт Карно]]<br /> *[[Специальные формы КНФ|Специальные формы КНФ: КНФ в форме Хорна и КНФ в форме Крома]]<br /> *[[Преобразование Мёбиуса для получения коэффициентов полинома Жегалкина]]<br /> *[[Представление функции класса DM с помощью медианы]]<br /> *[[Пороговая функция]]<br /> <br /> == Схемы из функциональных элементов ==<br /> *[[Реализация булевой функции схемой из функциональных элементов]]<br /> *[[Cумматор]]<br /> *[[Каскадный сумматор]]<br /> *[[Двоичный каскадный сумматор]]<br /> *[[Реализация вычитания сумматором]]<br /> *[[Матричный умножитель]]<br /> *[[Дерево Уоллеса]]<br /> <br /> == Представление информации ==<br /> *[[Кодирование информации]]<br /> *[[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]<br /> *[[Представление вещественных чисел]]<br /> *[[Представление символов, таблицы кодировок]]<br /> <br /> == Алгоритмы сжатия ==<br /> *[[Алгоритм Хаффмана]]<br /> *[[Алгоритм LZW]]<br /> *[[Алгоритмы LZ77 и LZ78]]<br /> *[[Преобразование Барроуза-Уиллера]]<br /> *[[Обратное преобразование Барроуза-Уиллера]]<br /> *[[Преобразование MTF]]<br /> *[[Расстояние Хэмминга]]<br /> *[[Избыточное кодирование, код Хэмминга]]<br /> *[[Неравенство Крафта]]<br /> *[[Неравенство Макмиллана]]<br /> <br /> == Комбинаторика ==<br /> *[[Комбинаторные объекты]]<br /> *[[Лексикографический порядок]]<br /> *[[Формула включения-исключения]]<br /> *[[Генерация комбинаторных объектов в лексикографическом порядке]]<br /> *[[Получение номера по объекту]]<br /> *[[Получение объекта по номеру]]<br /> *[[Получение следующего объекта]]<br /> *[[Коды Грея]]<br /> *[[Коды Грея для перестановок]]<br /> *[[Цепные коды]]<br /> *[[Правильные скобочные последовательности]]<br /> *[[Действие перестановки на набор из элементов, представление в виде циклов]]<br /> *[[Метод генерации случайной перестановки, алгоритм Фишера-Йетса]]<br /> *[[Таблица инверсий]]<br /> *[[Умножение перестановок, обратная перестановка, группа перестановок]]<br /> *[[Теорема Кэли]]<br /> *[[Матричное представление перестановок]]<br /> *[[Задача о минимуме/максимуме скалярного произведения]]<br /> *[[Задача о монотонных подпоследовательностях, теорема о связи длины НВП и НУП]]<br /> *[[Нахождение количества разбиений числа на слагаемые | Нахождение количества разбиений числа на слагаемые. Пентагональная теорема Эйлера]]<br /> *[[Производящая функция]]<br /> <br /> == [[Динамическое программирование]] ==<br /> *[[Кратчайший путь в ациклическом графе]]<br /> *[[Задача о расстановке знаков в выражении]]<br /> *[[Задача о наибольшей общей подпоследовательности]]<br /> *[[Задача о порядке перемножения матриц]]<br /> *[[Задача о наибольшей возрастающей подпоследовательности]]<br /> *[[Задача о паросочетании максимального веса в дереве, амортизированные оценки для ДП на дереве]]<br /> *[[Метод четырех русских для умножения матриц]]<br /> *[[Применение метода четырех русских в задачах ДП на примере задачи о НОП]]<br /> *[[Задача коммивояжера, ДП по подмножествам]]<br /> *[[Задача о выводе в контекстно-свободной грамматике, алгоритм Кока-Янгера-Касами]]<br /> *[[Задача о редакционном расстоянии, алгоритм Вагнера-Фишера]]<br /> *[[Задача о расстоянии Дамерау-Левенштейна]]<br /> *[[Задача об оптимальном префиксном коде с сохранением порядка. Монотонность точки разреза]]<br /> <br /> == Теория вероятностей ==<br /> *[[Вероятностное пространство, элементарный исход, событие]]<br /> *[[Независимые события]]<br /> *[[Условная вероятность]]<br /> *[[Формула Байеса]]<br /> *[[Формула полной вероятности]]<br /> *[[Дискретная случайная величина]]<br /> *[[Независимые случайные величины]]<br /> *[[Математическое ожидание случайной величины]]<br /> *[[Дисперсия случайной величины]]<br /> *[[Ковариация случайных величин]]<br /> *[[Энтропия случайного источника]]<br /> *[[Симуляция одним распределением другого]]<br /> *[[Арифметическое кодирование]]<br /> *[[Задача о двух конвертах]]<br /> <br /> == Марковские цепи ==<br /> <br /> * [[Марковская цепь]]<br /> * [[Теорема о поглощении]]<br /> * [[Фундаментальная матрица]]<br /> * [[Математическое ожидание времени поглощения]]<br /> * [[Расчет вероятности поглощения в состоянии]]<br /> * [[Эргодическая марковская цепь]]<br /> * [[Регулярная марковская цепь]]<br /> <br /> = Второй семестр =<br /> <br /> == Амортизационный анализ ==<br /> * [[Амортизационный анализ]]<br /> * [[Саморасширяющийся массив]]<br /> * [[Массив с увеличением/уменьшением размера]]<br /> * [[Список]]<br /> * [[Стек]]<br /> * [[Очередь]]<br /> * [[Персистентный стек]]<br /> * [[Персистентный дек]]<br /> <br /> == Приоритетные очереди ==<br /> <br /> * [[Двоичная куча]]<br /> * [[Биномиальная куча]]<br /> * [[Фибоначчиева куча]]<br /> <br /> == Система непересекающихся множеств ==<br /> * [[СНМ (наивные реализации) | Наивные реализации]]<br /> * [[СНМ (списки с весовой эвристикой) | Списки с весовой эвристикой]]<br /> * [[СНМ(реализация с помощью леса корневых деревьев) | Реализация с помощью леса корневых деревьев]]<br /> <br /> == Поисковые структуры данных ==<br /> * [[Упорядоченное множество]]<br /> * [[Дерево поиска, наивная реализация]]<br /> * [[АВЛ-дерево]]<br /> * [[2-3 дерево]]<br /> * [[B-дерево]]<br /> * [[Красно-черное дерево]]<br /> * [[Декартово дерево]]<br /> * [[Декартово дерево по неявному ключу]]<br /> * [[Splay-дерево]]<br /> * [[Рандомизированное бинарное дерево поиска]]<br /> * [[Дерево ван Эмде Боаса]]<br /> * [[Список с пропусками]]<br /> <br /> == Дерево отрезков ==<br /> <br /> * [[Статистики на отрезках. Корневая эвристика]]<br /> * [[Дерево отрезков. Построение]]<br /> * [[Реализация запроса в дереве отрезков сверху]]<br /> * [[Реализация запроса в дереве отрезков снизу]]<br /> * [[Несогласованные поддеревья. Реализация массового обновления]]<br /> * [[Многомерное дерево отрезков]]<br /> * [[Сжатое многомерное дерево отрезков]]<br /> <br /> == Дерево Фенвика ==<br /> * [[Дерево Фенвика]]<br /> * [[Встречное дерево Фенвика]]<br /> * [[Дерево Фенвика для некоммутативных операций]]<br /> * [[Многомерное дерево Фенвика]]<br /> <br /> == Хеширование ==<br /> * [[Хеш-таблица]]<br /> * [[Хеширование]]<br /> * [[Разрешение коллизий]]<br /> * [[Хеширование кукушки]]<br /> * [[Идеальное хеширование]]<br /> * [[Перехеширование. Амортизационный анализ]]<br /> * [[Фильтр Блума]]<br /> * [[Универсальное семейство хеш-функций]]<br /> <br /> == [[Сортировка]] ==<br /> * [[Сортировка выбором]]<br /> * [[Сортировка пузырьком]]<br /> * [[Сортировка вставками]]<br /> * [[Сортировка кучей]]<br /> * [[Быстрая сортировка]]<br /> * [[Сортировка слиянием]]<br /> * [[Cортировка слиянием с использованием O(1) дополнительной памяти]]<br /> * [[Теорема о нижней оценке для сортировки сравнениями]]<br /> * [[Сортировка подсчетом]]<br /> * [[Сортировка подсчетом сложных объектов]]<br /> * [[Цифровая сортировка]]<br /> * [[Карманная сортировка]]<br /> * [[Поиск k-ой порядковой статистики]]<br /> * [[Поиск k-ой порядковой статистики за линейное время]]<br /> <br /> == Сортирующие сети ==<br /> * [[Сортирующие сети]]<br /> * [[0-1 принцип | Проверка сети компараторов на то, что она сортирующая. 0-1 принцип]]<br /> * [[Сортирующие сети для квадратичных сортировок]]<br /> * [[Сеть Бетчера]]<br /> <br /> == Алгоритмы поиска ==<br /> * [[Целочисленный двоичный поиск]]<br /> * [[Вещественный двоичный поиск]]<br /> * [[Троичный поиск]]<br /> * [[Поиск с помощью золотого сечения]]<br /> * [[Интерполяционный поиск]]<br /> <br /> == Связь между структурами данных ==<br /> * [[Связь между структурами данных]]<br /> <br /> = Третий семестр =<br /> <br /> == Основные определения теории графов ==<br /> * [[Основные определения теории графов|Основные определения: граф, ребро, вершина, степень, петля, путь, цикл]]<br /> * [[Лемма о рукопожатиях]]<br /> * [[Теорема о существовании простого пути в случае существования пути]]<br /> * [[Теорема о существовании простого цикла в случае существования цикла]]<br /> * [[Матрица смежности графа]]<br /> * [[Связь степени матрицы смежности и количества путей]]<br /> * [[Матрица инцидентности графа]]<br /> * [[Циклическое пространство графа]]<br /> * [[Фундаментальные циклы графа]]<br /> * [[Дерево, эквивалентные определения]]<br /> <br /> == Связность в графах ==<br /> * [[Отношение связности, компоненты связности]]<br /> * [[Отношение реберной двусвязности]]<br /> * [[Отношение вершинной двусвязности]]<br /> * [[Граф компонент реберной двусвязности]]<br /> * [[Граф блоков-точек сочленения]]<br /> * [[Точка сочленения, эквивалентные определения]]<br /> * [[Мост, эквивалентные определения]]<br /> * [[k-связность]]<br /> * [[Теорема Менгера]]<br /> * [[Теорема Менгера, альтернативное доказательство]]<br /> * [[Вершинная, реберная связность, связь между ними и минимальной степенью вершины]]<br /> <br /> == Остовные деревья ==<br /> * [[Матрица Кирхгофа]]<br /> * [[Связь матрицы Кирхгофа и матрицы инцидентности]]<br /> * [[Подсчет числа остовных деревьев с помощью матрицы Кирхгофа]]<br /> * [[Количество помеченных деревьев]]<br /> * [[Коды Прюфера]]<br /> <br /> == Обходы графов ==<br /> * [[Эйлеров цикл, Эйлеров путь, Эйлеровы графы, Эйлеровость орграфов]]<br /> * [[Покрытие ребер графа путями]]<br /> * [[Алгоритм построения Эйлерова цикла]]<br /> * [[Произвольно вычерчиваемые из заданной вершины графы]]<br /> * [[Гамильтоновы графы]]<br /> * [[Теорема Хватала]]<br /> * [[Теорема Дирака]]<br /> * [[Теорема Оре]]<br /> * [[Турниры]]<br /> * [[Теорема Редеи-Камиона]]<br /> <br /> == Укладки графов ==<br /> * [[Укладка графа на плоскости]]<br /> * [[Формула Эйлера]]<br /> * [[Непланарность K5 и K3,3|Непланарность <tex>K_5</tex> и <tex>K_{3,3}</tex>]]<br /> * [[Укладка дерева]]<br /> * [[Укладка графа с планарными компонентами реберной двусвязности]]<br /> * [[Укладка графа с планарными компонентами вершинной двусвязности]]<br /> * [[Теорема Понтрягина-Куратовского]]<br /> * [[Двойственный граф планарного графа]]<br /> <br /> == Раскраски графов ==<br /> * [[Раскраска графа]]<br /> * [[Двудольные графы и раскраска в 2 цвета]]<br /> * [[Хроматический многочлен]]<br /> ** [[Хроматический многочлен#Хроматический многочлен полного графа|Хроматический многочлен полного графа]]<br /> ** [[Хроматический многочлен#Хроматический многочлен пустого графа|Хроматический многочлен пустого графа]]<br /> ** [[Хроматический многочлен#Хроматический многочлен дерева|Хроматический многочлен дерева]]<br /> ** [[Хроматический многочлен#Рекуррентные формулы для хроматических многочленов|Рекуррентные формулы для хроматических многочленов]]<br /> ** [[Хроматический многочлен#Коэффициенты хроматического многочлена|Коэффициенты хроматического многочлена: старший, второй коэффициенты, знакопеременность]]<br /> * [[Формула Зыкова]]<br /> * [[Формула Уитни]]<br /> <br /> == Обход в глубину ==<br /> * [[Обход в глубину, цвета вершин]]<br /> * [[Лемма о белых путях]]<br /> * [[Использование обхода в глубину для проверки связности]]<br /> * [[Использование обхода в глубину для поиска цикла в ориентированном графе]]<br /> * [[Использование обхода в глубину для топологической сортировки]]<br /> * [[Использование обхода в глубину для поиска компонент сильной связности]]<br /> * [[Использование обхода в глубину для поиска точек сочленения]]<br /> * [[Построение компонент вершинной двусвязности]]<br /> * [[Использование обхода в глубину для поиска мостов]]<br /> * [[Построение компонент реберной двусвязности]]<br /> <br /> == Кратчайшие пути в графах ==<br /> * [[Обход в ширину]]<br /> * [[Алгоритм Форда-Беллмана]]<br /> * [[Алгоритм Дейкстры]]<br /> * [[Алгоритм Флойда]]<br /> * [[Алгоритм A*]]<br /> * [[Алгоритм Джонсона]]<br /> <br /> == Построение остовных деревьев ==<br /> * [[Лемма о безопасном ребре]]<br /> * [[Алгоритм Прима]]<br /> * [[Алгоритм Краскала]]<br /> * [[Критерий Тарьяна минимальности остовного дерева|Теорема Тарьяна (критерий минимальности остовного дерева)]]<br /> * [[Алгоритм двух китайцев]]<br /> <br /> == Задача о паросочетании ==<br /> * [[Теорема о максимальном паросочетании и дополняющих цепях]]<br /> * [[Алгоритм Форда-Фалкерсона для поиска максимального паросочетания]]<br /> * [[Алгоритм Куна для поиска максимального паросочетания]]<br /> * [[Связь максимального паросочетания и минимального вершинного покрытия в двудольных графах]]<br /> * [[Связь вершинного покрытия и независимого множества]]<br /> * [[Матрица Татта и связь с размером максимального паросочетания в двудольном графе]]<br /> * [[Алгоритм вырезания соцветий|Паросочетания в недвудольных графах. Алгоритм вырезания соцветий]]<br /> <br /> == Задача о максимальном потоке ==<br /> * [[Определение сети, потока]]<br /> * [[Разрез, лемма о потоке через разрез]]<br /> * [[Дополняющая сеть, дополняющий путь]]<br /> * [[Лемма о сложении потоков]]<br /> * [[Теорема Форда-Фалкерсона]]<br /> * [[Алгоритм Форда-Фалкерсона, реализация с помощью поиска в глубину]]<br /> * [[Алоритм Эдмондса-Карпа]]<br /> * [[Алгоритм масштабирования потока]]<br /> * [[Блокирующий поток]]<br /> * [[Схема алгоритма Диница]]<br /> * [[Теоремы Карзанова о числе итераций алгоритма Диница в сети с целочисленными пропускными способностями]]<br /> * [[Алгоритм поиска блокирующего потока в ациклической сети]]<br /> * [[Теорема о декомпозиции]]<br /> * [[Теорема о декомпозиционном барьере]]<br /> * [[Циркуляция потока]]<br /> <br /> == Задача о потоке минимальной стоимости ==<br /> * [[Поток минимальной стоимости]]<br /> * [[Теорема Форда-Фалкерсона о потоке минимальной стоимости]]<br /> * [[Лемма об эквивалентности свойства потока быть минимальной стоимости и отсутствии отрицательных циклов в остаточной сети]]<br /> * [[Поиск потока минимальной стоимости методом дополнения вдоль путей минимальной стоимости]]<br /> * [[Использование потенциалов Джонсона при поиске потока минимальной стоимости]]<br /> * [[Сведение задачи о назначениях к задаче о потоке минимальной стоимости]]<br /> * [[Венгерский алгоритм решения задачи о назначениях]]<br /> <br /> = Четвертый семестр =<br /> <br /> == Основные определения. Простые комбинаторные свойства слов ==<br /> * [[Основные определения, связанные со строками]]<br /> * [[Период и бордер, их связь]]<br /> * [[Слово Фибоначчи]]<br /> * [[Слово Туэ-Морса]]<br /> <br /> == Поиск подстроки в строке ==<br /> * [[Наивный алгоритм поиска подстроки в строке]]<br /> * [[Поиск подстроки в строке с использованием хеширования. Алгоритм Рабина-Карпа]]<br /> * [[Поиск наибольшей общей подстроки двух строк с использованием хеширования]]<br /> * [[Префикс-функция]]<br /> * [[Алгоритм Кнута-Морриса-Пратта]]<br /> * [[Z-функция]]<br /> * [[Автомат для поиска образца в тексте]]<br /> * [[Бор]]<br /> * [[Алгоритм Ахо-Корасик]]<br /> <br /> == Суффиксное дерево ==<br /> * [[Суффиксный бор]]<br /> * [[Сжатое суффиксное дерево]]<br /> * [[Алгоритм Укконена]]<br /> <br /> == Суффиксный массив ==<br /> * [[Суффиксный массив]]<br /> * [[Построение суффиксного массива с помощью стандартных методов сортировки]]<br /> * [[Цифровая сортировка]]<br /> * [[Алгоритм цифровой сортировки суффиксов циклической строки]]<br /> * [[Алгоритм Касаи и др.]]<br /> * [[Алгоритм Карккайнена-Сандерса]]<br /> * [[Алгоритм поиска подстроки в строке с помощью суффиксного массива]]<br /> <br /> == Задача о наименьшем общем предке ==<br /> * [[Метод двоичного подъема]]<br /> * [[Сведение задачи LCA к задаче RMQ]]<br /> * [[Решение RMQ с помощью разреженной таблицы]]<br /> * [[Алгоритм Фарака-Колтона и Бендера]] (решение +/-1 RMQ с помощью метода четырех русских)<br /> * [[Алгоритм Шибера-Вишкина]]<br /> * [[Сведение задачи RMQ к задаче LCA]]<br /> <br /> == Матроиды ==<br /> * [[Определение матроида]]<br /> * [[Примеры матроидов]]<br /> * [[Прямая сумма матроидов]]<br /> * [[Теорема Радо-Эдмондса (жадный алгоритм)]]<br /> * [[Жадный алгоритм поиска базы минимального веса]]<br /> * [[Теорема о базах]]<br /> * [[Аксиоматизация матроида базами]]<br /> * [[Теорема о циклах]]<br /> * [[Аксиоматизация матроида циклами]]<br /> * [[Ранговая функция, полумодулярность]]<br /> * [[Двойственный матроид]]<br /> * [[Оператор замыкания для матроидов]]<br /> === Пересечение матроидов ===<br /> * [[Пересечение матроидов, определение, примеры]]<br /> * [[Лемма о паросочетании в графе замен]]<br /> * [[Лемма о единственном паросочетании в графе замен]]<br /> * [[Граф замен для двух матроидов]]<br /> * [[Лемма о единственном паросочетании в подграфе замен, индуцированном кратчайшим путем]]<br /> * [[Алгоритм построения базы в пересечении матроидов]]<br /> * [[Теорема Эдмондса-Лоулера]]<br /> === Объединение матроидов ===<br /> * [[Объединение матроидов, проверка множества на независимость]]<br /> * [[Объединение матроидов, доказательство того, что объединение является матроидом]]<br /> * [[Алгоритм построения базы в объединении матроидов]]<br /> <br /> == Теория расписаний ==<br /> * [[Классификация задач]]<br /> * [[Методы решения задач теории расписаний]]<br /> * [[Правило Лаулера]]<br /> * [[Flow shop]]<br /> * [[1precpmtnrifmax|<tex>1 \mid prec, pmtn, r_i \mid f_{\max}</tex>]]<br /> * [[QpmtnCmax|<tex>Q \mid pmtn \mid C_{max}</tex>]]<br /> * [[QpmtnriLmax|<tex>Q \mid pmtn, r_{i} \mid L_{max}</tex>]]<br /> * [[P2precpi1Lmax|<tex>P2 \mid prec, p_i = 1 \mid L_{\max}</tex>]]<br /> * [[R2Cmax|<tex>R2 \mid \mid C_{max}</tex>]]<br /> * [[O2Cmax|<tex>O2 \mid \mid C_{max}</tex>]]<br /> * [[PpmtnriLmax|<tex>P \mid pmtn, r_i \mid L_{max}</tex>]]<br /> * [[Opi1sumu|<tex>O \mid p_{ij} = 1 \mid \sum u_i</tex>]]<br /> * [[Fpij1sumwu|<tex>F \mid p_{ij} = 1 \mid \sum w_i u_i</tex>]]<br /> * [[1ripi1sumwc|<tex>1 \mid r_{i}, p_i=1\mid \sum w_{i}c_{i}</tex>]]<br /> * [[1ridipi1|<tex>1 \mid r_{i}, d_{i}, p_{i} = 1 \mid -</tex>]]<br /> * [[1outtreesumwc | <tex>1 \mid outtree \mid \sum w_i c_i</tex>]]<br /> * [[1pi1sumwu|<tex>1 \mid p_{i} = 1 \mid \sum w_{i}U_{i}</tex>]]<br /> * [[QSumCi|<tex>Q\mid\mid\sum{C_i}</tex>]]<br /> * [[J2pij1Lmax| <tex>J2\mid p_{ij} = 1\mid L_{max}</tex>]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26402 J2pij1Lmax 2012-06-21T18:44:37Z

<p>System29a: </p> <hr /> <div>{{в разработке}}<br /> ==Условие задачи==<br /> В нотации <br /> Дано <tex>n</tex> работ <tex>i = 1,\ldots,n</tex> и две машины, обозначенные как <tex>A</tex> и <tex>B</tex>. <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij} (j = 1,\ldots n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex>операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>.<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> ==Описание решения==<br /> Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,\ldots,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>\emptyset</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,\ldots,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,\ldots,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> ==Алгоритм==<br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответствующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> '''main()'''<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\setminus\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z \setminus\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> '''schedule(<tex>O_{ij}</tex>)'''<br /> '''if''' <tex>\mu_{ij}</tex> == A<br /> '''if''' T1 < LAST(i) <br /> t = LAST(i)<br /> A(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T1;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>A(T_1)</tex> <tex>\ne \emptyset</tex><br /> T1 = T1 + 1;<br /> '''else'''<br /> '''if''' T2 < LAST(i)<br /> t = LAST(i)<br /> B(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T2;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>B(T_2) \ne \emptyset</tex><br /> T2 = T2 + 1;<br /> LAST(i) = t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex><br /> <br /> <br /> ==Источники==<br /> * Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 379 стр. {{---}} ISBN 978-3-540-69515-8<br /> <br /> [[Категория: Дискретная математика и алгоритмы]]<br /> [[Категория: Теория расписаний]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26401 J2pij1Lmax 2012-06-21T18:39:36Z

<p>System29a: </p> <hr /> <div>{{в разработке}}<br /> ===Условие задачи===<br /> <br /> ===Описание решения===<br /> Дано <tex>n</tex> работ <tex>i = 1,\ldots,n</tex> и две машины, обозначенные как A и B. <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij} (j = 1,\ldots n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex>операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>. Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,\ldots,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>\emptyset</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max\{C_i - d_i | i = 1, \ldots, n\}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,\ldots,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,\ldots,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> ===Алгоритм===<br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответствующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> '''main()'''<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\setminus\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z \setminus\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> '''schedule(<tex>O_{ij}</tex>)'''<br /> '''if''' <tex>\mu_{ij}</tex> == A<br /> '''if''' T1 < LAST(i) <br /> t = LAST(i)<br /> A(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T1;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>A(T_1)</tex> <tex>\ne \emptyset</tex><br /> T1 = T1 + 1;<br /> '''else'''<br /> '''if''' T2 < LAST(i)<br /> t = LAST(i)<br /> B(t) = <tex>O_{ij}</tex><br /> '''else'''<br /> t = T2;<br /> A(t) = <tex>O_{ij}</tex>;<br /> '''while''' <tex>B(T_2) \ne \emptyset</tex><br /> T2 = T2 + 1;<br /> LAST(i) = t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex></div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26398 J2pij1Lmax 2012-06-21T18:20:08Z

<p>System29a: </p> <hr /> <div>{{в разработке}}<br /> Дано <tex>n</tex> работ <tex>i = 1,...,n</tex> и две машины, обозначенные как A и B. <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij} (j = 1,..n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex>операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>. Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,...,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>\emptyset</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max{C_i - d_i | i = 1, ..., n}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,...,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,...,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответсвующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> main()<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\\\{O_{ij}\}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z\\\{i\}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> <br /> schedule(O_{ij})<br /> if \mu_{ij} = A then do<br /> if T1 < LAST(i) then do<br /> t := LAST(i)<br /> A(t) := O_{ij}<br /> else<br /> t := T1;<br /> A(t) := O_{ij};<br /> while A(T_1) \ne \emptyset do <br /> T1 := T1 + 1;<br /> else<br /> if T2 < LAST(i) then do<br /> t := LAST(i)<br /> B(t) := O_{ij}<br /> else<br /> t := T2;<br /> A(t) := O_{ij};<br /> while B(T_2) \ne \emptyset do <br /> T2 := T2 + 1;<br /> LAST(i) := t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex></div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26397 J2pij1Lmax 2012-06-21T18:16:02Z

<p>System29a: </p> <hr /> <div>{{в разработке}}<br /> Дано <tex>n</tex> работ <tex>i = 1,...,n</tex> и две машины, обозначенные как A и B. <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij} (j = 1,..n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex>операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>. Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,...,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>\emptyset</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max{C_i - d_i | i = 1, ..., n}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,...,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,...,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответсвующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> main()<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> <tex>L(k)</tex> = <tex>\emptyset</tex>;<br /> Z = <tex>\emptyset</tex>;<br /> '''for''' i: 1 '''to''' n<br /> '''if''' <tex>d_i</tex> < r<br /> '''for''' j: 1 '''to''' n_i<br /> добавить <tex>O_{ij}</tex> в <tex>L(d_i - n_i + j)</tex><br /> '''else'''<br /> добавить работу i в Z<br /> '''for''' i: 1 '''to''' n<br /> LAST(i) = 0;<br /> T1 = 0;<br /> T2 = 0;<br /> '''for''' k: -r + 1 '''to''' r - 1<br /> '''while''' <tex>L(k) \ne \emptyset</tex><br /> Выбрать задание <tex>O_{ij}</tex> из <tex>L(k)</tex><br /> <tex>L(k)</tex> = <tex>L(k)\{O_{ij}}</tex>;<br /> schedule(<tex>O_{ij}</tex>) <br /> '''while''' <tex>z \ne \emptyset</tex><br /> Выбрать работу i из Z<br /> Z = <tex>Z\{i}</tex>;<br /> '''for''' j: 1 '''to''' <tex>n_i</tex><br /> schedule(<tex>O_{ij}</tex>) <br /> <br /> <br /> schedule(O_{ij})<br /> if \mu_{ij} = A then do<br /> if T1 < LAST(i) then do<br /> t := LAST(i)<br /> A(t) := O_{ij}<br /> else<br /> t := T1;<br /> A(t) := O_{ij};<br /> while A(T_1) \ne \emptyset do <br /> T1 := T1 + 1;<br /> else<br /> if T2 < LAST(i) then do<br /> t := LAST(i)<br /> B(t) := O_{ij}<br /> else<br /> t := T2;<br /> A(t) := O_{ij};<br /> while B(T_2) \ne \emptyset do <br /> T2 := T2 + 1;<br /> LAST(i) := t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex></div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26395 J2pij1Lmax 2012-06-21T18:05:23Z

<p>System29a: </p> <hr /> <div>{{в разработке}}<br /> Дано <tex>n</tex> работ <tex>i = 1,...,n</tex> и две машины, обозначенные как A и B. <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij} (j = 1,..n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex>операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>. Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \sum_{i=1}^n N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,...,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> \emptyset</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>\emptyset</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max\{t + 1 | A(t)\}</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max{C_i - d_i | i = 1, ..., n}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,...,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,...,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответсвующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> <br /> main()<br /> for k: -r + 1 to r - 1 do<br /> L(k) = \emptyset;<br /> Z := (empty);<br /> for i:= 1 to n do<br /> if d_i < r then<br /> for j := 1 to n_i do<br /> добавить O_{ij} в L(d_i - n_i + j)<br /> else<br /> добавить работу i в Z<br /> for i := 1 to n do<br /> LAST(i) := 0;<br /> T1 := 0;<br /> T2 := 0;<br /> for k := -r + 1 to r - 1 do<br /> while L(k) \ne \emptyset do<br /> Выбрать задание O_{ij} из L(k)<br /> L(k) := L(k)\{O_{ij}};<br /> schedule(O_{ij}) <br /> while z \ne \emptyset do<br /> Выбрать работу i из Z<br /> Z := Z\{i};<br /> for j := 1 to n_i<br /> schedule(O_{ij}) <br /> <br /> <br /> schedule(O_{ij})<br /> if \mu_{ij} = A then do<br /> if T1 < LAST(i) then do<br /> t := LAST(i)<br /> A(t) := O_{ij}<br /> else<br /> t := T1;<br /> A(t) := O_{ij};<br /> while A(T_1) \ne \emptyset do <br /> T1 := T1 + 1;<br /> else<br /> if T2 < LAST(i) then do<br /> t := LAST(i)<br /> B(t) := O_{ij}<br /> else<br /> t := T2;<br /> A(t) := O_{ij};<br /> while B(T_2) \ne \emptyset do <br /> T2 := T2 + 1;<br /> LAST(i) := t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex></div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=26386 J2pij1Lmax 2012-06-21T17:48:10Z

<p>System29a: </p> <hr /> <div>{{в разработке}}<br /> Дано <tex>n</tex> работ <tex>i = 1,...,n</tex> и две машины, обозначенные как A и B. <tex>i</tex>-тая работа состоит из <tex>n_i</tex> операций <tex>O_{ij} (j = 1,..n_i)</tex>, которые должны быть выполнены последовательно и, при этом, если <tex>O_{ij} </tex>операция была совершена на машине <tex>A (B)</tex>, то операция <tex>O_{i,j-1}</tex> должна быть совершена на машине <tex>B (A)</tex>. Таким образом, <tex>i</tex>-тая работа может характеризоваться двумя значениями: количество операций <tex>n_i</tex> и машина, на которой была совершена первая операция. Пусть <tex>r = \Sum(i=1..n) N_i</tex> {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за <tex>t_{max}</tex>. К примеру, мы можем выбрать <tex>t_{max} = r</tex>. Тогда расписание можно представить как два массива <tex>A(t)</tex> и <tex>B(t) (t = 0,...,t_{max})</tex>, где <tex>A(t) = O_{ij}</tex>, если операция <tex>O_ij</tex> должна выполниться на машине <tex>A</tex> в момент времени <tex>t</tex> и <tex>A(t) =</tex><tex> (пусто)</tex>, если машина <tex>A</tex> простаивает в этот момент. Будем называть <tex>(пусто)</tex> пустой операцией. И для каждой операции <tex>O_{ij}</tex>, выполняющейся на машине <tex>A</tex> существует <tex>t</tex>, для которого <tex>A(t) = O_{ij}</tex>. Аналогично для <tex>B_i</tex>. Расписание достижимо тогда и только тогда, когда из <tex>A(t) (B(t)) = O_{ij} , 1 < j \le n_i</tex> следует <tex>O_{i,j-1} = B(s) (A(s))</tex> для некоторого <tex>s < t</tex>, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка <tex>L</tex> осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим <tex>L</tex>, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим <tex>L</tex> расписанием. <br /> <tex>С_i</tex> {{---}} время окончания работы <tex>i</tex> в достижимом расписании <tex>y = (A(t), B(t))</tex> можно рассчитать как:<br /> <br /> <tex>C_i = max{t + 1 | A(t)</tex> или <tex>B(t)</tex> {{---}} операция <tex>i</tex>-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе <tex>i</tex> дедлайна <tex>d_i \ge 0</tex> мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> <tex>max{C_i - d_i | i = 1, ..., n}</tex> <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций <tex>L</tex>, упорядоченный в порядке неубывания значений <tex>l(O_{ij})</tex> <br /> * Найдем соответствующее списку <tex>L</tex> расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.<br /> <br /> Мы предполагаем, что <tex>d_i \ge 0</tex> для <tex>i = 1,...,n</tex> и хотя бы для одной работы <tex>i</tex> <tex>d_i = 0</tex>. Иначе, вычтем из всех <tex>d_i</tex> минимальное значение по <tex>d_i</tex><br /> <br /> Так как <tex>C_i \ge 1</tex> для всех <tex>i = 1,...,n</tex> и <tex>d_i = 0</tex> справедливо <tex>L_i = C_i - d_i \ge 1</tex> как минимум для одной работы <tex>i</tex>. К тому же, можно предположить, что <tex>C_i \le r</tex>. Таким образом, работы с <tex>d_i > r - 1</tex>, то есть c <tex>L_i = C_i - d_i < 1</tex> можно смело игнорировать. Они не влияют на значение улучшаемой функции <tex>max(L_i)</tex>, так как для некого <tex>i L_i \ge 1</tex> Можно выполнять эти работы в любом порядке после всех остальных. Для оставшихся операций <tex>O_{ij}</tex> мы имеем:<br /> <br /> <tex>-r + 1 \le l(O_{ij}) = d_i - n_i + j \le r - 1</tex><br /> <br /> Каждую операцию мы кладём в соответствующую корзину <tex>L(k)</tex>, где <tex>k = l(O_{ij}) = d_i - n_i + j(-r + 1 \le k \le r - 1)</tex>. На втором шаге мы планируем операции соответственно возрастающему по номеру корзины <tex>k</tex> порядку, где операции из одной корзины могут выполнятся в произвольном порядке.<br /> <br /> Давайте детально рассмотрим алгоритм. <tex>T1</tex> и <tex>T2</tex> обозначают первый период времени <tex>t \ge 0</tex>, когда соответсвующие машины <tex>A</tex> и <tex>B</tex> бездействуют. <tex>LAST(i)</tex> обозначает время окончания последней запланированной операции <tex>i</tex>-той работы. <tex>Z</tex> {{---}} множество работ, где <tex>d_i \ge r</tex> <br /> main()<br /> for k:= -r + 1 to r - 1 do<br /> L(k) := (empty);<br /> Z := (empty);<br /> for i:= 1 to n do<br /> if d_i < r then<br /> for j := 1 to n_i do<br /> добавить O_{ij} в L(d_i - n_i + j)<br /> else<br /> добавить работу i в Z<br /> for i := 1 to n do<br /> LAST(i) := 0;<br /> T1 := 0;<br /> T2 := 0;<br /> for k := -r + 1 to r - 1 do<br /> while L(k) \ne (empty) do<br /> Выбрать задание O_{ij} из L(k)<br /> L(k) := L(k)\{O_{ij}};<br /> schedule(O_{ij}) <br /> while z \ne (empty) do<br /> Выбрать работу i из Z<br /> Z := Z\{i};<br /> for j := 1 to n_i<br /> schedule(O_{ij}) <br /> <br /> schedule(O_{ij})<br /> if \mu_{ij} = A then do<br /> if T1 < LAST(i) then do<br /> t := LAST(i)<br /> A(t) := O_{ij}<br /> else<br /> t := T1;<br /> A(t) := O_{ij};<br /> while A(T_1) \ne (empty) do <br /> T1 := T1 + 1;<br /> else<br /> if T2 < LAST(i) then do<br /> t := LAST(i)<br /> B(t) := O_{ij}<br /> else<br /> t := T2;<br /> A(t) := O_{ij};<br /> while B(T_2) \ne (empty) do <br /> T2 := T2 + 1;<br /> LAST(i) := t + 1<br /> <br /> Очевидно, что количество шагов алгоритма ограничено <tex>O(r)</tex></div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=24182 J2pij1Lmax 2012-06-06T17:08:08Z

<p>System29a: </p> <hr /> <div>{{в разработке}}<br /> Дано n работ i = 1,...,n и две машины, обозначенные как A и B. i-тая работа состоит из n_i операций O_{ij} (j = 1,..n_i), которые должны быть выполнены последовательно и, при этом, если O_{ij} операция была совершена на машине A (B), то операция O_{i,j-1} должна быть совершена на машине B (A). Таким образом, i-тая работа может характеризоваться двумя значениями: количество операций n_i и машина, на которой была совершена первая операция. Пусть r = \Sum(i=1..n) N_i {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за t_{max}. К примеру, мы можем выбрать t_{max} = r. Тогда расписание можно представить как два массива A(t) и B(t) (t = 0,...,t_{max}), где A(t) = O_ij, если операция O_ij должна выполниться на машине A в момент времени t и A(t) = (пусто), если машина A простаивает в этот момент. Будем называть (пусто) пустой операцией. И для каждой операции O_ij, выполняющейся на машине A существует t, для которого A(t) = O_ij. Аналогично для B_i. Расписание достижимо тогда и только тогда, когда из A(t) (B(t)) = O_{ij} , 1 < j \le n_i следует O_{i,j-1} = B(s) (A(s)) для некоторого s < t, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка L осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим L, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим L расписанием. <br /> С_i {{---}} время окончания работы i в достижимом расписании y = (A(t), B(t)) можно рассчитать как:<br /> <br /> C_i = max{t + 1 | A(t) или B(t) {{---}} операция i-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе i дедлайна d_i \ge 0 мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> max{C_i - d_i | i = 1, ..., n} <br /> <br /> Следующий алгоритм решает эту задачу:<br /> <br /> * Введём для каждой операции <tex>O_{ij}</tex> величину <tex>l(O_{ij}) = d_i - n_i + j</tex><br /> * Создадим список всех операций L, упорядоченный в порядке неубывания значений l(O_{ij}) <br /> * Найдем соответствующее списку L расписание.<br /> <br /> Этот алгоритм может быть реализованным с асимптотикой <tex>O(r \log r)</tex>.<br /> Однако, мы будем использовать эвристику с хешами и улучшим асимптотику алгоритма до <tex>O(r)</tex>.</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=24151 J2pij1Lmax 2012-06-06T16:22:14Z

<p>System29a: Новая страница: «{{в разработке}} Дано n работ i = 1,...,n и две машины, обозначенные как A и B. i-тая работа состоит...»</p> <hr /> <div>{{в разработке}}<br /> Дано n работ i = 1,...,n и две машины, обозначенные как A и B. i-тая работа состоит из n_i операций O_{ij} (j = 1,..n_i), которые должны быть выполнены последовательно и, при этом, если O_{ij} операция была совершена на машине A (B), то операция O_{i,j-1} должна быть совершена на машине B (A). Таким образом, i-тая работа может характеризоваться двумя значениями: количество операций n_i и машина, на которой была совершена первая операция. Пусть r = \Sum(i=1..n) N_i {{---}} общее количество операций.<br /> <br /> Допустим, самым ранним моментом, когда операция может начать выполняться, будет момент времени 0, а верхняя граница момента начала выполнения последней операции обозначим за t_{max}. К примеру, мы можем выбрать t_{max} = r. Тогда расписание можно представить как два массива A(t) и B(t) (t = 0,...,t_{max}), где A(t) = O_ij, если операция O_ij должна выполниться на машине A в момент времени t и A(t) = (пусто), если машина A простаивает в этот момент. Будем называть (пусто) пустой операцией. И для каждой операции O_ij, выполняющейся на машине A существует t, для которого A(t) = O_ij. Аналогично для B_i. Расписание достижимо тогда и только тогда, когда из A(t) (B(t)) = O_{ij} , 1 < j \le n_i следует O_{i,j-1} = B(s) (A(s)) для некоторого s < t, и первая операция для каждой работы запланирована на нужной машине. Перестановку всех операций будем называть списком. Для данный списка L осуществимое расписание может быть создано следующим способом: планируем выполнять операции в порядке, соответствующим L, причем каждую операцию стараемся выполнить как можно раньше. Подобное расписание будем называть соответствующим L расписанием. <br /> С_i {{---}} время окончания работы i в достижимом расписании y = (A(t), B(t)) можно рассчитать как:<br /> <br /> C_i = max{t + 1 | A(t) или B(t) {{---}} операция i-той работы}<br /> <br /> Задача заключается в том, что для данного каждой работе i дедлайна d_i \ge 0 мы хотим найти достижимое расписание с наименьшими максимальным временем опоздания:<br /> <br /> max{C_i - d_i | i = 1, ..., n} <br /> <br /> Следующий алгоритм решает эту задачу</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:System29a/%D0%92%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%BE%D0%B3%D1%80%D0%B5%D1%88%D0%BD%D0%BE%D1%81%D1%82%D0%B5%D0%B9&diff=17870 Участник:System29a/Вычисление погрешностей 2012-01-27T05:37:51Z

<p>System29a: </p> <hr /> <div>Короче, смотрите, всё не так сложно как кажется.<br /> <br /> Первый и главный совет — почитайте презенташку Антона и посмотрите видео! Очень жаль, что лекториум именно в этот момент переезжает.<br /> <br /> Ну дык вот.<br /> <br /> Проблема — операции связанные с числами с плавающей точкой нифига не точны. Мы хотим оценить сверху эту самую неточность. В данном случае речь идёт об оценке знака векторного произведения.<br /> <br /> 19 слайд презенташки — тут даны определения операций с соответствующими погрешностями, которые собственно делает компьютер . <tex>\delta</tex> — погрешность конкретной операции, она различная для каждой операции, но мы её можем оценить как <tex>|\delta| \le \epsilon</tex>.<br /> <br /> Смотрим следующее утверждение. Тут задается операция векторного произведения для трех точек, как она рассчитывается в компьютере. Мы же хотим оценить эталонные вычисления (операции будут не в кружочках). <br /> <br /> Для начала выделим достаточное условие. Мы утверждаем, что если <tex>|\tilde v - v| \le |\tilde v|</tex>, то этого достаточно для того, чтобы у <tex>\tilde v</tex> и <tex>v</tex> был одинаковый знак. Проверяется это непосредственно, эта штука должна быть эквивалентна тому утверждению, что одномерный шар радиуса <tex>|\tilde v - v|</tex> с центром в точке <tex>\tilde v</tex> не пересекался с нулём. Нарисуйте картинку и всё осознаете. {{TODO| t = запилите рисунок, где есть 0, ось X, и на ней описанный шар!}}<br /> <br /> Окей, у нас есть подобное условие.<br /> теперь раскроем <tex>|\tilde v - v|</tex> по нашим определениям. Следующим шагом будет раскрытие знаков в кружочке (смотрите 23 слайд).<br /> <br /> Следующий переход (на том же 23 слайде) скорей всего вам не понятен. Поясню, выражение <tex>|\tilde v - v|</tex> перегруппировали таким образом, чтобы с помощью правил <tex>|a - b| \le |a| + |b| </tex> и <tex>|a*b| = |a|*|b| </tex> мы смогли оценить сверху <tex>|\tilde v - v|</tex> именно таким образом, каким он там оценён.<br /> <br /> Заметим, что выражение, обозванное в презенташке как <tex>e</tex>, вычисляется в операциях не компьютерных, а абсолютных. Это плохо, мы не умеем вычислять абсолютно :) Следующий шаг — оцениваем это выражение сверху в модели floating-point(кружочки!). Собственно, там куча промежуточных вычислений, которые я не могу пока привести. И в итоге (смотрите презентацию!) мы получим оценку погрешности вычисления нашей штуки.<br /> <br /> {{TODO| t=пилить эту штуку до удобоваримого состояния.}}</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:System29a/%D0%92%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5_%D0%BF%D0%BE%D0%B3%D1%80%D0%B5%D1%88%D0%BD%D0%BE%D1%81%D1%82%D0%B5%D0%B9&diff=17869 Участник:System29a/Вычисление погрешностей 2012-01-27T05:36:47Z

<p>System29a: Новая страница: «Короче, смотрите, всё не так сложно как кажется. Первый и главный совет — почитайте презен...»</p> <hr /> <div>Короче, смотрите, всё не так сложно как кажется.<br /> <br /> Первый и главный совет — почитайте презенташку Антона и посмотрите видео! Очень жаль, что лекториум именно в этот момент переезжает.<br /> <br /> Ну дык вот.<br /> <br /> Проблема — операции связанные с числами с плавающей точкой нифига не точны. Мы хотим оценить сверху эту самую неточность. В данном случае речь идёт об оценке знака векторного произведения.<br /> <br /> 19 слайд презенташки — тут даны определения операций с соответствующими погрешностями, которые собственно делает компьютер . <tex>\delta</tex> — погрешность конкретной операции, она различная для каждой операции, но мы её можем оценить как <tex>|\delta| \le \epsilon</tex>.<br /> <br /> Смотрим следующее утверждение. Тут задается операция векторного произведения для трех точек, как она рассчитывается в компьютере. Мы же хотим оценить эталонные вычисления (операции будут не в кружочках). <br /> <br /> Для начала выделим достаточное условие. Мы утверждаем, что если <tex>|\tilde v - v| \le |\tilde v|</tex>, то этого достаточно для того, чтобы у <tex>\tilde v</tex> и <tex>v</tex> был одинаковый знак. Проверяется это непосредственно, эта штука должна быть эквивалентна тому утверждению, что одномерный шар радиуса <tex>|\tilde v - v|</tex> с центром в точке <tex>\tilde v</tex> не пересекался с нулём. Нарисуйте картинку и всё осознаете. {{TODO| t = запилите рисунок, где есть 0, ось X, и на ней описанный шар!}}<br /> <br /> Окей, у нас есть подобное условие.<br /> теперь раскроем <tex>|\tilde v - v|</tex> по нашим определениям. Следующим шагом будет раскрытие знаков в кружочке (смотрите 23 слайд).<br /> <br /> Следующий переход (на том же 23 слайде) скорей всего вам не понятен. Поясню, выражение <tex>|\tilde v - v|</tex> перегруппировали таким образом, чтобы с помощью правил <tex>|a - b| \le |a| + |b| </tex> и <tex>|a*b| = |a|*|b| </tex> мы смогли оценить сверху <tex>|\tilde v - v|</tex> именно таким образом, каким он там оценён.<br /> <br /> Заметим, что выражение, обозванное в презенташке как <tex>e</tex>, вычисляется в операциях не компьютерных, а абсолютных. Это плохо, мы не умеем вычислять абсолютно :) Следующий шаг — оцениваем это выражение сверху в модели floating-point(кружочки!). Собственно, там куча промежуточных вычислений, которые я не могу пока привести. И в итоге (смотрите презентацию!) мы получим оценку погрешности вычисления нашей штуки.<br /> <br /> {{ODO| t=пилить эту штуку до удобоваримого состояния.}}</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:System29a&diff=17867 Участник:System29a 2012-01-27T02:39:48Z

<p>System29a: </p> <hr /> <div>Артём Попов, 2538<br /> <br /> [[Участник:System29a/Вычисление погрешностей]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:System29a&diff=17866 Участник:System29a 2012-01-27T02:33:58Z

<p>System29a: </p> <hr /> <div>Артём Попов, 2538<br /> [[Вычисление погрешностей]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%90%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC_%D0%91%D0%B5%D0%BD%D1%82%D0%BB%D0%B8-%D0%9E%D1%82%D1%82%D0%BC%D0%B0%D0%BD%D0%B0&diff=17380 Алгоритм Бентли-Оттмана 2012-01-20T00:17:53Z

<p>System29a: тире</p> <hr /> <div>Алгоритм Бентли-Оттмана(англ. Bentley-Ottmann) — алгоритм, позволяющий по множеству отрезков на плоскости получить множество точек, в которых эти отрезки пересекаются, при этом для каждой точки алгоритм выдает множество отрезков, пересекающихся в ней.<br /> <br /> ==Постановка задачи==<br /> [[Файл:pic1.jpg|right|560|thumb|Пример результата работы алгоритма]]<br /> На плоскости лежит <tex>n</tex> отрезков, каждый из них задан координатами своих концов. Требуется по этим данным определить множество точек, в которых эти отрезки пересекаются. Однако, не всегда координаты точки можно абсолютно точно представить с помощью вещественных типов данных. Поэтому характеризовать каждую точку будем множеством отрезков, которые пересекаются в этой точке.<br /> <br /> Для упрощения понимания введем два ограничения на входные данные:<br /> * не существует вертикальных отрезков<br /> * не существует пары отрезков, имеющих более одной общей точки<br /> * никакие три отрезка не пересекаются в одной точке<br /> <br /> Как обрабатывать эти случаи будет объяснено позднее.<br /> <br /> ==Алгоритм==<br /> <br /> ===Основная идея===<br /> Алгоритм будет основан на идее сканирующей прямой. Опишем три типа событий, которые мы и будем обрабатывать:<br /> * начался новый отрезок<br /> * два отрезка пересеклись<br /> * отрезок закончился<br /> <br /> Сканирующая прямая будет расположена параллельно оси ординат, и двигаться вдоль оси абсцисс в сторону ее положительного направления. Учитывая введенные ограничения на входные данные, прямая никогда не будет проходить через два события одновременно.<br /> <br /> ===Статус===<br /> [[Файл:pic2.jpg|right|560|thumb|Иллюстрация определения статуса]]<br /> Назовем статусом множество, в которой содержатся все отрезки, пересекающие нашу сканирующую прямую. Важно, что эти отрезки должны быть упорядочены по возрастанию (или убыванию) координаты их пересечения с прямой. Заметим, что в процессе работы алгоритма отрезки могут добавляться в произвольные места этого упорядоченной множества, удаляться из произвольных мест или меняться местами друг с другом.<br /> <br /> ===Важная мысль===<br /> Попробуем найти событие, которое случится раньше всех других, если наша прямая уже пересекает какие-то отрезки. Нам, в данный момент, интересен случай, когда это событие является пересечением отрезков. Важно, что в этом пересечении участвуют два отрезка, которые обязательно являются соседними в нашем статусе.<br /> <br /> ====Доказательство====<br /> Предположим, что это не так. Значит, между этими двумя пересекающимися отрезками существует еще хотя бы один. Поскольку эти два отрезка пересекаются, то или третий пересекает перед их пересечением один из них, или пересекается с ними в той же точке. В любом случае, Важная мысль верна<br /> <br /> ===В итоге===<br /> [[Файл:anim1.gif|right|560|thumb|Пример работы алгоритма]]<br /> Изначально у нас есть только события вида "начался отрезок" и "закончился отрезок". События вида "пересекаются два отрезка" будут добавляться нами в множество еще не обработанных событий. Соответственно, алгоритм выглядит так: выбираем то событие из множества необработанных, у которого наименьшая координата <tex>X</tex>, обрабатываем, делаем так, пока множество необработанных событий непустое. Плюс, на протяжении всего алгоритма должен поддерживаться следующий инвариант: в множество необработанных событий уже добавлены все пересечения отрезков, которые в текущем статусе текущие.<br /> <br /> ===Обработка событий===<br /> ====Событие "начало отрезка"====<br /> Находим в статусе два отрезка, между которыми будет находится тот, который начинается. После этого добавляем его в статус на это место и точки его пересечения с соседними добавляем в множество необработанных событий.<br /> <br /> ====Событие "конец отрезка"====<br /> Находим в статусе отрезок, который заканчивается. Удаляем его оттуда, после чего в множество необработанных событий добавляем точку, в которой пересекаются отрезки, которые были соседями заканчивающегося в старом статусе. Это необходимо, потому что в новом статусе они станут соседними. Заметим, что добавляемое событие может уже находиться в множестве, но нас это совершенно не напрягает.<br /> <br /> ====Событие "пересечение отрезков"====<br /> Находим в статусе два отрезка, которые пересекаются. Меняем их местами (это действительно происходит). После этого добавляем в множество пересечения двух новых пар соседей, которые появились после перестановки пересекшихся отрезков.<br /> <br /> ==Обработка "нехороших случаев"==<br /> ===Сканирующая точка===<br /> Решим, для начала, вопрос с вертикальными отрезками. Важно, что заодно пропадет и проблема с обработкой событий, имеющих одинаковую координату по оси <tex>X</tex>.<br /> <br /> [[Файл:anim2.gif|right|560|thumb|Сканирующая точка]]<br /> Слегка поменяем нашу концепцию. Сканирующая прямая теперь становится не совсем прямой. Теперь у нас появляется, скорее, сканирующая точка. Суть изменения в следующем: в случае, если несколько событий попадают на одну вертикальную прямую, мы их обрабатываем в порядке возрастания координаты по оси <tex>X</tex>. Внимательный читатель сейчас, наверное, воскликнет: "А как же тогда наш статус? Ведь отрезки не могут пересекать точку!". Однако и это не является проблемой. Если отрезок, который лежит в статусе, не вертикален, то он сортируется по своей координате <tex>Y</tex>, в которой он пересекается с вертикальной прямой, проведенной через нашу точку (да, это бывшая сканирующая прямая). А вот если отрезок вертикален, то его параметром является как раз ордината "сканирующей точки". <s>Если внимательно подумать, то все будет корректно.</s><br /> <br /> ===Несколько отрезков в одной точке===<br /> ====Первый метод решения проблемы====<br /> У нас есть упорядоченное множество необработанных событий. Давайте перед добавлением события будем проверять, а нет ли его там. Если оно там уже есть, то события вида "в этой точке перечекаются отрезки <tex>A</tex> и <tex>B</tex>", превратится в событие вида "в этой точке пересекаются отрезки <tex>A</tex>, <tex>B</tex> и <tex>C</tex>". В процессе обработки этой точки порядок следования в статусе всех отрезков, пересекающихся в ней, просто инвертируется. Соответственно, проблема решилась.<br /> <br /> ====Второй метод решения проблемы====<br /> На самом деле, посмотрим более внимательно, что произойдет в этой точке. Все пересечения всех пар обработаются. Всего таких пар <tex>k^2</tex>, где в точке пересекается <tex>k</tex> отрезков. Если в некой перестановке делается <tex>k^2</tex> элементарных транспозиций, и ни одна из них не повторяется, то перестановка становится инвертированной. Так что, даже если оставить все как есть, то все будет работать. <s>Такие дела.</s> Здесь тоже должна быть соответствующая анимашка.<br /> <br /> ===СНМ вместо отрезков===<br /> '''Внимание! Этот раздел должен интересовать только <s>задротов</s> любознательных, так как он описывает разбор случая, который нам, по обещанию Ковалева, не встретится.'''<br /> Нам остался последний сложный случай: наложение двух или более отрезков друг для друга. Давайте теперь вместо просто отрезков будем класть в СНМ следующее: множество отрезков, которые на данном этапе накладываются друг на друга. Понятно, что при добавлении нового отрезка он или создает свое множество, или добавляется в уже существующее. При удалении удаляется из множества, если оно осталось пустым — удаляется и само множество. А при пересечении с другим множеством попарно пересекаются все отрезки из двух множеств. При этом важно, что все отрезки, накладывающиеся друг на друга, должны занимать в статусе одну ячейку, т. е. являться одним множеством.<br /> <br /> ==Реализация алгоритма==<br /> ===Двоичное дерево поиска в качестве статуса===<br /> Из определения статуса ясно, какую структуру удобно использовать в качестве статуса: двоичное дерево поиска. В нем удобно делать все необходимые операции, и выполняться они будут за <tex>O(log_2(n))</tex>.<br /> <br /> ===Реализация множества необработанных событий===<br /> ====Приоритетная очередь====<br /> Опять же, эта идея возникает в процессе описания этого множества. При этом понятно, что точки сравниваются сначала по абсциссе, в случае равенства — по ординате.<br /> ====Двоичное дерево поиска====<br /> В принципе, вполне себе вариант реализации упорядоченного множества. Но его стоит использовать только тогда, когда мы хотим рассматривать пересечение нескольких отрезков в одной точке в качестве отдельного случая, а не как несколько попарных пересечений. Заметим, что это существенно усложняет реализацию.<br /> <br /> ===Наконец, абсолютная точность===<br /> Заметим, что мы не умеем получать абсолютно точные координаты пересечения двух отрезков. Однако, мы умеем представлять эти координаты в качестве суммы произведений нескольких чисел (просто пересечение прямых и раскрытие скобок в верхней части дроби). А сами координаты нам и не требуются, нам необходимо только уметь сравнивать эти координаты друг с другом. Сравнивать же эти суммы произведений с другими такими же суммами и с обычными числами (в обобщенном представлении тоже такими же суммами) мы тоже умеем. Победа!<br /> <br /> [[Категория: Вычислительная геометрия]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%A3%D0%B8%D1%82%D0%BD%D0%B8&diff=16840 Формула Уитни 2012-01-16T19:59:53Z

<p>System29a: </p> <hr /> <div>{{Теорема<br /> |about=<br /> Уитни<br /> |statement=<br /> Пусть <tex>G</tex> - обыкновенный <tex>(n, m)</tex> - граф. Тогда коэффициент при <tex>x^i</tex>, где <tex>1\le i\le n</tex> в хроматическом многочлене <tex>P(G, x)</tex> равен <tex>\sum \limits_{j=0}^{m}{(-1)^jN(i, j)}</tex>, где <tex>N(i, j)</tex> - число остовных подграфов графа <tex>G</tex>, имеющих <tex>i</tex> компонент связности и <tex>j</tex> рёбер, т.е. <tex>P(G, x) = \sum \limits_{i=1}^{n}{(\sum \limits_{j=0}^{m}{(-1)^jN(i, j))x^i}}.</tex><br /> |proof=<br /> <br>Пусть <tex>K</tex> — некоторый набор из <tex>x</tex> красок. Отображение <tex>\phi</tex> из <tex>VG</tex> в <tex>K</tex>, не являющееся раскраской графа <tex>G</tex>, будем называть его ''несобственной'' раскраской. Всего собственных и несобственных <tex>x</tex> — раскрасок графа <tex>G</tex> — <tex>x^n</tex>.<br>Возьмём некоторую собственную или несобственную раскраску графа <tex>G</tex>. Удалим из графа каждое ребро, концы которого раскрашены в разный цвет. Получим остовный подграф <tex>H</tex>, в котором каждое ребро соединяет вершины одинакового цвета. Исходную собственную или несобственную раскраску будем называть ''строго несобственной'' раскраской остовного подграфа <tex>H</tex>. Каждой компоненте связности графа <tex>H</tex> соответствует точно один цвет - цвет её вершин. Если остовный подграф <tex>H</tex> имеет <tex>i</tex> компонент связности, то есть <tex>x^i</tex> различных строго несобственных раскрасок, отвечающих остовному подграфу <tex>H</tex>.<br>Каждая собственная или несобственная раскраска графа <tex>G</tex> является строго несобственной раскраской его остовного подграфа. Собственным раскраскам графа <tex>G</tex> отвечает нулевой остовный подграф.<br>Пусть <tex>N(i, j)</tex> — число остовных подграфов графа <tex>G</tex>, имеющих <tex>i</tex> компонент связности и <tex>j</tex> рёбер.<br><br /> Из общего числа <tex>x^n</tex> собственных и не собственных раскрасок вычтем число строго несобственных раскрасок остовных подграфов, имеющих ровно одно ребро. Если мы вычтем сумму <tex> \sum \limits_{i}{N(i, 1)x^i} </tex>, то мы вычтем помимо указанного числа ещё и строго несобственные раскраски остовного подграфа, содержащего ровно два ребра. Более того, это число мы вычтем дважды. Подобным образом, число строго несобственных раскрасок остовных подграфов, содержащих точно три, четыре и более ребер будет вычтено соответствующее число раз.<br/><br /> Попытаемся скомпенсировать двукратное вычитание добавлением <tex>\sum \limits_{i}{N(i, 2)x^i}</tex>, однако при этом добавится излишек строго несобственных раскрасок для остовных подграфов с тремя, четырьмя и более ребрами. <br/><br /> Подобную конструкцию можно рассчитать по [[Формула включения-исключения|формуле включения-исключения]]. <br /> Воспользуемся формулой и получим число собственных раскрасок графа <tex>G</tex>. Оно равно <tex>x^n - \sum \limits_{i}{N(i, 1)x^i} + \sum \limits_{i}{N(i, 2)x^i} - \sum \limits_{i}{N(i, 3)x^i} + ...</tex><br>Так как <tex>N(n, 0) = 1</tex>, то <tex>P(G, x) = \sum \limits_{j=0}^{m}{\sum \limits_{i=1}^{n}{(-1)^jN(i, j)x^i}} = \sum \limits_{i=1}^{n}{\sum \limits_{j=0}^{m}{(-1)^jN(i, j)x^i}}</tex>.<br /> }}<br /> <br /> ==Литература==<br /> * Асанов М,, Баранский В., Расин В. - Дискретная математика - Графы, матроиды, алгоритмы<br /> <br /> [[Категория: Алгоритмы и структуры данных]]<br /> [[Категория: Раскраски графов ]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A5%D1%80%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%D1%87%D0%BB%D0%B5%D0%BD&diff=16809 Хроматический многочлен 2012-01-16T19:01:48Z

<p>System29a: /* Рекуррентные формулы для хроматических многочленов */</p> <hr /> <div>{{Определение<br /> |definition=Пусть дан фиксированный граф <tex>G</tex> и фиксированное число красок <tex>x</tex>. Количество способов правильной <tex>x</tex>-раскраски графа <tex>G</tex> называется '''хроматическим многочленом'''. Обозначают <tex>P(G,x)</tex>.<br /> }}<br /> <br /> == Хроматический многочлен полного графа ==<br /> <tex>P(K_{n},x)=x(x-1)...(x-n+1)=x^{\underline{n}}</tex>, так как первую вершину полного графа <tex>K_{n}</tex> можно окрасить в любой из <tex>x</tex> цветов, вторую — в любой из оставшихся <tex>x-1</tex> цветов и т. д. Очевидно, что если <tex>x</tex> меньше <tex>n</tex>, то и многочлен равен <tex>0</tex>, так как один из его множителей <tex>0</tex>.<br /><br /> <br /> == Хроматический многочлен пустого графа ==<br /> <tex>P(O_{n},x)=x^{n}</tex>, так как каждую из <tex>n</tex> вершин нулевого графа <tex>O_{n}</tex> можно независимо окрасить в любой из <tex>x</tex> цветов.<br /><br /> Примечание. Нулевой граф <tex>O_{n}</tex> также можно обозначать <tex>\overline{K_{n}}</tex> (дополнительный граф для полного графа <tex>K_{n}</tex>).<br /> <br /> == Хроматический многочлен дерева ==<br /> {{Теорема<br /> |about=<br /> хроматический многочлен дерева<br /> |statement=<br /> Граф <tex>G</tex> с <tex>n</tex> вершинами является деревом тогда и только тогда, когда <tex>P(G,x)=x(x-1)^{n-1}</tex>.<br /> |proof=<br /> Сначала покажем, что хроматический многочлен любого дерева <tex>T</tex> с <tex>n</tex> вершинами есть <tex>x(x-1)^{n-1}</tex>.<br /><br /> Доказательство индукцией по числу <tex>n</tex>. Для <tex>n=1</tex> и <tex>n=2</tex> результат очевиден. Предположим, что <tex>P(T',x)=x(x-1)^{n-2}</tex> для любого дерева <tex>T'</tex> с количеством вершин равным <tex>n-1</tex>. Пусть <tex>uv</tex> — ребро дерева <tex>T</tex>, такое что <tex>v</tex> является висячей вершиной. Хроматический многочлен дерева <tex>T</tex> без ребра <tex>uv</tex> равен <tex>P(T/uv,x)=x(x-1)^{n-2}</tex> по нашему предположению. Вершину <tex>v</tex> можно окрасить <tex>x-1</tex> способом, так как её цвет должен только лишь отличаться от цвета вершины <tex>u</tex>. Итого: <tex>P(T,x)=(x-1)P(T/uv,x)=x(x-1)^{n-1}</tex>.<br /><br /><br /> Обратно, пусть <tex>G</tex> — граф, у которого <tex>P(G,x)=x(x-1)^{n-1}</tex>. Тогда верны два следующих утверждения:<br /><br /> 1. Граф <tex>G</tex> связен, потому что если было бы две компоненты связности (или больше), то <tex>P(G,x)</tex> делился бы на <tex>x^2</tex> без остатка.<br /><br /> 2. В графе <tex>G</tex> количество рёбер равно <tex>n-1</tex>, так как по одной из теорем о коэффициентах хроматического многочлена ([[Хроматический многочлен#Коэффициенты хроматического многочлена|Коэффициенты хроматического многочлена]], теорема 4), количество рёбер в графе соответствует коэффициенту при <tex>x^{n-1}</tex>, взятому со знаком минус. В нашем случае, этот коэффициент удобно искать, используя бином Ньютона:<br /><br /> <tex>{P(G,x)=x(x-1)^{n-1}=x\left(x^{n-1}-{n-1 \choose 1}x^{n-2}+{n-1 \choose 2}x^{n-3}-...+(-1)^{n-1}\right)=x^{n}-(n-1)x^{n-1}+...+(-1)^{n-1}x}</tex><br /><br /> Из этих двух утверждений (связность и <tex>n-1</tex> ребро) следует, что граф <tex>G</tex> является деревом (см. [[Дерево, эквивалентные определения]], утверждения 1 и 3).<br /> }}<br /> <br /> == Рекуррентные формулы для хроматических многочленов ==<br /> Граф <tex>G/uv</tex> — граф, полученный из графа <tex>G</tex> стягиванием ребра <tex>uv</tex>, то есть у которого вершины <tex>u</tex> и <tex>v</tex> будут отождествлены и при этом будут отброшены все петли и кратность ребер будет сведена к единице.<br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> - несмежные вершины графа <tex>G</tex>. Если <tex>G_1=G\cup uv</tex>, а <tex>G_2=G/uv</tex> (стягивание ребра) , то <tex>P(G,x)=P(G_1,x)+P(G_2,x)</tex>.<br /> |proof=<br /> Рассмотрим все произвольные раскраски графа <tex>G</tex>. Рассмотрим те из них, при которых вершины <tex>u</tex> и <tex>v</tex> окрашены в разные цвета. Если добавить к графу <tex>G</tex> ребро <tex>uv</tex>, то они не изменятся, то есть останутся правильными. Рассмотрим раскраски, при которых <tex>u</tex> и <tex>v</tex> одного цвета. Все эти раскраски останутся правильными и для графа, полученного из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>.<br /> }}<br /> '''Замечание:'''<br /> Если к некоторому произвольному графу добавлять ребра последовательно, не меняя его вершин, то на каком-то шаге мы получим полный граф. Аналогично мы получим полный граф, если в произвольном графе уменьшим число вершин, путем их отождествления, не меняя числа ребер. <br /> <br /> '''Следствие:'''<br /> Хроматический многочлен любого графа <tex>G</tex> равен сумме хроматических многочленов некоторого числа полных графов, число вершин в которых не больше, чем в графе <tex>G</tex>.<br /> <br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> — смежные вершины графа <tex>G</tex>. Если <tex>G_1=G\backslash uv</tex> и <tex>G_2=G/uv</tex>, то <tex>P(G,x)=P(G_1,x)-P(G_2,x)</tex>.<br /> |proof=<br /> Следует из предыдущей теоремы.<br /> }}<br /> <br /> == Коэффициенты хроматического многочлена ==<br /> {{Теорема<br /> |about=<br /> 1<br /> |statement=<br /> Свободный член хроматического многочлена равен <tex>0</tex>.<br /> |proof=<br /> По определению хроматического многочлена графа <tex>G</tex>, его значение в точке <tex>x</tex> равно количеству способов раскрасить вершины <tex>G</tex> правильным образом в <tex>x</tex> цветов. Количество способов раскрасить граф в <tex>0</tex> цветов равно <tex>0</tex>. То есть <tex>P(G,0)=0</tex>. Из этого следует, что <tex>P(G,x)</tex> кратен <tex>x</tex>, следовательно его свободный член равен <tex>0</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 2<br /> |statement=<br /> Старший коэффициент хроматического многочлена равен <tex>1</tex>.<br /> |proof=<br /> Воспользуемся рекуррентной формулой:<br/><br /> <tex>P(G,x) = P(G_{1},x) + P(G_{2},x)</tex>,<br/><br /> где <tex>G_{1}</tex> — граф, полученный из <tex>G</tex> добавлением отсутствующего в <tex>G</tex> ребра <tex>uv</tex>, а <tex>G_{2}</tex> — граф, полученный из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex> в одну и удалением возникших при этом кратных ребер.<br /> Применяя рекуррентную формулу повторно, хроматический полином можно представить в виде суммы хроматических полиномов полных графов, то есть:<br/><br /> <tex>P(G,x) = {P(K_{n},x) + a_{1}P(K_{n-1},x) + a_{2}P(K_{n-2},x) + \ldots = x^{\underline{n}} + a_{1}x^{\underline{n-1}}+a_{2}x^{\underline{n-2}}+\ldots}</tex><br/><br /> Из этой формулы видно, что хроматический многочлен имеет старший коэффициент, равный <tex>1</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 3<br /> |statement=<br /> Коэффициенты хроматического многочлена составляют знакопеременную последовательность.<br /> |proof=<br /> Индукция по количеству вершин.<br/><br /> '''База индукции:'''<br/><br /> Теорема верна для графа <tex>G</tex> из одной вершины, потому что <tex>P(G,x)=x</tex>.<br/><br /> '''Индукционный переход''' (<tex>n \to n+1)</tex>:<br/><br /> Предположим, что теорема верна для всех графов на <tex>n</tex> вершинах. Рассмотрим графы на <tex>n+1</tex> вершине.<br /> Индукционный переход будем доказывать индукцией по количеству ребер графа <tex>G</tex>. Если <tex>G</tex> не содержит ребер, то есть <tex>G</tex> является <tex>O_{n+1}</tex>, то его хроматический многочлен <tex>P(G,x)=x^{n+1}</tex> обладает доказываемым свойством. Теперь предположим, что для всех <tex>(n+1,m)</tex>-графов теорема верна. Возьмем <tex>(n+1,m+1)</tex>-граф <tex>G_{1}</tex> и его ребро <tex>uv</tex>. Обозначим за <tex>G</tex> граф, полученный из <tex>G_{1}</tex> удалением ребра <tex>uv</tex> (<tex>G=G_{1}-uv</tex>), а за <tex>G_{2}</tex> — граф, полученный из <tex>G_{1}</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>. Тогда из рекуррентной формулы следует:<br/><br /> <tex>P(G_{1},x)=P(G,x)-P(G_{2},x)</tex>.<br /> Так как <tex>G</tex> — <tex>(n+1,m)</tex>-граф, а в <tex>G_{2}</tex> — <tex>n</tex> вершин, то для <tex>G</tex> и <tex>G_{2}</tex> теорема верна:<br/><br /> <tex>{P(G,x)=x^{n+1}-a_{1}x^{n}+a_{2}x^{n-1}-a_{3}x^{n-2}+\ldots}</tex> ,<br/><br /> <tex>{P(G_{2},x)=x^{n}-b_{1}x^{n-1}+b_{2}x^{n-2}+\ldots}</tex> ,<br/><br /> где <tex>a_{1}</tex>, <tex>a_{2}</tex>, …, <tex>a_{n+1}</tex>, <tex>b_{1}</tex>, <tex>b_{2}</tex>, …, <tex>b_{n}</tex> — некоторые неотрицательные целые числа. Из этих равенств получаем:<br/><br /> <tex>P(G_{1},x)=x^{n+1}-(a_{1}+1)x^{n}+(a_{2}+b_{1})x^{n-1}+\ldots</tex>.<br /> Видно, что в этом полученном полиноме коэффициенты составляют знакопеременную последовательность.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 4<br /> |statement=<br /> Второй коэффициент хроматического многочлена равен по модулю количеству ребер графа.<br /> |proof=<br /> Из доказательства '''Теоремы (3)''' видно, что при увеличении количества ребер графа на <tex>1</tex>, второй коэффициент также увеличивается на <tex>1</tex>. Так как для пустого графа второй коэффициент равен <tex>0</tex>, то утверждение верно для любого графа.<br /> }}<br /> <br /> == См. также ==<br /> == Литература ==<br /> 1. Асанов М. О., Баранский В. А., Расин В. В. - Дискретная математика: Графы, матроиды, алгоритмы: Учебное пособие. 2-е изд., испр. и доп. - СПб.: Издательство "Лань", 2010. - 368 с.: ил. - (Учебники для вузов. Специальная литература). '''ISBN 978-5-8114-1068-2'''<br /><br /> 2. Харари Ф. - Теория графов: Изд. 4-е. - М.: Книжный дом "ЛИБРОКОМ", 2009. - 296 с. '''ISBN 978-5-397-00622-4'''<br /> <br /> [[Категория: Алгоритмы и структуры данных]]<br /> [[Категория: Раскраски графов]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5:%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%A3%D0%B8%D1%82%D0%BD%D0%B8&diff=16127 Обсуждение:Формула Уитни 2012-01-11T02:28:03Z

<p>System29a: Новая страница: «Я не совсем понимаю, как тут можно написать про принцип включения-исключения иначе. С одно...»</p> <hr /> <div>Я не совсем понимаю, как тут можно написать про принцип включения-исключения иначе. С одной одной строкой как было — не совсем понятно откуда взялось. А сейчас, как в Асанове. Зато всё понятно. Чем это плохо?<br><br /> --[[Участник:System29a|System29a]] 05:28, 11 января 2012 (MSK)</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%A3%D0%B8%D1%82%D0%BD%D0%B8&diff=16126 Формула Уитни 2012-01-11T02:24:42Z

<p>System29a: </p> <hr /> <div>{{Теорема<br /> |about=<br /> Уитни<br /> |statement=<br /> Пусть <tex>G</tex> - обыкновенный <tex>(n, m)</tex> - граф. Тогда коэффициент при <tex>x^i</tex>, где <tex>1\le i\le n</tex> в хроматическом многочлене <tex>P(G, x)</tex> равен <tex>\sum \limits_{j=0}^{m}{(-1)^jN(i, j)}</tex>, где <tex>N(i, j)</tex> - число остовных подграфов графа <tex>G</tex>, имеющих <tex>i</tex> компонент связности и <tex>j</tex> рёбер, т.е. <tex>P(G, x) = \sum \limits_{i=1}^{n}{(\sum \limits_{j=0}^{m}{(-1)^jN(i, j))x^i}}.</tex><br /> |proof=<br /> <br>Пусть <tex>K</tex> — некоторый набор из <tex>x</tex> красок. Отображение <tex>\phi</tex> из <tex>VG</tex> в <tex>K</tex>, не являющееся раскраской графа <tex>G</tex>, будем называть его ''несобственной'' раскраской. Всего собственных и несобственных <tex>x</tex> — раскрасок графа <tex>G</tex> — <tex>x^n</tex>.<br>Возьмём некоторую собственную или несобственную раскраску графа <tex>G</tex>. Удалим из графа каждое ребро, концы которого раскрашены в разный цвет. Получим остовный подграф <tex>H</tex>, в котором каждое ребро соединяет вершины одинакового цвета. Исходную собственную или несобственную раскраску будем называть ''строго несобственной'' раскраской остовного подграфа <tex>H</tex>. Каждой компоненте связности графа <tex>H</tex> соответствует точно один цвет - цвет её вершин. Если остовный подграф <tex>H</tex> имеет <tex>i</tex> компонент связности, то есть <tex>x^i</tex> различных строго несобственных раскрасок, отвечающих остовному подграфу <tex>H</tex>.<br>Каждая собственная или несобственная раскраска графа <tex>G</tex> является строго несобственной раскраской его остовного подграфа. Собственным раскраскам графа <tex>G</tex> отвечает нулевой остовный подграф.<br>Пусть <tex>N(i, j)</tex> — число остовных подграфов графа <tex>G</tex>, имеющих <tex>i</tex> компонент связности и <tex>j</tex> рёбер.<br><br /> Из общего числа <tex>x^n</tex> собственных и не собственных раскрасок вычтем число строго несобственных раскрасок остовных подграфов, имеющих ровно одно ребро. Если мы вычтем сумму <tex> \sum \limits_{i}{N(i, 1)x^i} </tex>, то мы вычтем помимо указанного числа ещё и избыточную величину. Действительно, допустим <tex>e_1 = u_1v_1</tex> и <tex>e_2 = u_2v_2</tex> — два различных ребра графа <tex>G</tex>. Тогда в число строго несобственных раскрасок остовного подграфа, содержащего точно одно ребро <tex>e_1</tex>, попадут и те, у которых вершины <tex>e_1</tex> и <tex>e_2</tex>, а это в свою очередь строго несобственные раскраски остовного подграфа, содержащего ровно два ребра <tex>e_1</tex> и <tex>e_2</tex>. При этом их число мы вычтем дважды — для <tex>e_1</tex> и <tex>e_2</tex>. Аналогично, число строго несобственных раскрасок остовных подграфов, содержащих точно три, четыре и более ребер будет вычтено соответствующее число раз.<br/><br /> Добавим сумму <tex>\sum \limits_{i}{N(i, 2)x^i}</tex>, компенсируя при этом двукратное вычитание, но при этом возникнет необходимость компенсации излишне добавленных чисел строго несобственных раскрасок для остовных подграфов с тремя, четырьмя и более ребрами. <br/> <br /> Итого, по [[Формула включения-исключения|принципу включения-исключения]] получаем, что число собственных раскрасок графа <tex>G</tex> равно <tex>x^n - \sum \limits_{i}{N(i, 1)x^i} + \sum \limits_{i}{N(i, 2)x^i} - \sum \limits_{i}{N(i, 3)x^i} + ...</tex><br>Так как <tex>N(n, 0) = 1</tex>, то <tex>P(G, x) = \sum \limits_{j=0}^{m}{\sum \limits_{i=1}^{n}{(-1)^jN(i, j)x^i}} = \sum \limits_{i=1}^{n}{\sum \limits_{j=0}^{m}{(-1)^jN(i, j)x^i}}</tex>.<br /> }}<br /> <br /> ==Литература==<br /> * Асанов М,, Баранский В., Расин В. - Дискретная математика - Графы, матроиды, алгоритмы<br /> <br /> [[Категория: Алгоритмы и структуры данных]]<br /> [[Категория: Раскраски графов ]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A5%D1%80%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%D1%87%D0%BB%D0%B5%D0%BD&diff=16124 Хроматический многочлен 2012-01-11T01:58:52Z

<p>System29a: Перенёс определение в текст доказательства</p> <hr /> <div>{{Определение<br /> |definition=Пусть дан фиксированный граф <tex>G</tex> и фиксированное число красок <tex>x</tex>. Количество способов правильной <tex>x</tex>-раскраски графа <tex>G</tex> называется '''хроматическим многочленом'''. Обозначают <tex>P(G,x)</tex>.<br /> }}<br /> <br /> == Хроматический многочлен полного графа ==<br /> <tex>P(K_{n},x)=x(x-1)...(x-n+1)=x^{\underline{n}}</tex>, так как первую вершину полного графа <tex>K_{n}</tex> можно окрасить в любой из <tex>x</tex> цветов, вторую — в любой из оставшихся <tex>x-1</tex> цветов и т. д. Очевидно, что если <tex>x</tex> меньше <tex>n</tex>, то и многочлен равен <tex>0</tex>, так как один из его множителей <tex>0</tex>.<br /><br /> <br /> == Хроматический многочлен пустого графа ==<br /> <tex>P(O_{n},x)=x^{n}</tex>, так как каждую из <tex>n</tex> вершин нулевого графа <tex>O_{n}</tex> можно независимо окрасить в любой из <tex>x</tex> цветов.<br /><br /> Примечание. Нулевой граф <tex>O_{n}</tex> также можно обозначать <tex>\overline{K_{n}}</tex> (дополнительный граф для полного графа <tex>K_{n}</tex>).<br /> <br /> == Хроматический многочлен дерева ==<br /> {{Теорема<br /> |about=<br /> хроматический многочлен дерева<br /> |statement=<br /> Граф <tex>G</tex> с <tex>n</tex> вершинами является деревом тогда и только тогда, когда <tex>P(G,x)=x(x-1)^{n-1}</tex>.<br /> |proof=<br /> Сначала покажем, что хроматический многочлен любого дерева <tex>T</tex> с <tex>n</tex> вершинами есть <tex>x(x-1)^{n-1}</tex>.<br /><br /> Доказательство индукцией по числу <tex>n</tex>. Для <tex>n=1</tex> и <tex>n=2</tex> результат очевиден. Предположим, что <tex>P(T',x)=x(x-1)^{n-2}</tex> для любого дерева <tex>T'</tex> с количеством вершин равным <tex>n-1</tex>. Пусть <tex>uv</tex> — ребро дерева <tex>T</tex>, такое что <tex>v</tex> является висячей вершиной. Хроматический многочлен дерева <tex>T</tex> без ребра <tex>uv</tex> равен <tex>P(T/uv,x)=x(x-1)^{n-2}</tex> по нашему предположению. Вершину <tex>v</tex> можно окрасить <tex>x-1</tex> способом, так как её цвет должен только лишь отличаться от цвета вершины <tex>u</tex>. Итого: <tex>P(T,x)=(x-1)P(T/uv,x)=x(x-1)^{n-1}</tex>.<br /><br /><br /> Обратно, пусть <tex>G</tex> — граф, у которого <tex>P(G,x)=x(x-1)^{n-1}</tex>. Тогда верны два следующих утверждения:<br /><br /> 1. Граф <tex>G</tex> связен, потому что если было бы две компоненты связности (или больше), то <tex>P(G,x)</tex> делился бы на <tex>x^2</tex> без остатка.<br /><br /> 2. В графе <tex>G</tex> количество рёбер равно <tex>n-1</tex>, так как по одной из теорем о коэффициентах хроматического многочлена ([[Хроматический многочлен#Коэффициенты хроматического многочлена|Коэффициенты хроматического многочлена]], теорема 4), количество рёбер в графе соответствует коэффициенту при <tex>x^{n-1}</tex>, взятому со знаком минус. В нашем случае, этот коэффициент удобно искать, используя бином Ньютона:<br /><br /> <tex>{P(G,x)=x(x-1)^{n-1}=x\left(x^{n-1}-{n-1 \choose 1}x^{n-2}+{n-1 \choose 2}x^{n-3}-...+(-1)^{n-1}\right)=x^{n}-(n-1)x^{n-1}+...+(-1)^{n-1}x}</tex><br /><br /> Из этих двух утверждений (связность и <tex>n-1</tex> ребро) следует, что граф <tex>G</tex> является деревом (см. [[Дерево, эквивалентные определения]], утверждения 1 и 3).<br /> }}<br /> <br /> == Рекуррентные формулы для хроматических многочленов ==<br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> - несмежные вершины графа <tex>G</tex>. Если <tex>G_1=G\cup uv</tex>, а <tex>G_2=G/uv</tex> (стягивание ребра) , то <tex>P(G,x)=P(G_1,x)+P(G_2,x)</tex>.<br /> |proof=<br /> Напомним, что граф <tex>G/uv</tex> — граф, полученный из графа <tex>G</tex> стягиванием ребра <tex>uv</tex>, то есть у которого вершины <tex>u</tex> и <tex>v</tex> будут отождествлены и при этом будут отброшены все петли и кратность ребер будет сведена к единице.<br /> Рассмотрим все произвольные раскраски графа <tex>G</tex>. Рассмотрим те из них, при которых вершины <tex>u</tex> и <tex>v</tex> окрашены в разные цвета. Если добавить к графу <tex>G</tex> ребро <tex>uv</tex>, то они не изменятся, то есть останутся правильными. Рассмотрим раскраски, при которых <tex>u</tex> и <tex>v</tex> одного цвета. Все эти раскраски останутся правильными и для графа, полученного из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>.<br /> }}<br /> '''Замечание:'''<br /> Если к некоторому произвольному графу добавлять ребра последовательно, не меняя его вершин, то на каком-то шаге мы получим полный граф. Аналогично мы получим полный граф, если в произвольном графе уменьшим число вершин, путем их отождествления, не меняя числа ребер. <br /> <br /> '''Следствие:'''<br /> Хроматический многочлен любого графа <tex>G</tex> равен сумме хроматических многочленов некоторого числа полных графов, число вершин в которых не больше, чем в графе <tex>G</tex>.<br /> <br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> — смежные вершины графа <tex>G</tex>. Если <tex>G_1=G\backslash uv</tex> и <tex>G_2=G/uv</tex>, то <tex>P(G,x)=P(G_1,x)-P(G_2,x)</tex>.<br /> |proof=<br /> Следует из предыдущей теоремы.<br /> }}<br /> <br /> == Коэффициенты хроматического многочлена ==<br /> {{Теорема<br /> |about=<br /> 1<br /> |statement=<br /> Свободный член хроматического многочлена равен <tex>0</tex>.<br /> |proof=<br /> По определению хроматического многочлена графа <tex>G</tex>, его значение в точке <tex>x</tex> равно количеству способов раскрасить вершины <tex>G</tex> правильным образом в <tex>x</tex> цветов. Количество способов раскрасить граф в <tex>0</tex> цветов равно <tex>0</tex>. То есть <tex>P(G,0)=0</tex>. Из этого следует, что <tex>P(G,x)</tex> кратен <tex>x</tex>, следовательно его свободный член равен <tex>0</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 2<br /> |statement=<br /> Старший коэффициент хроматического многочлена равен <tex>1</tex>.<br /> |proof=<br /> Воспользуемся рекуррентной формулой:<br/><br /> <tex>P(G,x) = P(G_{1},x) + P(G_{2},x)</tex>,<br/><br /> где <tex>G_{1}</tex> — граф, полученный из <tex>G</tex> добавлением отсутствующего в <tex>G</tex> ребра <tex>uv</tex>, а <tex>G_{2}</tex> — граф, полученный из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex> в одну и удалением возникших при этом кратных ребер.<br /> Применяя рекуррентную формулу повторно, хроматический полином можно представить в виде суммы хроматических полиномов полных графов, то есть:<br/><br /> <tex>P(G,x) = {P(K_{n},x) + a_{1}P(K_{n-1},x) + a_{2}P(K_{n-2},x) + \ldots = x^{\underline{n}} + a_{1}x^{\underline{n-1}}+a_{2}x^{\underline{n-2}}+\ldots}</tex><br/><br /> Из этой формулы видно, что хроматический многочлен имеет старший коэффициент, равный <tex>1</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 3<br /> |statement=<br /> Коэффициенты хроматического многочлена составляют знакопеременную последовательность.<br /> |proof=<br /> Индукция по количеству вершин.<br/><br /> '''База индукции:'''<br/><br /> Теорема верна для графа <tex>G</tex> из одной вершины, потому что <tex>P(G,x)=x</tex>.<br/><br /> '''Индукционный переход''' (<tex>n \to n+1)</tex>:<br/><br /> Предположим, что теорема верна для всех графов на <tex>n</tex> вершинах. Рассмотрим графы на <tex>n+1</tex> вершине.<br /> Индукционный переход будем доказывать индукцией по количеству ребер графа <tex>G</tex>. Если <tex>G</tex> не содержит ребер, то есть <tex>G</tex> является <tex>O_{n+1}</tex>, то его хроматический многочлен <tex>P(G,x)=x^{n+1}</tex> обладает доказываемым свойством. Теперь предположим, что для всех <tex>(n+1,m)</tex>-графов теорема верна. Возьмем <tex>(n+1,m+1)</tex>-граф <tex>G_{1}</tex> и его ребро <tex>uv</tex>. Обозначим за <tex>G</tex> граф, полученный из <tex>G_{1}</tex> удалением ребра <tex>uv</tex> (<tex>G=G_{1}-uv</tex>), а за <tex>G_{2}</tex> — граф, полученный из <tex>G_{1}</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>. Тогда из рекуррентной формулы следует:<br/><br /> <tex>P(G_{1},x)=P(G,x)-P(G_{2},x)</tex>.<br /> Так как <tex>G</tex> — <tex>(n+1,m)</tex>-граф, а в <tex>G_{2}</tex> — <tex>n</tex> вершин, то для <tex>G</tex> и <tex>G_{2}</tex> теорема верна:<br/><br /> <tex>{P(G,x)=x^{n+1}-a_{1}x^{n}+a_{2}x^{n-1}-a_{3}x^{n-2}+\ldots}</tex> ,<br/><br /> <tex>{P(G_{2},x)=x^{n}-b_{1}x^{n-1}+b_{2}x^{n-2}+\ldots}</tex> ,<br/><br /> где <tex>a_{1}</tex>, <tex>a_{2}</tex>, …, <tex>a_{n+1}</tex>, <tex>b_{1}</tex>, <tex>b_{2}</tex>, …, <tex>b_{n}</tex> — некоторые неотрицательные целые числа. Из этих равенств получаем:<br/><br /> <tex>P(G_{1},x)=x^{n+1}-(a_{1}+1)x^{n}+(a_{2}+b_{1})x^{n-1}+\ldots</tex>.<br /> Видно, что в этом полученном полиноме коэффициенты составляют знакопеременную последовательность.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 4<br /> |statement=<br /> Второй коэффициент хроматического многочлена равен по модулю количеству ребер графа.<br /> |proof=<br /> Из доказательства '''Теоремы (3)''' видно, что при увеличении количества ребер графа на <tex>1</tex>, второй коэффициент также увеличивается на <tex>1</tex>. Так как для пустого графа второй коэффициент равен <tex>0</tex>, то утверждение верно для любого графа.<br /> }}<br /> <br /> == См. также ==<br /> == Литература ==<br /> 1. Асанов М. О., Баранский В. А., Расин В. В. - Дискретная математика: Графы, матроиды, алгоритмы: Учебное пособие. 2-е изд., испр. и доп. - СПб.: Издательство "Лань", 2010. - 368 с.: ил. - (Учебники для вузов. Специальная литература). '''ISBN 978-5-8114-1068-2'''<br /><br /> 2. Харари Ф. - Теория графов: Изд. 4-е. - М.: Книжный дом "ЛИБРОКОМ", 2009. - 296 с. '''ISBN 978-5-397-00622-4'''<br /> <br /> [[Категория: Алгоритмы и структуры данных]]<br /> [[Категория: Раскраски графов]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D1%85%D0%BE%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D1%8C_%D0%BF%D0%BE_%D0%BC%D0%B5%D1%80%D0%B5&diff=16034 Сходимость по мере 2012-01-09T22:14:55Z

<p>System29a: </p> <hr /> <div>{{В разработке}}<br /> <br /> [[Предельный переход в классе измеримых функций|<<]][[Классические теоремы теории измеримых функций|>>]]<br /> <br /> Пусть функции <tex>f_n, f</tex> {{---}} измеримы на <tex>E</tex>, множества <tex>E(|f_n - f| \geq \delta)</tex>, где <tex>\delta > 0</tex>, измеримы.<br /> <br /> {{Определение<br /> |definition=<tex>f_n</tex> стремятся по мере на <tex>E</tex> к <tex>f</tex> (<tex>f_n\stackrel{[E]}{\Rightarrow} f</tex>), если <tex>\forall\delta>0 : \mu E(|f_n - f| \geq \delta) \xrightarrow[n\to\infty]{} 0</tex><br /> }}<br /> <br /> В определённом смысле, это наиболее слабый вид сходимости, что подтверждает следующая классическая теорема Лебега.<br /> {{TODO| t=запилить единственность}}<br /> <br /> ==Теорема Лебега==<br /> {{Теорема<br /> |author=Лебег<br /> |statement=<tex>\mu E<+\infty</tex>, <tex>f_n\to f</tex> почти всюду на <tex>E</tex>. Тогда <tex>f_n\stackrel{E}{\Rightarrow} f</tex>.<br /> |proof=<br /> Как мы выяснили ранее, удобно рассматривать <tex>E'=\bigcup\limits_{p=1}^\infty \bigcap\limits_{m=1}^\infty \bigcup\limits_{n=m}^\infty E(|f_n - f| \geq \frac1p)</tex>;<br /> по условию теоремы, <tex>\mu E' = 0</tex>.<br /> <br /> Пусть <tex>B_m = \bigcup\limits_{n=m}^\infty E(|f_n - f| \geq \frac1p) \supset B_{m+1}</tex>, тогда <br /> <tex>\forall p: B = \bigcap\limits_{m=1}^\infty B_m </tex>, очевидно, содержится в <tex>E'</tex>,<br /> поэтому, по полноте меры, <tex>\mu B = 0</tex>.<br /> <br /> <br /> По монотонности меры, <tex>\mu B_i</tex> {{---}} убывающая числовая последовательность. Она ограничена, значит, у неё есть предел. <br /> <br /> Покажем, что он равен нулю. Или, более общий факт: <tex>\mu B_m \to \mu B = 0</tex>.<br /> <br /> Для этого воспользуемся тем, что <tex>\mu E</tex> {{---}} конечен.<br /> <br /> Так как <tex>B = \bigcap\limits_{m=1}^\infty B_m</tex>, то<br /> <tex>\overline B = \bigcup\limits_{m=1}^\infty \overline B_m</tex> (здесь под <tex> \overline X </tex> имеется в виду дополнение <tex> X </tex> до <tex> E </tex>).<br /> <br /> <tex>B_m</tex> {{---}} убывающая (<tex>B_m \supset B_{m+1}</tex>), значит, дополнения растут: <tex>\overline B_m \subset \overline B_{m+1}</tex>.<br /> <br /> Значит, <tex>\overline B = \overline B_1 \cup (\overline B_2 \setminus \overline B_1) \cup (\overline B_3 \setminus \overline B_2) \cup \ldots</tex>.<br /> <br /> <tex>\overline B \subset E</tex>. Значит, <tex>\mu \overline B \leq \mu E < +\infty</tex>.<br /> <br /> По <tex>\sigma</tex>-аддитивности, <tex>\mu\overline B = \mu\overline B_1 + \mu(\overline B_2 \setminus\overline B_1) + \mu(\overline B_3 \setminus \overline B_2) + \cdots</tex>.<br /> <br /> В силу конечности <tex>\mu E</tex>, <tex>\mu(\overline B_{m + 1} \setminus \overline B_{m}) = \mu \overline B_{m + 1} - \mu \overline B_{m} </tex>.<br /> <br /> Вставляя это в ряд и вспоминая, что ряд {{---}} предел частичных сумм, получаем <br /> <tex>\mu\overline B = \mu\overline B_1 - \mu \overline B_1 + \mu\overline B_2 - \mu \overline B_2 + \mu\overline B_3 - \cdots</tex><br /> <br /> Так как частичная сумма этого ряда с номером <tex> m </tex> — не что иное, как <tex> \mu \overline B_m </tex>, то <tex>\mu \overline B_m \rightarrow \mu \overline B </tex>.<br /> <br /> <tex>\mu B_m = \mu E - \mu \overline B_m</tex>, <tex>\mu B = \mu E - \mu \overline B</tex>, отсюда <tex>\mu B_m \to \mu B</tex>.<br /> <br /> В нашем случае <tex>\mu B =0</tex>.<br /> <br /> <tex>\forall p : \mu \bigcup\limits_{n=m}^\infty E(|f_n - f| \geq \frac1p) \to 0</tex><br /> <br /> <tex>\forall \delta > 0\ \exists p_0 \in \mathbb{N} : \frac1{p_0} \leq \delta</tex><br /> <br /> <tex>E(|f_m - f| \geq \delta) \subset E(|f_m-f|\geq \frac1{p_0}) \to 0</tex><br /> <br /> Значит, <tex>f_n \stackrel{E}{\Rightarrow} f</tex> по определению.<br /> }}<br /> <br /> Продемонстрируем теперь, что условие конечности меры важно:<br /> <br /> {{Утверждение<br /> |statement=<br /> <tex> \mu E < +\infty </tex> — существенно.<br /> |proof=<br /> Рассмотрим функции <tex>f_n(x)=\begin{cases}0 &, 0 \leq x < n\\1 &, x\geq n\end{cases}</tex>, <tex>E = \mathbb{R}^+</tex>.<br /> <br /> При фиксированном <tex>x</tex>, для всех <tex>n > N: n > x \Rightarrow f_n(x) = 0</tex>. Значит, <tex>f_n(x) \xrightarrow[n \to \infty]{} 0</tex> всюду на <tex>\mathbb{R}^+</tex>. <tex>\lambda(\mathbb{R^+}) = +\infty</tex><br /> <br /> Возьмем <tex>\delta=\frac12</tex>, <tex>E(|f_n - f|\geq \delta) = \mathbb{R}^+(|f_n(x)| \geq \frac12) = [n; +\infty)</tex><br /> <br /> Значит, <tex>\lambda E(|f_n-f|\geq \delta) = +\infty</tex><br /> <br /> Значит, <tex>f_n \not\Rightarrow 0</tex>, хотя стремится к <tex>0</tex> почти всюду.<br /> }}<br /> <br /> Замечание: даже в случае конечной меры <tex> E </tex> последовательность функций, сходящаяся по мере, может не иметь предела ни в одной точке.<br /> <br /> [[Предельный переход в классе измеримых функций|<<]][[Классические теоремы теории измеримых функций|>>]]<br /> [[Категория:Математический анализ 2 курс]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D1%85%D0%BE%D0%B4%D0%B8%D0%BC%D0%BE%D1%81%D1%82%D1%8C_%D0%BF%D0%BE_%D0%BC%D0%B5%D1%80%D0%B5&diff=16033 Сходимость по мере 2012-01-09T22:10:06Z

<p>System29a: </p> <hr /> <div>{{В разработке}}<br /> <br /> [[Предельный переход в классе измеримых функций|<<]][[Классические теоремы теории измеримых функций|>>]]<br /> <br /> Пусть функции <tex>f_n, f</tex> {{---}} измеримы на <tex>E</tex>, множества <tex>E(|f_n - f| \geq \delta)</tex>, где <tex>\delta > 0</tex>, измеримы.<br /> <br /> {{Определение<br /> |definition=<tex>f_n</tex> стремятся по мере на <tex>E</tex> к <tex>f</tex> (<tex>f_n\stackrel{[E]}{\Rightarrow} f</tex>), если <tex>\forall\delta>0 : \mu E(|f_n - f| \geq \delta) \xrightarrow[n\to\infty]{} 0</tex><br /> }}<br /> <br /> В определённом смысле, это наиболее слабый вид сходимости, что подтверждает следующая классическая теорема Лебега.<br /> <br /> {{TODO| t=запилить единственность}}<br /> <br /> ==Теорема Лебега==<br /> {{Теорема<br /> |author=Лебег<br /> |statement=<tex>\mu E<+\infty</tex>, <tex>f_n\to f</tex> почти всюду на <tex>E</tex>. Тогда <tex>f_n\stackrel{E}{\Rightarrow} f</tex>.<br /> |proof=<br /> Как мы выяснили ранее, удобно рассматривать <tex>E'=\bigcup\limits_{p=1}^\infty \bigcap\limits_{m=1}^\infty \bigcup\limits_{n=m}^\infty E(|f_n - f| \geq \frac1p)</tex>;<br /> по условию теоремы, <tex>\mu E' = 0</tex>.<br /> <br /> Пусть <tex>B_m = \bigcup\limits_{n=m}^\infty E(|f_n - f| \geq \frac1p) \supset B_{m+1}</tex>, тогда <br /> <tex>\forall p: B = \bigcap\limits_{m=1}^\infty B_m </tex>, очевидно, содержится в <tex>E'</tex>,<br /> поэтому, по полноте меры, <tex>\mu B = 0</tex>.<br /> <br /> <br /> По монотонности меры, <tex>\mu B_i</tex> {{---}} убывающая числовая последовательность. Она ограничена, значит, у неё есть предел. <br /> <br /> Покажем, что он равен нулю. Или, более общий факт: <tex>\mu B_m \to \mu B = 0</tex>.<br /> <br /> Для этого воспользуемся тем, что <tex>\mu E</tex> {{---}} конечен.<br /> <br /> Так как <tex>B = \bigcap\limits_{m=1}^\infty B_m</tex>, то<br /> <tex>\overline B = \bigcup\limits_{m=1}^\infty \overline B_m</tex> (здесь под <tex> \overline X </tex> имеется в виду дополнение <tex> X </tex> до <tex> E </tex>).<br /> <br /> <tex>B_m</tex> {{---}} убывающая (<tex>B_m \supset B_{m+1}</tex>), значит, дополнения растут: <tex>\overline B_m \subset \overline B_{m+1}</tex>.<br /> <br /> Значит, <tex>\overline B = \overline B_1 \cup (\overline B_2 \setminus \overline B_1) \cup (\overline B_3 \setminus \overline B_2) \cup \ldots</tex>.<br /> <br /> <tex>\overline B \subset E</tex>. Значит, <tex>\mu \overline B \leq \mu E < +\infty</tex>.<br /> <br /> По <tex>\sigma</tex>-аддитивности, <tex>\mu\overline B = \mu\overline B_1 + \mu(\overline B_2 \setminus\overline B_1) + \mu(\overline B_3 \setminus \overline B_2) + \cdots</tex>.<br /> <br /> В силу конечности <tex>\mu E</tex>, <tex>\mu(\overline B_{m + 1} \setminus \overline B_{m}) = \mu \overline B_{m + 1} - \mu \overline B_{m} </tex>.<br /> <br /> Вставляя это в ряд и вспоминая, что ряд {{---}} предел частичных сумм, получаем <br /> <tex>\mu\overline B = \mu\overline B_1 - \mu \overline B_1 + \mu\overline B_2 - \mu \overline B_2 + \mu\overline B_3 - \cdots</tex><br /> <br /> Так как частичная сумма этого ряда с номером <tex> m </tex> — не что иное, как <tex> \mu \overline B_m </tex>, то <tex>\mu \overline B_m \rightarrow \mu \overline B </tex>.<br /> <br /> <tex>\mu B_m = \mu E - \mu \overline B_m</tex>, <tex>\mu B = \mu E - \mu \overline B</tex>, отсюда <tex>\mu B_m \to \mu B</tex>.<br /> <br /> В нашем случае <tex>\mu B =0</tex>.<br /> <br /> <tex>\forall p : \mu \bigcup\limits_{n=m}^\infty E(|f_n - f| \geq \frac1p) \to 0</tex><br /> <br /> <tex>\forall \delta > 0\ \exists p_0 \in \mathbb{N} : \frac1{p_0} \leq \delta</tex><br /> <br /> <tex>E(|f_m - f| \geq \delta) \subset E(|f_m-f|\geq \frac1{p_0}) \to 0</tex><br /> <br /> Значит, <tex>f_n \stackrel{E}{\Rightarrow} f</tex> по определению.<br /> }}<br /> <br /> Продемонстрируем теперь, что условие конечности меры важно:<br /> <br /> {{Утверждение<br /> |statement=<br /> <tex> \mu E < +\infty </tex> — существенно.<br /> |proof=<br /> Рассмотрим функции <tex>f_n(x)=\begin{cases}0 &, 0 \leq x < n\\1 &, x\geq n\end{cases}</tex>, <tex>E = \mathbb{R}^+</tex>.<br /> <br /> При фиксированном <tex>x</tex>, для всех <tex>n > N: n > x \Rightarrow f_n(x) = 0</tex>. Значит, <tex>f_n(x) \xrightarrow[n \to \infty]{} 0</tex> всюду на <tex>\mathbb{R}^+</tex>. <tex>\lambda(\mathbb{R^+}) = +\infty</tex><br /> <br /> Возьмем <tex>\delta=\frac12</tex>, <tex>E(|f_n - f|\geq \delta) = \mathbb{R}^+(|f_n(x)| \geq \frac12) = [n; +\infty)</tex><br /> <br /> Значит, <tex>\lambda E(|f_n-f|\geq \delta) = +\infty</tex><br /> <br /> Значит, <tex>f_n \not\Rightarrow 0</tex>, хотя стремится к <tex>0</tex> почти всюду.<br /> }}<br /> <br /> Замечание: даже в случае конечной меры <tex> E </tex> последовательность функций, сходящаяся по мере, может не иметь предела ни в одной точке.<br /> <br /> [[Предельный переход в классе измеримых функций|<<]][[Классические теоремы теории измеримых функций|>>]]<br /> [[Категория:Математический анализ 2 курс]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:System29a&diff=15886 Участник:System29a 2012-01-08T14:13:30Z

<p>System29a: </p> <hr /> <div>Артём Попов, 2538</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Sementry/%D0%93%D0%B0%D0%B9%D0%B4_%D0%BF%D0%BE_vizi&diff=14884 Участник:Sementry/Гайд по vizi 2011-12-18T23:18:23Z

<p>System29a: /* Подготовка */</p> <hr /> <div><p align = "right"><i>Дон Хуан добавил, что в его мире подарков не раздают и что всякое знание дается в нем великим трудом.</i></p><br /> <p align = "right"><i>(К. Кастанеда, "Учение Дона Хуана")</i></p><br /> <br /> <br /> <br /> Если вы зашли на эту страницу, то, вероятнее всего, вы не хотите самостоятельно разбираться с устаревшими недокументированными системами. Возможно, у вас нет на это времени, возможно, вам это не интересно, может быть, вам просто лень. Тем не менее, вы готовы написать много-много кода на Java и XML, а потом долго-долго его дебажить. Так или иначе, вы оказались здесь, потому что хотите разобраться с Vizi и написать визуализатор.<br /> <br /> Что же такое Vizi? Это, в некотором роде, фреймворк, который должен облегчить разработку визуализаторов. К сожалению, из-за плохой и незавершенной документации написание приложения с использованием vizi скорее усложняется, а не упрощается. Этот гайд написан для того, чтобы можно было более-менее сориентироваться в процессе разработки и, вопреки всем препятствиям, написать что-то адекватно работающее.<br /> <br /> = Подготовка =<br /> <br /> === Установка ===<br /> Скачиваем [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/vizi-0_4b7.rar последнюю версию Vizi], [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/vizi-0_4b6-bin.rar бинарики предпоследней], [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/classes-1.1.8.jar Java 1.1.8 classes] и [http://mirrors.sonic.net/apache//ant/binaries/apache-ant-1.8.2-bin.zip собранный Apache Ant].<br /> <br /> Распаковываем куда-нибудь последнюю версию Vizi. В папку meta копируем файл "classes-1.1.8.jar". Создаем папку /meta/bin и копируем содержимое папки apache-ant-1.8.2 туда (чтобы получились папки /meta/bin/bin, /meta/bin/lib, etc.). Туда же, куда распаковали последнюю Vizi (т.е. туда, где лежит корневая папка vizi), распаковываем бинарники предпоследней, дополняя недостающие файлы. Заменять новые версии старыми не нужно.<br /> <br /> Теперь надо немного подправить xml-файлы для сборки, конечно, если у вас нет Java 1.1. В /meta/scripts/build/build-compile.xml исправляем debuglevel на "lines,vars,source" в 154 строчке и target на "1.7" или "1.6" (в зависимости от версии jdk). Возможно, нужно исправить что-то еще, но, мне кажется, это все. (если этого недостаточно, нужно исправить аналогичным образом строчки 137 и 138 --[[Участник:Glukos|Иван Раков]] 02:01, 18 декабря 2011 (MSK))<br /> <br /> === Для пользователей Windows ===<br /> Добавляем в систему переменную окружения java_home, в ней прописываем путь к jdk. Путь не должен содержать пробелов. Hint: в Windows можно заменить "Program Files" на "Progra~1". А "Program Files [x86]" на "Progra~2", да.<br /> <br /> Возвращаемся в корень папки vizi и пробуем запустить ant.bat без параметров. <br /> Если я написал эту часть гайда правильно, а вы правильно выполнили предыдущие действия, то все должно скомпилироваться, вы получите сообщение "BUILD SUCCESSFUL", а в корне появится новая папка deploy, в которой будет лежать визуализатор для поиска максимума.<br /> <br /> === Для пользователей Linux ===<br /> Как вы могли заметить, для сборки проекта в vizi есть файлик ant.bat. Для того, чтобы получить соответствующий файл для сборки понятный Linux, выполните следующие действия:<br /> <br /> В системе должны быть прописаны соответственные переменные окружения. Посмотрите на свой <code>~/.profile</code>(или на .bashrc, тогда надо будет всего лишь открыть новую консоль, а не перелогиниваться --[[Участник:Dgerasimov|Дмитрий Герасимов]]) и добавьте при необходимости следующие строчки: <br/><br /> <code><br /> JAVA_HOME=/home/jambo/soft/java/jdk1.6.0_24 (то есть путь до jdk) <br/><br /> export JAVA_HOME<br /> <br /> JDK_HOME=$JAVA_HOME <br/><br /> export JDK_HOME<br /> <br /> JRE_HOME=$JAVA_HOME/jre <br/><br /> export JRE_HOME<br /> <br /> ANT_HOME=/home/jambo/soft/apache-ant (то есть путь до apache-ant) <br/><br /> export ANT_HOME<br /> <br /> PATH=$PATH:$JDK_HOME/bin <br/><br /> PATH=$PATH:$JRE_HOME/bin <br/><br /> PATH=$PATH:$ANT_HOME/bin <br/><br /> export PATH <br/><br /> </code><br /> <br /> Для того, чтобы все изменения <code>.profile</code> вступили в силу, нужно перезагрузить машину (или завершить сеанс пользователя и снова зайти)<br /> <br /> Ок, переменные окружения мы прописали.<br /> Теперь в папке с vizi создайте файл <code>ant.sh</code>, дайте ему права на выполнения командой <code>chmod +x ant.sh</code><br /> в файлик поместите следующее содержимое: <br/><br /> <code><br /> #!/bin/sh <br/><br /> <br /> CLASSPATH=`find meta/bin/lib -maxdepth 3 -name '*.jar' -printf '%p:'`$CLASSPATH <br/><br /> CLASSPATH=`find $JDK_HOME -maxdepth 3 -name '*.jar' -printf '%p:'`$CLASSPATH<br/><br /> <br /> #echo $CLASSPATH<br/><br /> <br /> export CLASSPATH<br/><br /> <br /> exec \<br/><br /> java -classpath "$CLASSPATH" \<br/><br /> org.apache.tools.ant.Main $*<br/><br /> </code><br /> Запускаем командой <code>./ant.sh</code>, должно всё получиться. В папке deploy должен валяться визуализатор примера.<br /> <br /> === Дальше ===<br /> Для того, чтобы скомпилировать что-то еще, нужно исправить строчку project в файле build.properties на путь к нужному проекту. Другие визуализаторы можно взять в Term3. Если у вас собирался поиск максимума, а при попытке сделать то же самое с другим визуализатором начинают появляться ошибки о недостающих классах, то можно взять их из архива rt.jar в jdk и добавить в classes-1.1.8.jar. Также можно просто заменить classes-1.1.8.jar на rt.jar, правда, если это кого-то волнует, он весит на порядок больше. UPD: проблема в том, что конкатенация строк через "+" в Java, похоже, реализована через класс StringBuilder, который появился только в 5 версии. Если вы хотите, чтобы ваш визуализатор полностью соответствовал предъявляемым к нему требованиям, воспользуйтесь методом concat().<br /> <br /> Ура-ура, теперь мы умеем собирать правильно написанный готовый визуализатор!<br /> <br /> Теперь рекомендуется открыть и прочесть docs/readme.html, если вы вдруг это еще не сделали. Что-то пока будет непонятно, но, по крайней мере, вы узнаете про параметры запуска vizi.<br /> <br /> = Написание визуализатора =<br /> <br /> Теперь можно начать писать свой собственный визуализатор. Предварительно я настоятельно рекомендую прочесть [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/XMLFormat-0_01.pdf спецификацию используемых XML-описаний].<br /> <br /> Структуру проекта можно посмотреть в примерах. Если вы хотите пользоваться какой-нибудь средой разработки, то, вероятно, вам понадобятся исходные коды vizi, которые поставляются вместе с ней и также лежат в папке projects/vizi, ее содержимое нужно скопировать в папку вашего проекта, тогда IDE будет знать, что за классы вы хотите использовать. Компилить проект нужно все тем же запуском ant.bat, дебагать из-под IDE не получится, используйте debug-output.<br /> <br /> == %your_project%.xml ==<br /> <br /> Берем аналогичный файл из уже готового проекта и меняем все параметры на соответствующие нашему проекту, тут проблем возникнуть не должно.<br /> <br /> == %your_project%-algorithm.xml ==<br /> <br /> Пожалуй, самая неприятная часть. Да-да, логику программы мы будем писать на языке разметки XML. Для подробных сведений о спецификации используемого метаязыка читайте указанный двумя абзацами выше файл, а также ознакомьтесь с примерами, здесь я опишу лишь некоторые подводные камни.<br /> <br /> У нас есть конструкции step для присвоений, if-then-else для переменных, while для циклов и call-auto для вызова функции. Можно спокойно объявлять и пользоваться одиночными переменными и массивами примитивных типов, с другими объектами могут возникнуть внезапные осложнения. В описании сказано, что переменные бывают локальными и глобальными. Это не так, переменные бывают только глобальными; главное отличие состоит в том, что значение по умолчанию у глобальных переменных обязательно присутствует, а у локальных {{---}} обязательно отсутствует. Поэтому с рекурсией все грустно, если она необходима, то, видимо, нужно написать стек самостоятельно, либо использовать на свой страх и риск объект stack, который Vizi сама пропишет(но позже там могут возникнуть проблемы с обращением автомата). Можно также схалтурить и написать основную часть кода в визуализаторе, а xml-файл менять как угодно, лишь бы только запланированное разбиение вашего алгоритма на шаги, которые будет видеть пользователь, оставалось прежним.<br /> <br /> Рекомендуемый способ разработки: взять тщательно протестированный и уже сданный код вашего алгоритма на Java, выкинуть из него все сложные классы и языковые конструкции, включая рекурсию и циклы for и свалить все переменные в одну кучу "class Data". Сохраните люмпенизированный таким образом код и убедитесь в том, что он все еще работает так, как надо. Теперь полученный код можно постепенно перерабатывать в xml-файл, окружая все действия нужными тегами. Пока лучше ничего не рисовать, тег draw можно добавить и потом.<br /> <br /> Аргументы в комментарии к шагу задаются как {0}, {1}, etc. Если вы не хотите показывать какой-то шаг пользователю, комментария у него нет, а он все равно показывается, сделайте значение level равным -1.<br /> <br /> Когда все напишете, запустите ant.bat с параметром debug-source. Если где-то есть ошибка, то вам скажут, где именно. Если все написано верно, то версия кода для дебага должна появиться в папке src/ru/ifmo/vizi/%your_project%/%your_project%Debug.java. Сравните ее на похожесть с ранее упрощенным кодом, должно получиться примерно то же самое. Подебажьте сгенерированный код и убедитесь в том, что оно и работает так, как запланировано. Если все хорошо, то можно запустить ant.bat без параметров, сборка не дойдет до конца, но вы сгенерируете код src/ru/ifmo/vizi/%your_project%/%your_project%.java, который написан уже в стиле автоматного программирования и пригодится вам для написания визуализатора в вашей любимой IDE.<br /> <br /> == %your_project%-configuration.xml ==<br /> <br /> Из этого файла будут подгружаться все параметры для вашего визуализатора. Никаких констант, все должно конфигурироваться через XML! Опять же, начать можно с частей уже готовых проектов, оставив более тонкую настройку на потом.<br /> <br /> == src/ru/ifmo/vizi/%your_project%/%your_project%Visualizer.java ==<br /> <br /> Рекомендуемый способ разработки: взять аналогичный код для поиска максимума и выкинуть из него все лишнее, запустить ant.bat без параметров, убедиться в том, что визуализатор собирается и запускается. Если все прошло успешно, то при запуске вы увидите окошко белого цвета с серой панелькой внизу. На заднем плане будет чернеть консолька, ее, как уже было ранее упомянуто, полезно использовать для debug-output'а.<br /> <br /> На этом этапе полезно запустить ant.bat c параметром docs и почитать сгенерированный javadoc.<br /> <br /> Если вам нужен какой-то компонент, которого нет в vizi, то ищите его в AWT. Если вам нужен какой-то графический примитив, то, возможно, придется написать его самостоятельно. Код некоторых графических примитивов можно посмотреть, например, в SegmentsTree\src\ru\ifmo\vizi\SegmentsTree\widgets.<br /> <br /> Больше я не могу посоветовать ничего конкретного, читайте исходники (лучше не читать исходники поиска максимума, черта с два вы напишете что-то работающее так же) и смотрите, как визуализация устроена там.<br /> <br /> == ссылки ==<br /> * [http://dl.dropbox.com/u/29995484/vizi.zip] - моя папка vizi, со всеми необходимыми частями и всевозможным мусором;<br /> * [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/] - страничка vizi на neerc.ifmo.ru.</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Sementry/%D0%93%D0%B0%D0%B9%D0%B4_%D0%BF%D0%BE_vizi&diff=14772 Участник:Sementry/Гайд по vizi 2011-12-17T20:56:51Z

<p>System29a: /* Для пользователей Linux */</p> <hr /> <div><p align = "right"><i>Дон Хуан добавил, что в его мире подарков не раздают и что всякое знание дается в нем великим трудом.</i></p><br /> <p align = "right"><i>(К. Кастанеда, "Учение Дона Хуана")</i></p><br /> <br /> <br /> <br /> Если вы зашли на эту страницу, то, вероятнее всего, вы не хотите самостоятельно разбираться с устаревшими недокументированными системами. Возможно, у вас нет на это времени, возможно, вам это не интересно, может быть, вам просто лень. Тем не менее, вы готовы написать много-много кода на Java и XML, а потом долго-долго его дебажить. Так или иначе, вы оказались здесь, потому что хотите разобраться с Vizi и написать визуализатор.<br /> <br /> Что же такое Vizi? Это, в некотором роде, фреймворк, который должен облегчить разработку визуализаторов. К сожалению, из-за плохой и незавершенной документации написание приложения с использованием vizi скорее усложняется, а не упрощается. Этот гайд написан для того, чтобы можно было более-менее сориентироваться в процессе разработки и, вопреки всем препятствиям, написать что-то адекватно работающее.<br /> <br /> = Подготовка =<br /> <br /> === Установка ===<br /> Скачиваем [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/vizi-0_4b7.rar последнюю версию Vizi], [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/vizi-0_4b6-bin.rar бинарики предпоследней], [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/classes-1.1.8.jar Java 1.1.8 classes] и [http://mirrors.sonic.net/apache//ant/binaries/apache-ant-1.8.2-bin.zip собранный Apache Ant].<br /> <br /> Распаковываем куда-нибудь последнюю версию Vizi. В папку meta копируем файл "classes-1.1.8.jar". Создаем папку /meta/bin и копируем содержимое папки apache-ant-1.8.2 туда (чтобы получились папки /meta/bin/bin, /meta/bin/lib, etc.). Туда же, куда распаковали последнюю Vizi (т.е. туда, где лежит корневая папка vizi), распаковываем бинарники предпоследней, дополняя недостающие файлы. Заменять новые версии старыми не нужно.<br /> === Для пользователей Windows ===<br /> Добавляем в систему переменную окружения java_home, в ней прописываем путь к jdk. Путь не должен содержать пробелов. Hint: в Windows можно заменить "Program Files" на "Progra~1". А "Program Files [x86]" на "Progra~2", да.<br /> <br /> Теперь надо немного подправить xml-файлы для сборки, конечно, если у вас нет Java 1.1. В /meta/scripts/build/build-compile.xml исправляем debuglevel на "lines,vars,source" в 154 строчке и target на "1.7" или "1.6" (в зависимости от версии jdk). Возможно, нужно исправить что-то еще, но, мне кажется, это все.<br /> <br /> Возвращаемся в корень папки vizi и пробуем запустить ant.bat без параметров. <br /> Если я написал эту часть гайда правильно, а вы правильно выполнили предыдущие действия, то все должно скомпилироваться, вы получите сообщение "BUILD SUCCESSFUL", а в корне появится новая папка deploy, в которой будет лежать визуализатор для поиска максимума.<br /> <br /> === Для пользователей Linux ===<br /> Как вы могли заметить, для сборки проекта в vizi есть файлик ant.bat. Для того, чтобы получить соответствующий файл для сборки понятный Linux, выполните следующие действия:<br /> <br /> В системе должны быть прописаны соответственные переменные окружения. Посмотрите на свой <code>~/.profile</code> и добавьте при необходимости следующие строчки: <br/><br /> <code><br /> JAVA_HOME=/home/jambo/soft/java/jdk1.6.0_24 (то есть путь до jdk) <br/><br /> export JAVA_HOME<br /> <br /> JDK_HOME=$JAVA_HOME <br/><br /> export JDK_HOME<br /> <br /> JRE_HOME=$JAVA_HOME/jre <br/><br /> export JRE_HOME<br /> <br /> ANT_HOME=/home/jambo/soft/apache-ant (то есть путь до apache-ant) <br/><br /> export ANT_HOME<br /> <br /> PATH=$PATH:$JDK_HOME/bin <br/><br /> PATH=$PATH:$JRE_HOME/bin <br/><br /> PATH=$PATH:$ANT_HOME/bin <br/><br /> export PATH <br/><br /> </code><br /> <br /> Для того, чтобы все изменения <code>.profile</code> вступили в силу, нужно перезагрузить машину (или завершить сеанс пользователя и снова зайти)<br /> <br /> Ок, переменные окружения мы прописали.<br /> Теперь в папке с vizi создайте файл <code>ant.sh</code>, дайте ему права на выполнения командой <code>chmod +x ant.sh</code><br /> в файлик поместите следующее содержимое: <br/><br /> <code><br /> #!/bin/sh <br/><br /> <br /> CLASSPATH=`find meta/bin/lib -maxdepth 3 -name '*.jar' -printf '%p:'`$CLASSPATH <br/><br /> CLASSPATH=`find $JDK_HOME -maxdepth 3 -name '*.jar' -printf '%p:'`$CLASSPATH<br/><br /> <br /> #echo $CLASSPATH<br/><br /> <br /> export CLASSPATH<br/><br /> <br /> exec \<br/><br /> java -classpath "$CLASSPATH" \<br/><br /> org.apache.tools.ant.Main $*<br/><br /> </code><br /> Запускаем командой <code>./ant.sh</code>, должно всё получиться. В папке deploy должен валяться визуализатор примера.<br /> <br /> === Дальше ===<br /> Для того, чтобы скомпилировать что-то еще, нужно исправить строчку project в файле build.properties на путь к нужному проекту. Другие визуализаторы можно взять в Term3. Если у вас собирался поиск максимума, а при попытке сделать то же самое с другим визуализатором начинают появляться ошибки о недостающих классах, то можно взять их из архива rt.jar в jdk и добавить в classes-1.1.8.jar. Также можно просто заменить classes-1.1.8.jar на rt.jar, правда, если это кого-то волнует, он весит на порядок больше. <br /> <br /> Ура-ура, теперь мы умеем собирать правильно написанный готовый визуализатор!<br /> <br /> Теперь рекомендуется открыть и прочесть docs/readme.html, если вы вдруг это еще не сделали. Что-то пока будет непонятно, но, по крайней мере, вы узнаете про параметры запуска vizi.<br /> <br /> = Написание визуализатора =<br /> <br /> Теперь можно начать писать свой собственный визуализатор. Предварительно я настоятельно рекомендую прочесть [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/XMLFormat-0_01.pdf спецификацию используемых XML-описаний].<br /> <br /> Структуру проекта можно посмотреть в примерах. Если вы хотите пользоваться какой-нибудь средой разработки, то, вероятно, вам понадобятся исходные коды vizi, которые поставляются вместе с ней и также лежат в папке projects/vizi, ее содержимое нужно скопировать в папку вашего проекта, тогда IDE будет знать, что за классы вы хотите использовать. Компилить проект нужно все тем же запуском ant.bat, дебагать из-под IDE не получится, используйте debug-output.<br /> <br /> == %your_project%.xml ==<br /> <br /> Берем аналогичный файл из уже готового проекта и меняем все параметры на соответствующие нашему проекту, тут проблем возникнуть не должно.<br /> <br /> == %your_project%-algorithm.xml ==<br /> <br /> Пожалуй, самая неприятная часть. Да-да, логику программы мы будем писать на языке разметки XML. Для подробных сведений о спецификации используемого метаязыка читайте указанный двумя абзацами выше файл, а также ознакомьтесь с примерами, здесь я опишу лишь некоторые подводные камни.<br /> <br /> У нас есть конструкции step для присвоений, if-then-else для переменных, while для циклов и call-auto для вызова функции. Можно спокойно объявлять и пользоваться одиночными переменными и массивами примитивных типов, с другими объектами могут возникнуть внезапные осложнения. В описании сказано, что переменные бывают локальными и глобальными. Это не так, переменные бывают только глобальными; главное отличие состоит в том, что значение по умолчанию у глобальных переменных обязательно присутствует, а у локальных {{---}} обязательно отсутствует. Поэтому с рекурсией все грустно, если она необходима, то, видимо, нужно написать стек самостоятельно, либо использовать на свой страх и риск объект stack, который Vizi сама пропишет(но позже там могут возникнуть проблемы с обращением автомата). Можно также схалтурить и написать основную часть кода в визуализаторе, а xml-файл менять как угодно, лишь бы только запланированное разбиение вашего алгоритма на шаги, которые будет видеть пользователь, оставалось прежним.<br /> <br /> Рекомендуемый способ разработки: взять тщательно протестированный и уже сданный код вашего алгоритма на Java, выкинуть из него все сложные классы и языковые конструкции, включая рекурсию и циклы for и свалить все переменные в одну кучу "class Data". Сохраните люмпенизированный таким образом код и убедитесь в том, что он все еще работает так, как надо. Теперь полученный код можно постепенно перерабатывать в xml-файл, окружая все действия нужными тегами. Пока лучше ничего не рисовать, тег draw можно добавить и потом.<br /> <br /> Аргументы в комментарии к шагу задаются как {0}, {1}, etc. Если вы не хотите показывать какой-то шаг пользователю, комментария у него нет, а он все равно показывается, сделайте значение level равным -1.<br /> <br /> Когда все напишете, запустите ant.bat с параметром debug-source. Если где-то есть ошибка, то вам скажут, где именно. Если все написано верно, то версия кода для дебага должна появиться в папке src/ru/ifmo/vizi/%your_project%/%your_project%Debug.java. Сравните ее на похожесть с ранее упрощенным кодом, должно получиться примерно то же самое. Подебажьте сгенерированный код и убедитесь в том, что оно и работает так, как запланировано. Если все хорошо, то можно запустить ant.bat без параметров, сборка не дойдет до конца, но вы сгенерируете код src/ru/ifmo/vizi/%your_project%/%your_project%.java, который написан уже в стиле автоматного программирования и пригодится вам для написания визуализатора в вашей любимой IDE.<br /> <br /> == %your_project%-configuration.xml ==<br /> <br /> Из этого файла будут подгружаться все параметры для вашего визуализатора. Никаких констант, все должно конфигурироваться через XML! Опять же, начать можно с частей уже готовых проектов, оставив более тонкую настройку на потом.<br /> <br /> == src/ru/ifmo/vizi/%your_project%/%your_project%Visualizer.java ==<br /> <br /> Рекомендуемый способ разработки: взять аналогичный код для поиска максимума и выкинуть из него все лишнее, запустить ant.bat без параметров, убедиться в том, что визуализатор собирается и запускается. Если все прошло успешно, то при запуске вы увидите окошко белого цвета с серой панелькой внизу. На заднем плане будет чернеть консолька, ее, как уже было ранее упомянуто, полезно использовать для debug-output'а.<br /> <br /> На этом этапе полезно запустить ant.bat c параметром docs и почитать сгенерированный javadoc.<br /> <br /> Если вам нужен какой-то компонент, которого нет в vizi, то ищите его в AWT. Если вам нужен какой-то графический примитив, то, возможно, придется написать его самостоятельно. Код некоторых графических примитивов можно посмотреть, например, в SegmentsTree\src\ru\ifmo\vizi\SegmentsTree\widgets.<br /> <br /> Больше я не могу посоветовать ничего конкретного, читайте исходники (лучше не читать исходники поиска максимума, черта с два вы напишете что-то работающее так же) и смотрите, как визуализация устроена там.</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A3%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA:Sementry/%D0%93%D0%B0%D0%B9%D0%B4_%D0%BF%D0%BE_vizi&diff=14771 Участник:Sementry/Гайд по vizi 2011-12-17T20:40:29Z

<p>System29a: Добавил часть для линуксоидов</p> <hr /> <div><p align = "right"><i>Дон Хуан добавил, что в его мире подарков не раздают и что всякое знание дается в нем великим трудом.</i></p><br /> <p align = "right"><i>(К. Кастанеда, "Учение Дона Хуана")</i></p><br /> <br /> <br /> <br /> Если вы зашли на эту страницу, то, вероятнее всего, вы не хотите самостоятельно разбираться с устаревшими недокументированными системами. Возможно, у вас нет на это времени, возможно, вам это не интересно, может быть, вам просто лень. Тем не менее, вы готовы написать много-много кода на Java и XML, а потом долго-долго его дебажить. Так или иначе, вы оказались здесь, потому что хотите разобраться с Vizi и написать визуализатор.<br /> <br /> Что же такое Vizi? Это, в некотором роде, фреймворк, который должен облегчить разработку визуализаторов. К сожалению, из-за плохой и незавершенной документации написание приложения с использованием vizi скорее усложняется, а не упрощается. Этот гайд написан для того, чтобы можно было более-менее сориентироваться в процессе разработки и, вопреки всем препятствиям, написать что-то адекватно работающее.<br /> <br /> = Подготовка =<br /> <br /> === Установка ===<br /> Скачиваем [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/vizi-0_4b7.rar последнюю версию Vizi], [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/vizi-0_4b6-bin.rar бинарики предпоследней], [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/classes-1.1.8.jar Java 1.1.8 classes] и [http://mirrors.sonic.net/apache//ant/binaries/apache-ant-1.8.2-bin.zip собранный Apache Ant].<br /> <br /> Распаковываем куда-нибудь последнюю версию Vizi. В папку meta копируем файл "classes-1.1.8.jar". Создаем папку /meta/bin и копируем содержимое папки apache-ant-1.8.2 туда (чтобы получились папки /meta/bin/bin, /meta/bin/lib, etc.). Туда же, куда распаковали последнюю Vizi (т.е. туда, где лежит корневая папка vizi), распаковываем бинарники предпоследней, дополняя недостающие файлы. Заменять новые версии старыми не нужно.<br /> === Для пользователей Windows ===<br /> Добавляем в систему переменную окружения java_home, в ней прописываем путь к jdk. Путь не должен содержать пробелов. Hint: в Windows можно заменить "Program Files" на "Progra~1". А "Program Files [x86]" на "Progra~2", да.<br /> <br /> Теперь надо немного подправить xml-файлы для сборки, конечно, если у вас нет Java 1.1. В /meta/scripts/build/build-compile.xml исправляем debuglevel на "lines,vars,source" в 154 строчке и target на "1.7" или "1.6" (в зависимости от версии jdk). Возможно, нужно исправить что-то еще, но, мне кажется, это все.<br /> <br /> Возвращаемся в корень папки vizi и пробуем запустить ant.bat без параметров. <br /> Если я написал эту часть гайда правильно, а вы правильно выполнили предыдущие действия, то все должно скомпилироваться, вы получите сообщение "BUILD SUCCESSFUL", а в корне появится новая папка deploy, в которой будет лежать визуализатор для поиска максимума.<br /> <br /> === Для пользователей Linux ===<br /> Как вы могли заметить, для сборки проекта в vizi есть файлик ant.bat. Для того, чтобы получить соответствующий файл для сборки понятный Linux, выполните следующие действия:<br /> <br /> В системе должны быть прописаны соответственные переменные окружения. Посмотрите на свой <code>~/.profile</code> и добавьте при необходимости следующие строчки: <br/><br /> <code><br /> JAVA_HOME=/home/jambo/soft/java/jdk1.6.0_24 (то есть путь до jdk) <br/><br /> export JAVA_HOME<br /> <br /> JDK_HOME=$JAVA_HOME <br/><br /> export JDK_HOME<br /> <br /> JRE_HOME=$JAVA_HOME/jre <br/><br /> export JRE_HOME<br /> <br /> ANT_HOME=/home/jambo/soft/apache-ant (то есть путь до apache-ant) <br/><br /> export ANT_HOME<br /> <br /> PATH=$PATH:$JDK_HOME/bin <br/><br /> PATH=$PATH:$JRE_HOME/bin <br/><br /> PATH=$PATH:$ANT_HOME/bin <br/><br /> export PATH <br/><br /> </code><br /> <br /> Для того, чтобы все изменения <code>.profile</code> вступили в силу, нужно перезагрузить машину (или завершить сеанс пользователя и снова зайти)<br /> <br /> Ок, переменные окружения мы прописали.<br /> Теперь в папке с vizi создайте файл <code>ant.sh</code>, дайте ему права на выполнения командой <code>chmod +x ant.sh</code><br /> в файлик поместите следующее содержимое: <br/><br /> <code><br /> #!/bin/sh <br/><br /> <br /> CLASSPATH=`find meta/bin/lib -maxdepth 3 -name '*.jar' -printf '%p:'`$CLASSPATH <br/><br /> CLASSPATH=`find $JDK_HOME -maxdepth 3 -name '*.jar' -printf '%p:'`$CLASSPATH<br/><br /> <br /> #echo $CLASSPATH<br/><br /> <br /> export CLASSPATH<br/><br /> <br /> exec \<br/><br /> java -classpath "$CLASSPATH" \<br/><br /> org.apache.tools.ant.Main<br/><br /> </code><br /> Запускаем командой <code>./ant.sh</code>, должно всё получиться. В папке deploy должен валяться визуализатор примера.<br /> <br /> === Дальше ===<br /> Для того, чтобы скомпилировать что-то еще, нужно исправить строчку project в файле build.properties на путь к нужному проекту. Другие визуализаторы можно взять в Term3. Если у вас собирался поиск максимума, а при попытке сделать то же самое с другим визуализатором начинают появляться ошибки о недостающих классах, то можно взять их из архива rt.jar в jdk и добавить в classes-1.1.8.jar. Также можно просто заменить classes-1.1.8.jar на rt.jar, правда, если это кого-то волнует, он весит на порядок больше. <br /> <br /> Ура-ура, теперь мы умеем собирать правильно написанный готовый визуализатор!<br /> <br /> Теперь рекомендуется открыть и прочесть docs/readme.html, если вы вдруг это еще не сделали. Что-то пока будет непонятно, но, по крайней мере, вы узнаете про параметры запуска vizi.<br /> <br /> = Написание визуализатора =<br /> <br /> Теперь можно начать писать свой собственный визуализатор. Предварительно я настоятельно рекомендую прочесть [http://neerc.ifmo.ru/~kgeorgiy/courses/vizi/XMLFormat-0_01.pdf спецификацию используемых XML-описаний].<br /> <br /> Структуру проекта можно посмотреть в примерах. Если вы хотите пользоваться какой-нибудь средой разработки, то, вероятно, вам понадобятся исходные коды vizi, которые поставляются вместе с ней и также лежат в папке projects/vizi, ее содержимое нужно скопировать в папку вашего проекта, тогда IDE будет знать, что за классы вы хотите использовать. Компилить проект нужно все тем же запуском ant.bat, дебагать из-под IDE не получится, используйте debug-output.<br /> <br /> == %your_project%.xml ==<br /> <br /> Берем аналогичный файл из уже готового проекта и меняем все параметры на соответствующие нашему проекту, тут проблем возникнуть не должно.<br /> <br /> == %your_project%-algorithm.xml ==<br /> <br /> Пожалуй, самая неприятная часть. Да-да, логику программы мы будем писать на языке разметки XML. Для подробных сведений о спецификации используемого метаязыка читайте указанный двумя абзацами выше файл, а также ознакомьтесь с примерами, здесь я опишу лишь некоторые подводные камни.<br /> <br /> У нас есть конструкции step для присвоений, if-then-else для переменных, while для циклов и call-auto для вызова функции. Можно спокойно объявлять и пользоваться одиночными переменными и массивами примитивных типов, с другими объектами могут возникнуть внезапные осложнения. В описании сказано, что переменные бывают локальными и глобальными. Это не так, переменные бывают только глобальными; главное отличие состоит в том, что значение по умолчанию у глобальных переменных обязательно присутствует, а у локальных {{---}} обязательно отсутствует. Поэтому с рекурсией все грустно, если она необходима, то, видимо, нужно написать стек самостоятельно, либо использовать на свой страх и риск объект stack, который Vizi сама пропишет(но позже там могут возникнуть проблемы с обращением автомата). Можно также схалтурить и написать основную часть кода в визуализаторе, а xml-файл менять как угодно, лишь бы только запланированное разбиение вашего алгоритма на шаги, которые будет видеть пользователь, оставалось прежним.<br /> <br /> Рекомендуемый способ разработки: взять тщательно протестированный и уже сданный код вашего алгоритма на Java, выкинуть из него все сложные классы и языковые конструкции, включая рекурсию и циклы for и свалить все переменные в одну кучу "class Data". Сохраните люмпенизированный таким образом код и убедитесь в том, что он все еще работает так, как надо. Теперь полученный код можно постепенно перерабатывать в xml-файл, окружая все действия нужными тегами. Пока лучше ничего не рисовать, тег draw можно добавить и потом.<br /> <br /> Аргументы в комментарии к шагу задаются как {0}, {1}, etc. Если вы не хотите показывать какой-то шаг пользователю, комментария у него нет, а он все равно показывается, сделайте значение level равным -1.<br /> <br /> Когда все напишете, запустите ant.bat с параметром debug-source. Если где-то есть ошибка, то вам скажут, где именно. Если все написано верно, то версия кода для дебага должна появиться в папке src/ru/ifmo/vizi/%your_project%/%your_project%Debug.java. Сравните ее на похожесть с ранее упрощенным кодом, должно получиться примерно то же самое. Подебажьте сгенерированный код и убедитесь в том, что оно и работает так, как запланировано. Если все хорошо, то можно запустить ant.bat без параметров, сборка не дойдет до конца, но вы сгенерируете код src/ru/ifmo/vizi/%your_project%/%your_project%.java, который написан уже в стиле автоматного программирования и пригодится вам для написания визуализатора в вашей любимой IDE.<br /> <br /> == %your_project%-configuration.xml ==<br /> <br /> Из этого файла будут подгружаться все параметры для вашего визуализатора. Никаких констант, все должно конфигурироваться через XML! Опять же, начать можно с частей уже готовых проектов, оставив более тонкую настройку на потом.<br /> <br /> == src/ru/ifmo/vizi/%your_project%/%your_project%Visualizer.java ==<br /> <br /> Рекомендуемый способ разработки: взять аналогичный код для поиска максимума и выкинуть из него все лишнее, запустить ant.bat без параметров, убедиться в том, что визуализатор собирается и запускается. Если все прошло успешно, то при запуске вы увидите окошко белого цвета с серой панелькой внизу. На заднем плане будет чернеть консолька, ее, как уже было ранее упомянуто, полезно использовать для debug-output'а.<br /> <br /> На этом этапе полезно запустить ant.bat c параметром docs и почитать сгенерированный javadoc.<br /> <br /> Если вам нужен какой-то компонент, которого нет в vizi, то ищите его в AWT. Если вам нужен какой-то графический примитив, то, возможно, придется написать его самостоятельно. Код некоторых графических примитивов можно посмотреть, например, в SegmentsTree\src\ru\ifmo\vizi\SegmentsTree\widgets.<br /> <br /> Больше я не могу посоветовать ничего конкретного, читайте исходники (лучше не читать исходники поиска максимума, черта с два вы напишете что-то работающее так же) и смотрите, как визуализация устроена там.</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:Sementry/%D0%93%D0%B0%D0%B9%D0%B4_%D0%BF%D0%BE_vizi&diff=14768 Обсуждение участника:Sementry/Гайд по vizi 2011-12-17T19:56:41Z

<p>System29a: </p> <hr /> <div>Можешь впилить линк на этот гайд на свою страницу? Так будет удобнее, имо. --[[Участник:SkudarnovYaroslav|SkudarnovYaroslav]] 12:57, 13 декабря 2011 (MSK)<br /> : На свою страницу [[Участник:Sementry|здесь]]? Done.<br /> :: Благодарю =)<br /> <br /> [флуд] Мне нравится как выглядела фраза "пользователи альтернативных операционных систем" до правки. -- [[Участник:Dmitriy D.|Dmitriy D.]] 11:37, 14 декабря 2011 (MSK)<br /> <br /> Сделал все по подготовке, перепроверил 3 раза, Система не находит путь...что я делаю не так? Завадский Дмитрий<br /> : Что у тебя с переменной окружения java_home ? Попробуй в консоли написать: "%java_home%\bin\javac". Если тут скажет, что не может найти путь, значит у тебя неправильно установлена переменная %java_home% (а может быть ты указал путь к jre вместо jdk?) [[Участник:Dmitriy D.|Dmitriy D.]] 19:38, 17 декабря 2011 (MSK)<br /> <br /> <br /> [[Участник:System29a|System29a]] 22:34, 17 декабря 2011 (MSK) Ребят, кто-то под никсами собирал? не могу никак совладать с <br /> BUILD FAILED<br /> /home/jambo/tmp/vizi/meta/scripts/build/build-shared.xml:120: taskdef class SchemaValidatorTask cannot be found<br /> <br /> Update: сейчас подкручу гайд, линуксоидам нужен свой запускающий скрипт.</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5_%D1%83%D1%87%D0%B0%D1%81%D1%82%D0%BD%D0%B8%D0%BA%D0%B0:Sementry/%D0%93%D0%B0%D0%B9%D0%B4_%D0%BF%D0%BE_vizi&diff=14767 Обсуждение участника:Sementry/Гайд по vizi 2011-12-17T19:34:51Z

<p>System29a: </p> <hr /> <div>Можешь впилить линк на этот гайд на свою страницу? Так будет удобнее, имо. --[[Участник:SkudarnovYaroslav|SkudarnovYaroslav]] 12:57, 13 декабря 2011 (MSK)<br /> : На свою страницу [[Участник:Sementry|здесь]]? Done.<br /> :: Благодарю =)<br /> <br /> [флуд] Мне нравится как выглядела фраза "пользователи альтернативных операционных систем" до правки. -- [[Участник:Dmitriy D.|Dmitriy D.]] 11:37, 14 декабря 2011 (MSK)<br /> <br /> Сделал все по подготовке, перепроверил 3 раза, Система не находит путь...что я делаю не так? Завадский Дмитрий<br /> : Что у тебя с переменной окружения java_home ? Попробуй в консоли написать: "%java_home%\bin\javac". Если тут скажет, что не может найти путь, значит у тебя неправильно установлена переменная %java_home% (а может быть ты указал путь к jre вместо jdk?) [[Участник:Dmitriy D.|Dmitriy D.]] 19:38, 17 декабря 2011 (MSK)<br /> <br /> <br /> [[Участник:System29a|System29a]] 22:34, 17 декабря 2011 (MSK) Ребят, кто-то под никсами собирал? не могу никак совладать с <br /> BUILD FAILED<br /> /home/jambo/tmp/vizi/meta/scripts/build/build-shared.xml:120: taskdef class SchemaValidatorTask cannot be found</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A5%D1%80%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%D1%87%D0%BB%D0%B5%D0%BD&diff=14760 Хроматический многочлен 2011-12-17T05:29:08Z

<p>System29a: /* Хроматический многочлен полного графа */</p> <hr /> <div>{{Определение<br /> |definition=Пусть дан фиксированный граф <tex>G</tex> и фиксированное число красок <tex>x</tex>. Количество способов правильной <tex>x</tex>-раскраски графа <tex>G</tex> называется '''хроматическим многочленом'''. Обозначают <tex>P(G,x)</tex>.<br /> }}<br /> <br /> == Операция стягивания ребра ==<br /> {{Определение<br /> |definition=Пусть <tex>uv</tex> — ребро графа <tex>G</tex>, не являющееся петлёй. Тогда графом <tex>G/uv</tex> назовём граф, у которого вершины <tex>u</tex> и <tex>v</tex> будут отождествлены, при этом будут отброшены все петли и кратность ребер будет сведена к единице. Граф <tex>G/uv</tex> получен из графа <tex>G</tex> '''стягиванием ребра <tex>uv</tex>'''<br /> }}<br /> <br /> == Хроматический многочлен полного графа ==<br /> <tex>P(K_{n},x)=x(x-1)...(x-n+1)=x^{\underline{n}}</tex>, так как первую вершину полного графа <tex>K_{n}</tex> можно окрасить в любой из <tex>x</tex> цветов, вторую — в любой из оставшихся <tex>x-1</tex> цветов и т. д. Очевидно, что если <tex>x</tex> меньше <tex>n</tex>, то и многочлен равен <tex>0</tex>, так как один из его множителей <tex>0</tex>.<br /><br /> <br /> == Хроматический многочлен пустого графа ==<br /> <tex>P(O_{n},x)=x^{n}</tex>, так как каждую из <tex>n</tex> вершин нулевого графа <tex>O_{n}</tex> можно независимо окрасить в любой из <tex>x</tex> цветов.<br /><br /> Примечание. Нулевой граф <tex>O_{n}</tex> также можно обозначать <tex>\overline{K_{n}}</tex> (дополнительный граф для полного графа <tex>K_{n}</tex>).<br /> <br /> == Хроматический многочлен дерева ==<br /> {{Теорема<br /> |about=<br /> хроматический многочлен дерева<br /> |statement=<br /> Граф <tex>G</tex> с <tex>n</tex> вершинами является деревом тогда и только тогда, когда <tex>P(G,x)=x(x-1)^{n-1}</tex>.<br /> |proof=<br /> Сначала покажем, что хроматический многочлен любого дерева <tex>T</tex> с <tex>n</tex> вершинами есть <tex>x(x-1)^{n-1}</tex>.<br /><br /> Доказательство индукцией по числу <tex>n</tex>. Для <tex>n=1</tex> и <tex>n=2</tex> результат очевиден. Предположим, что <tex>P(T',x)=x(x-1)^{n-2}</tex> для любого дерева <tex>T'</tex> с количеством вершин равным <tex>n-1</tex>. Пусть <tex>uv</tex> — ребро дерева <tex>T</tex>, такое что <tex>v</tex> является висячей вершиной. Хроматический многочлен дерева <tex>T</tex> без ребра <tex>uv</tex> равен <tex>P(T/uv,x)=x(x-1)^{n-2}</tex> по нашему предположению. Вершину <tex>v</tex> можно окрасить <tex>x-1</tex> способом, так как её цвет должен только лишь отличаться от цвета вершины <tex>u</tex>. Итого: <tex>P(T,x)=(x-1)P(T/uv,x)=x(x-1)^{n-1}</tex>.<br /><br /><br /> Обратно, пусть <tex>G</tex> — граф, у которого <tex>P(G,x)=x(x-1)^{n-1}</tex>. Тогда верны два следующих утверждения:<br /><br /> 1. Граф <tex>G</tex> связен, потому что если было бы две компоненты связности (или больше), то <tex>P(G,x)</tex> делился бы на <tex>x^2</tex> без остатка.<br /><br /> 2. В графе <tex>G</tex> количество рёбер равно <tex>n-1</tex>, так как по одной из теорем о коэффициентах хроматического многочлена ([[Хроматический многочлен#Коэффициенты хроматического многочлена|Коэффициенты хроматического многочлена]], теорема 4), количество рёбер в графе соответствует коэффициенту при <tex>x^{n-1}</tex>, взятому со знаком минус. В нашем случае, этот коэффициент удобно искать, используя бином Ньютона:<br /><br /> <tex>{P(G,x)=x(x-1)^{n-1}=x\left(x^{n-1}-{n-1 \choose 1}x^{n-2}+{n-1 \choose 2}x^{n-3}-...+(-1)^{n-1}\right)=x^{n}-(n-1)x^{n-1}+...+(-1)^{n-1}x}</tex><br /><br /> Из этих двух утверждений (связность и <tex>n-1</tex> ребро) следует, что граф <tex>G</tex> является деревом (см. [[Дерево, эквивалентные определения]], утверждения 1 и 3).<br /> }}<br /> <br /> == Рекуррентные формулы для хроматических многочленов ==<br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> - несмежные вершины графа <tex>G</tex>. Если <tex>G_1=G\cup uv</tex>, а <tex>G_2=G/uv</tex> , то <tex>P(G,x)=P(G_1,x)+P(G_2,x)</tex>.<br /> |proof=<br /> Рассмотрим все произвольные раскраски графа <tex>G</tex>. Рассмотрим те из них, при которых вершины <tex>u</tex> и <tex>v</tex> окрашены в разные цвета. Если добавить к графу <tex>G</tex> ребро <tex>uv</tex>, то они не изменятся, то есть останутся правильными. Рассмотрим раскраски, при которых <tex>u</tex> и <tex>v</tex> одного цвета. Все эти раскраски останутся правильными и для графа, полученного из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>.<br /> }}<br /> '''Замечание:'''<br /> Если к некоторому произвольному графу добавлять ребра последовательно, не меняя его вершин, то на каком-то шаге мы получим полный граф. Аналогично мы получим полный граф, если в произвольном графе уменьшим число вершин, путем их отождествления, не меняя числа ребер. <br /> <br /> '''Следствие:'''<br /> Хроматический многочлен любого графа <tex>G</tex> равен сумме хроматических многочленов некоторого числа полных графов, число вершин в которых не больше, чем в графе <tex>G</tex>.<br /> <br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> — смежные вершины графа <tex>G</tex>. Если <tex>G_1=G\backslash uv</tex> и <tex>G_2=G/uv</tex>, то <tex>P(G,x)=P(G_1,x)-P(G_2,x)</tex>.<br /> |proof=<br /> Следует из предыдущей теоремы.<br /> }}<br /> <br /> == Коэффициенты хроматического многочлена ==<br /> {{Теорема<br /> |about=<br /> 1<br /> |statement=<br /> Свободный член хроматического многочлена равен <tex>0</tex>.<br /> |proof=<br /> По определению хроматического многочлена графа <tex>G</tex>, его значение в точке <tex>x</tex> равно количеству способов раскрасить вершины <tex>G</tex> правильным образом в <tex>x</tex> цветов. Количество способов раскрасить граф в <tex>0</tex> цветов равно <tex>0</tex>. То есть <tex>P(G,0)=0</tex>. Из этого следует, что <tex>P(G,x)</tex> кратен <tex>x</tex>, следовательно его свободный член равен <tex>0</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 2<br /> |statement=<br /> Старший коэффициент хроматического многочлена равен <tex>1</tex>.<br /> |proof=<br /> Воспользуемся рекуррентной формулой:<br/><br /> <tex>P(G,x) = P(G_{1},x) + P(G_{2},x)</tex>,<br/><br /> где <tex>G_{1}</tex> — граф, полученный из <tex>G</tex> добавлением отсутствующего в <tex>G</tex> ребра <tex>uv</tex>, а <tex>G_{2}</tex> — граф, полученный из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex> в одну и удалением возникших при этом кратных ребер.<br /> Применяя рекуррентную формулу повторно, хроматический полином можно представить в виде суммы хроматических полиномов полных графов, то есть:<br/><br /> <tex>P(G,x) = {P(K_{n},x) + a_{1}P(K_{n-1},x) + a_{2}P(K_{n-2},x) + \ldots = x^{\underline{n}} + a_{1}x^{\underline{n-1}}+a_{2}x^{\underline{n-2}}+\ldots}</tex><br/><br /> Из этой формулы видно, что хроматический многочлен имеет старший коэффициент, равный <tex>1</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 3<br /> |statement=<br /> Коэффициенты хроматического многочлена составляют знакопеременную последовательность.<br /> |proof=<br /> Индукция по количеству вершин.<br/><br /> '''База индукции:'''<br/><br /> Теорема верна для графа <tex>G</tex> из одной вершины, потому что <tex>P(G,x)=x</tex>.<br/><br /> '''Индукционный переход''' (<tex>n \to n+1)</tex>:<br/><br /> Предположим, что теорема верна для всех графов на <tex>n</tex> вершинах. Рассмотрим графы на <tex>n+1</tex> вершине.<br /> Индукционный переход будем доказывать индукцией по количеству ребер графа <tex>G</tex>. Если <tex>G</tex> не содержит ребер, то есть <tex>G</tex> является <tex>O_{n+1}</tex>, то его хроматический многочлен <tex>P(G,x)=x^{n+1}</tex> обладает доказываемым свойством. Теперь предположим, что для всех <tex>(n+1,m)</tex>-графов теорема верна. Возьмем <tex>(n+1,m+1)</tex>-граф <tex>G_{1}</tex> и его ребро <tex>uv</tex>. Обозначим за <tex>G</tex> граф, полученный из <tex>G_{1}</tex> удалением ребра <tex>uv</tex> (<tex>G=G_{1}-uv</tex>), а за <tex>G_{2}</tex> — граф, полученный из <tex>G_{1}</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>. Тогда из рекуррентной формулы следует:<br/><br /> <tex>P(G_{1},x)=P(G,x)-P(G_{2},x)</tex>.<br /> Так как <tex>G</tex> — <tex>(n+1,m)</tex>-граф, а в <tex>G_{2}</tex> — <tex>n</tex> вершин, то для <tex>G</tex> и <tex>G_{2}</tex> теорема верна:<br/><br /> <tex>{P(G,x)=x^{n+1}-a_{1}x^{n}+a_{2}x^{n-1}-a_{3}x^{n-2}+\ldots}</tex> ,<br/><br /> <tex>{P(G_{2},x)=x^{n}-b_{1}x^{n-1}+b_{2}x^{n-2}+\ldots}</tex> ,<br/><br /> где <tex>a_{1}</tex>, <tex>a_{2}</tex>, …, <tex>a_{n+1}</tex>, <tex>b_{1}</tex>, <tex>b_{2}</tex>, …, <tex>b_{n}</tex> — некоторые неотрицательные целые числа. Из этих равенств получаем:<br/><br /> <tex>P(G_{1},x)=x^{n+1}-(a_{1}+1)x^{n}+(a_{2}+b_{1})x^{n-1}+\ldots</tex>.<br /> Видно, что в этом полученном полиноме коэффициенты составляют знакопеременную последовательность.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 4<br /> |statement=<br /> Второй коэффициент хроматического многочлена равен по модулю количеству ребер графа.<br /> |proof=<br /> Из доказательства '''Теоремы (3)''' видно, что при увеличении количества ребер графа на <tex>1</tex>, второй коэффициент также увеличивается на <tex>1</tex>. Так как для пустого графа второй коэффициент равен <tex>0</tex>, то утверждение верно для любого графа.<br /> }}<br /> <br /> == См. также ==<br /> == Литература ==<br /> 1. Асанов М. О., Баранский В. А., Расин В. В. - Дискретная математика: Графы, матроиды, алгоритмы: Учебное пособие. 2-е изд., испр. и доп. - СПб.: Издательство "Лань", 2010. - 368 с.: ил. - (Учебники для вузов. Специальная литература). '''ISBN 978-5-8114-1068-2'''<br /><br /> 2. Харари Ф. - Теория графов: Изд. 4-е. - М.: Книжный дом "ЛИБРОКОМ", 2009. - 296 с. '''ISBN 978-5-397-00622-4'''<br /> <br /> [[Категория: Алгоритмы и структуры данных]]<br /> [[Категория: Раскраски графов]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A5%D1%80%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%D1%87%D0%BB%D0%B5%D0%BD&diff=14759 Хроматический многочлен 2011-12-17T05:26:57Z

<p>System29a: </p> <hr /> <div>{{Определение<br /> |definition=Пусть дан фиксированный граф <tex>G</tex> и фиксированное число красок <tex>x</tex>. Количество способов правильной <tex>x</tex>-раскраски графа <tex>G</tex> называется '''хроматическим многочленом'''. Обозначают <tex>P(G,x)</tex>.<br /> }}<br /> <br /> == Операция стягивания ребра ==<br /> {{Определение<br /> |definition=Пусть <tex>uv</tex> — ребро графа <tex>G</tex>, не являющееся петлёй. Тогда графом <tex>G/uv</tex> назовём граф, у которого вершины <tex>u</tex> и <tex>v</tex> будут отождествлены, при этом будут отброшены все петли и кратность ребер будет сведена к единице. Граф <tex>G/uv</tex> получен из графа <tex>G</tex> '''стягиванием ребра <tex>uv</tex>'''<br /> }}<br /> <br /> == Хроматический многочлен полного графа ==<br /> <tex>P(K_{n},x)=x(x-1)...(x-n+1)=x^{\underline{n}}</tex>, так как первую вершину полного графа <tex>K_{n}</tex> можно окрасить в любой из <tex>x</tex> цветов, вторую — в любой из оставшихся <tex>x-1</tex> цветов и т. д. Очевидно, что если <tex>x</tex> меньше <tex>n</tex>, то и многочлен равен <tex>0</tex>, так как один из его множителей <tex>0</tex>.<br /><br /> Примечание. В некоторых источниках <tex>x^{\underline{n}}</tex> (<tex>x</tex> в <tex>n</tex>-убывающей) обозначают <tex>x^{(n)}</tex>. Это не очень удобно, так как легко спутать с <tex>n</tex>-ой производной.<br /> <br /> == Хроматический многочлен пустого графа ==<br /> <tex>P(O_{n},x)=x^{n}</tex>, так как каждую из <tex>n</tex> вершин нулевого графа <tex>O_{n}</tex> можно независимо окрасить в любой из <tex>x</tex> цветов.<br /><br /> Примечание. Нулевой граф <tex>O_{n}</tex> также можно обозначать <tex>\overline{K_{n}}</tex> (дополнительный граф для полного графа <tex>K_{n}</tex>).<br /> <br /> == Хроматический многочлен дерева ==<br /> {{Теорема<br /> |about=<br /> хроматический многочлен дерева<br /> |statement=<br /> Граф <tex>G</tex> с <tex>n</tex> вершинами является деревом тогда и только тогда, когда <tex>P(G,x)=x(x-1)^{n-1}</tex>.<br /> |proof=<br /> Сначала покажем, что хроматический многочлен любого дерева <tex>T</tex> с <tex>n</tex> вершинами есть <tex>x(x-1)^{n-1}</tex>.<br /><br /> Доказательство индукцией по числу <tex>n</tex>. Для <tex>n=1</tex> и <tex>n=2</tex> результат очевиден. Предположим, что <tex>P(T',x)=x(x-1)^{n-2}</tex> для любого дерева <tex>T'</tex> с количеством вершин равным <tex>n-1</tex>. Пусть <tex>uv</tex> — ребро дерева <tex>T</tex>, такое что <tex>v</tex> является висячей вершиной. Хроматический многочлен дерева <tex>T</tex> без ребра <tex>uv</tex> равен <tex>P(T/uv,x)=x(x-1)^{n-2}</tex> по нашему предположению. Вершину <tex>v</tex> можно окрасить <tex>x-1</tex> способом, так как её цвет должен только лишь отличаться от цвета вершины <tex>u</tex>. Итого: <tex>P(T,x)=(x-1)P(T/uv,x)=x(x-1)^{n-1}</tex>.<br /><br /><br /> Обратно, пусть <tex>G</tex> — граф, у которого <tex>P(G,x)=x(x-1)^{n-1}</tex>. Тогда верны два следующих утверждения:<br /><br /> 1. Граф <tex>G</tex> связен, потому что если было бы две компоненты связности (или больше), то <tex>P(G,x)</tex> делился бы на <tex>x^2</tex> без остатка.<br /><br /> 2. В графе <tex>G</tex> количество рёбер равно <tex>n-1</tex>, так как по одной из теорем о коэффициентах хроматического многочлена ([[Хроматический многочлен#Коэффициенты хроматического многочлена|Коэффициенты хроматического многочлена]], теорема 4), количество рёбер в графе соответствует коэффициенту при <tex>x^{n-1}</tex>, взятому со знаком минус. В нашем случае, этот коэффициент удобно искать, используя бином Ньютона:<br /><br /> <tex>{P(G,x)=x(x-1)^{n-1}=x\left(x^{n-1}-{n-1 \choose 1}x^{n-2}+{n-1 \choose 2}x^{n-3}-...+(-1)^{n-1}\right)=x^{n}-(n-1)x^{n-1}+...+(-1)^{n-1}x}</tex><br /><br /> Из этих двух утверждений (связность и <tex>n-1</tex> ребро) следует, что граф <tex>G</tex> является деревом (см. [[Дерево, эквивалентные определения]], утверждения 1 и 3).<br /> }}<br /> <br /> == Рекуррентные формулы для хроматических многочленов ==<br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> - несмежные вершины графа <tex>G</tex>. Если <tex>G_1=G\cup uv</tex>, а <tex>G_2=G/uv</tex> , то <tex>P(G,x)=P(G_1,x)+P(G_2,x)</tex>.<br /> |proof=<br /> Рассмотрим все произвольные раскраски графа <tex>G</tex>. Рассмотрим те из них, при которых вершины <tex>u</tex> и <tex>v</tex> окрашены в разные цвета. Если добавить к графу <tex>G</tex> ребро <tex>uv</tex>, то они не изменятся, то есть останутся правильными. Рассмотрим раскраски, при которых <tex>u</tex> и <tex>v</tex> одного цвета. Все эти раскраски останутся правильными и для графа, полученного из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>.<br /> }}<br /> '''Замечание:'''<br /> Если к некоторому произвольному графу добавлять ребра последовательно, не меняя его вершин, то на каком-то шаге мы получим полный граф. Аналогично мы получим полный граф, если в произвольном графе уменьшим число вершин, путем их отождествления, не меняя числа ребер. <br /> <br /> '''Следствие:'''<br /> Хроматический многочлен любого графа <tex>G</tex> равен сумме хроматических многочленов некоторого числа полных графов, число вершин в которых не больше, чем в графе <tex>G</tex>.<br /> <br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> — смежные вершины графа <tex>G</tex>. Если <tex>G_1=G\backslash uv</tex> и <tex>G_2=G/uv</tex>, то <tex>P(G,x)=P(G_1,x)-P(G_2,x)</tex>.<br /> |proof=<br /> Следует из предыдущей теоремы.<br /> }}<br /> <br /> == Коэффициенты хроматического многочлена ==<br /> {{Теорема<br /> |about=<br /> 1<br /> |statement=<br /> Свободный член хроматического многочлена равен <tex>0</tex>.<br /> |proof=<br /> По определению хроматического многочлена графа <tex>G</tex>, его значение в точке <tex>x</tex> равно количеству способов раскрасить вершины <tex>G</tex> правильным образом в <tex>x</tex> цветов. Количество способов раскрасить граф в <tex>0</tex> цветов равно <tex>0</tex>. То есть <tex>P(G,0)=0</tex>. Из этого следует, что <tex>P(G,x)</tex> кратен <tex>x</tex>, следовательно его свободный член равен <tex>0</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 2<br /> |statement=<br /> Старший коэффициент хроматического многочлена равен <tex>1</tex>.<br /> |proof=<br /> Воспользуемся рекуррентной формулой:<br/><br /> <tex>P(G,x) = P(G_{1},x) + P(G_{2},x)</tex>,<br/><br /> где <tex>G_{1}</tex> — граф, полученный из <tex>G</tex> добавлением отсутствующего в <tex>G</tex> ребра <tex>uv</tex>, а <tex>G_{2}</tex> — граф, полученный из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex> в одну и удалением возникших при этом кратных ребер.<br /> Применяя рекуррентную формулу повторно, хроматический полином можно представить в виде суммы хроматических полиномов полных графов, то есть:<br/><br /> <tex>P(G,x) = {P(K_{n},x) + a_{1}P(K_{n-1},x) + a_{2}P(K_{n-2},x) + \ldots = x^{\underline{n}} + a_{1}x^{\underline{n-1}}+a_{2}x^{\underline{n-2}}+\ldots}</tex><br/><br /> Из этой формулы видно, что хроматический многочлен имеет старший коэффициент, равный <tex>1</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 3<br /> |statement=<br /> Коэффициенты хроматического многочлена составляют знакопеременную последовательность.<br /> |proof=<br /> Индукция по количеству вершин.<br/><br /> '''База индукции:'''<br/><br /> Теорема верна для графа <tex>G</tex> из одной вершины, потому что <tex>P(G,x)=x</tex>.<br/><br /> '''Индукционный переход''' (<tex>n \to n+1)</tex>:<br/><br /> Предположим, что теорема верна для всех графов на <tex>n</tex> вершинах. Рассмотрим графы на <tex>n+1</tex> вершине.<br /> Индукционный переход будем доказывать индукцией по количеству ребер графа <tex>G</tex>. Если <tex>G</tex> не содержит ребер, то есть <tex>G</tex> является <tex>O_{n+1}</tex>, то его хроматический многочлен <tex>P(G,x)=x^{n+1}</tex> обладает доказываемым свойством. Теперь предположим, что для всех <tex>(n+1,m)</tex>-графов теорема верна. Возьмем <tex>(n+1,m+1)</tex>-граф <tex>G_{1}</tex> и его ребро <tex>uv</tex>. Обозначим за <tex>G</tex> граф, полученный из <tex>G_{1}</tex> удалением ребра <tex>uv</tex> (<tex>G=G_{1}-uv</tex>), а за <tex>G_{2}</tex> — граф, полученный из <tex>G_{1}</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>. Тогда из рекуррентной формулы следует:<br/><br /> <tex>P(G_{1},x)=P(G,x)-P(G_{2},x)</tex>.<br /> Так как <tex>G</tex> — <tex>(n+1,m)</tex>-граф, а в <tex>G_{2}</tex> — <tex>n</tex> вершин, то для <tex>G</tex> и <tex>G_{2}</tex> теорема верна:<br/><br /> <tex>{P(G,x)=x^{n+1}-a_{1}x^{n}+a_{2}x^{n-1}-a_{3}x^{n-2}+\ldots}</tex> ,<br/><br /> <tex>{P(G_{2},x)=x^{n}-b_{1}x^{n-1}+b_{2}x^{n-2}+\ldots}</tex> ,<br/><br /> где <tex>a_{1}</tex>, <tex>a_{2}</tex>, …, <tex>a_{n+1}</tex>, <tex>b_{1}</tex>, <tex>b_{2}</tex>, …, <tex>b_{n}</tex> — некоторые неотрицательные целые числа. Из этих равенств получаем:<br/><br /> <tex>P(G_{1},x)=x^{n+1}-(a_{1}+1)x^{n}+(a_{2}+b_{1})x^{n-1}+\ldots</tex>.<br /> Видно, что в этом полученном полиноме коэффициенты составляют знакопеременную последовательность.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 4<br /> |statement=<br /> Второй коэффициент хроматического многочлена равен по модулю количеству ребер графа.<br /> |proof=<br /> Из доказательства '''Теоремы (3)''' видно, что при увеличении количества ребер графа на <tex>1</tex>, второй коэффициент также увеличивается на <tex>1</tex>. Так как для пустого графа второй коэффициент равен <tex>0</tex>, то утверждение верно для любого графа.<br /> }}<br /> <br /> == См. также ==<br /> == Литература ==<br /> 1. Асанов М. О., Баранский В. А., Расин В. В. - Дискретная математика: Графы, матроиды, алгоритмы: Учебное пособие. 2-е изд., испр. и доп. - СПб.: Издательство "Лань", 2010. - 368 с.: ил. - (Учебники для вузов. Специальная литература). '''ISBN 978-5-8114-1068-2'''<br /><br /> 2. Харари Ф. - Теория графов: Изд. 4-е. - М.: Книжный дом "ЛИБРОКОМ", 2009. - 296 с. '''ISBN 978-5-397-00622-4'''<br /> <br /> [[Категория: Алгоритмы и структуры данных]]<br /> [[Категория: Раскраски графов]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%A3%D0%B8%D1%82%D0%BD%D0%B8&diff=14758 Формула Уитни 2011-12-17T04:52:36Z

<p>System29a: </p> <hr /> <div>{{Теорема<br /> |about=<br /> Уитни<br /> |statement=<br /> Пусть <tex>G</tex> - обыкновенный <tex>(n, m)</tex> - граф. Тогда коэффициент при <tex>x^i</tex>, где <tex>1\le i\le n</tex> в хроматическом многочлене <tex>P(G, x)</tex> равен <tex>\sum \limits_{j=0}^{m}{(-1)^jN(i, j)}</tex>, где <tex>N(i, j)</tex> - число остовных подграфов графа <tex>G</tex>, имеющих <tex>i</tex> компонент связности и <tex>j</tex> рёбер, т.е. <tex>P(G, x) = \sum \limits_{i=1}^{n}{(\sum \limits_{j=0}^{m}{(-1)^jN(i, j))x^i}}.</tex><br /> |proof=<br /> <br>Пусть <tex>K</tex> — некоторый набор из <tex>x</tex> красок. Отображение <tex>\phi</tex> из <tex>VG</tex> в <tex>K</tex>, не являющееся раскраской графа <tex>G</tex>, будем называть его ''несобственной'' раскраской. Всего собственных и несобственных <tex>x</tex> — раскрасок графа <tex>G</tex> — <tex>x^n</tex>.<br>Возьмём некоторую собственную или несобственную раскраску графа <tex>G</tex>. Удалим из графа каждое ребро, концы которого раскрашены в разный цвет. Получим остовный подграф <tex>H</tex>, в котором каждое ребро соединяет вершины одинакового цвета. Исходную собственную или несобственную раскраску будем называть ''строго несобственной'' раскраской остовного подграфа <tex>H</tex>. Каждой компоненте связности графа <tex>H</tex> соответствует точно один цвет - цвет её вершин. Если остовный подграф <tex>H</tex> имеет <tex>i</tex> компонент связности, то есть <tex>x^i</tex> различных строго несобственных раскрасок, отвечающих остовному подграфу <tex>H</tex>.<br>Каждая собственная или несобственная раскраска графа <tex>G</tex> является строго несобственной раскраской его остовного подграфа. Собственным раскраскам графа <tex>G</tex> отвечает нулевой остовный подграф.<br>Пусть <tex>N(i, j)</tex> — число остовных подграфов графа <tex>G</tex>, имеющих <tex>i</tex> компонент связности и <tex>j</tex> рёбер.<br><br /> Из общего числа <tex>x^n</tex> собственных и не собственных раскрасок вычтем число строго несобственных раскрасок остовных подграфов, имеющих ровно одно ребро. Если мы вычтем сумму <tex> \sum \limits_{i}{N(i, 1)x^i} </tex>, то мы вычтем помимо указанного числа ещё и избыточную величину. Действительно, допустим <tex>e_1 = u_1v_1</tex> и <tex>e_2 = u_2v_2</tex> — два различных ребра графа <tex>G</tex>. Тогда в число строго несобственных раскрасок остовного подграфа, содержащего точно одно ребро <tex>e_1</tex>, попадут и те, у которых вершины <tex>e_1</tex> и <tex>e_2</tex>, а это в свою очередь строго несобственные раскраски остовного подграфа, содержащего ровно два ребра <tex>e_1</tex> и <tex>e_2</tex>. При этом их число мы вычтем дважды — для <tex>e_1</tex> и <tex>e_2</tex>. Аналогично, число строго несобственных раскрасок остовных подграфов, содержащих точно три, четыре и более ребер будет вычтено соответствующее число раз.<br/><br /> Добавим сумму <tex>\sum \limits_{i}{N(i, 2)x^i}</tex>, компенсируя при этом двукратное вычитание, но при этом возникнет необходимость компенсации излишне добавленных чисел строго несобственных раскрасок для остовных подграфов с тремя, четырьмя и более ребрами. <br/> <br /> Итого, по принципу включения-исключения получаем, что число собственных раскрасок графа <tex>G</tex> равно <tex>x^n - \sum \limits_{i}{N(i, 1)x^i} + \sum \limits_{i}{N(i, 2)x^i} - \sum \limits_{i}{N(i, 3)x^i} + ...</tex><br>Так как <tex>N(n, 0) = 1</tex>, то <tex>P(G, x) = \sum \limits_{j=0}^{m}{\sum \limits_{i=1}^{n}{(-1)^jN(i, j)x^i}} = \sum \limits_{i=1}^{n}{\sum \limits_{j=0}^{m}{(-1)^jN(i, j)x^i}}</tex>.<br /> }}<br /> <br /> ==Литература==<br /> * Асанов М,, Баранский В., Расин В. - Дискретная математика - Графы, матроиды, алгоритмы<br /> <br /> [[Категория: Алгоритмы и структуры данных]]<br /> [[Категория: Раскраски графов ]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A5%D1%80%D0%BE%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%BD%D0%BE%D0%B3%D0%BE%D1%87%D0%BB%D0%B5%D0%BD&diff=14711 Хроматический многочлен 2011-12-17T00:36:31Z

<p>System29a: </p> <hr /> <div>{{Определение<br /> |definition=Пусть дан фиксированный граф <tex>G</tex> и фиксированное число красок <tex>x</tex>. Количество способов правильной <tex>x</tex>-раскраски графа <tex>G</tex> называется '''хроматическим многочленом'''. Обозначают <tex>P(G,x)</tex>.<br /> }}<br /> <br /> == Хроматический многочлен полного графа ==<br /> <tex>P(K_{n},x)=x(x-1)...(x-n+1)=x^{\underline{n}}</tex>, так как первую вершину полного графа <tex>K_{n}</tex> можно окрасить в любой из <tex>x</tex> цветов, вторую — в любой из оставшихся <tex>x-1</tex> цветов и т. д. Очевидно, что если <tex>x</tex> меньше <tex>n</tex>, то и многочлен равен <tex>0</tex>, так как один из его множителей <tex>0</tex>.<br /><br /> Примечание. В некоторых источниках <tex>x^{\underline{n}}</tex> (<tex>x</tex> в <tex>n</tex>-убывающей) обозначают <tex>x^{(n)}</tex>. Это не очень удобно, так как легко спутать с <tex>n</tex>-ой производной.<br /> <br /> == Хроматический многочлен пустого графа ==<br /> <tex>P(O_{n},x)=x^{n}</tex>, так как каждую из <tex>n</tex> вершин нулевого графа <tex>O_{n}</tex> можно независимо окрасить в любой из <tex>x</tex> цветов.<br /><br /> Примечание. Нулевой граф <tex>O_{n}</tex> также можно обозначать <tex>\overline{K_{n}}</tex> (дополнительный граф для полного графа <tex>K_{n}</tex>).<br /> <br /> == Хроматический многочлен дерева ==<br /> {{Теорема<br /> |about=<br /> хроматический многочлен дерева<br /> |statement=<br /> Граф <tex>G</tex> с <tex>n</tex> вершинами является деревом тогда и только тогда, когда <tex>P(G,x)=x(x-1)^{n-1}</tex>.<br /> |proof=<br /> Сначала покажем, что хроматический многочлен любого дерева <tex>T</tex> с <tex>n</tex> вершинами есть <tex>x(x-1)^{n-1}</tex>.<br /><br /> Доказательство индукцией по числу <tex>n</tex>. Для <tex>n=1</tex> и <tex>n=2</tex> результат очевиден. Предположим, что <tex>P(T',x)=x(x-1)^{n-2}</tex> для любого дерева <tex>T'</tex> с количеством вершин равным <tex>n-1</tex>. Пусть <tex>uv</tex> — ребро дерева <tex>T</tex>, такое что <tex>v</tex> является висячей вершиной. Хроматический многочлен дерева <tex>T</tex> без ребра <tex>uv</tex> равен <tex>P(T/uv,x)=x(x-1)^{n-2}</tex> по нашему предположению. Вершину <tex>v</tex> можно окрасить <tex>x-1</tex> способом, так как её цвет должен только лишь отличаться от цвета вершины <tex>u</tex>. Итого: <tex>P(T,x)=(x-1)P(T/uv,x)=x(x-1)^{n-1}</tex>.<br /><br /><br /> Обратно, пусть <tex>G</tex> — граф, у которого <tex>P(G,x)=x(x-1)^{n-1}</tex>. Тогда верны два следующих утверждения:<br /><br /> 1. Граф <tex>G</tex> связен, потому что если было бы две компоненты связности (или больше), то <tex>P(G,x)</tex> делился бы на <tex>x^2</tex> без остатка.<br /><br /> 2. В графе <tex>G</tex> количество рёбер равно <tex>n-1</tex>, так как по одной из теорем о коэффициентах хроматического многочлена ([[Хроматический многочлен#Коэффициенты хроматического многочлена|Коэффициенты хроматического многочлена]], теорема 4), количество рёбер в графе соответствует коэффициенту при <tex>x^{n-1}</tex>, взятому со знаком минус. В нашем случае, этот коэффициент удобно искать, используя бином Ньютона:<br /><br /> <tex>{P(G,x)=x(x-1)^{n-1}=x\left(x^{n-1}-{n-1 \choose 1}x^{n-2}+{n-1 \choose 2}x^{n-3}-...+(-1)^{n-1}\right)=x^{n}-(n-1)x^{n-1}+...+(-1)^{n-1}x}</tex><br /><br /> Из этих двух утверждений (связность и <tex>n-1</tex> ребро) следует, что граф <tex>G</tex> является деревом (см. [[Дерево, эквивалентные определения]], утверждения 1 и 3).<br /> }}<br /> <br /> == Рекуррентные формулы для хроматических многочленов ==<br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> - несмежные вершины графа <tex>G</tex>. Если <tex>G_1=G\cup uv</tex>, а <tex>G_2=G/uv</tex> , то <tex>P(G,x)=P(G_1,x)+P(G_2,x)</tex>.<br /> |proof=<br /> Рассмотрим все произвольные раскраски графа <tex>G</tex>. Рассмотрим те из них, при которых вершины <tex>u</tex> и <tex>v</tex> окрашены в разные цвета. Если добавить к графу <tex>G</tex> ребро <tex>uv</tex>, то они не изменятся, то есть останутся правильными. Рассмотрим раскраски, при которых <tex>u</tex> и <tex>v</tex> одного цвета. Все эти раскраски останутся правильными и для графа, полученного из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>.<br /> }}<br /> '''Замечание:'''<br /> Если к некоторому произвольному графу добавлять ребра последовательно, не меняя его вершин, то на каком-то шаге мы получим полный граф. Аналогично мы получим полный граф, если в произвольном графе уменьшим число вершин, путем их отождествления, не меняя числа ребер. <br /> <br /> '''Следствие:'''<br /> Хроматический многочлен любого графа <tex>G</tex> равен сумме хроматических многочленов некоторого числа полных графов, число вершин в которых не больше, чем в графе <tex>G</tex>.<br /> <br /> {{Теорема<br /> |statement=<br /> Пусть <tex>u</tex> и <tex>v</tex> — смежные вершины графа <tex>G</tex>. Если <tex>G_1=G\backslash uv</tex> и <tex>G_2=G/uv</tex>, то <tex>P(G,x)=P(G_1,x)-P(G_2,x)</tex>.<br /> |proof=<br /> Следует из предыдущей теоремы.<br /> }}<br /> <br /> == Коэффициенты хроматического многочлена ==<br /> {{Теорема<br /> |about=<br /> 1<br /> |statement=<br /> Свободный член хроматического многочлена равен <tex>0</tex>.<br /> |proof=<br /> По определению хроматического многочлена графа <tex>G</tex>, его значение в точке <tex>x</tex> равно количеству способов раскрасить вершины <tex>G</tex> правильным образом в <tex>x</tex> цветов. Количество способов раскрасить граф в <tex>0</tex> цветов равно <tex>0</tex>. То есть <tex>P(G,0)=0</tex>. Из этого следует, что <tex>P(G,x)</tex> кратен <tex>x</tex>, следовательно его свободный член равен <tex>0</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 2<br /> |statement=<br /> Старший коэффициент хроматического многочлена равен <tex>1</tex>.<br /> |proof=<br /> Воспользуемся рекуррентной формулой:<br/><br /> <tex>P(G,x) = P(G_{1},x) + P(G_{2},x)</tex>,<br/><br /> где <tex>G_{1}</tex> — граф, полученный из <tex>G</tex> добавлением отсутствующего в <tex>G</tex> ребра <tex>uv</tex>, а <tex>G_{2}</tex> — граф, полученный из <tex>G</tex> слиянием вершин <tex>u</tex> и <tex>v</tex> в одну и удалением возникших при этом кратных ребер.<br /> Применяя рекуррентную формулу повторно, хроматический полином можно представить в виде суммы хроматических полиномов полных графов, то есть:<br/><br /> <tex>P(G,x) = {P(K_{n},x) + a_{1}P(K_{n-1},x) + a_{2}P(K_{n-2},x) + \ldots = x^{\underline{n}} + a_{1}x^{\underline{n-1}}+a_{2}x^{\underline{n-2}}+\ldots}</tex><br/><br /> Из этой формулы видно, что хроматический многочлен имеет старший коэффициент, равный <tex>1</tex>.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 3<br /> |statement=<br /> Коэффициенты хроматического многочлена составляют знакопеременную последовательность.<br /> |proof=<br /> Индукция по количеству вершин.<br/><br /> '''База индукции:'''<br/><br /> Теорема верна для графа <tex>G</tex> из одной вершины, потому что <tex>P(G,x)=x</tex>.<br/><br /> '''Индукционный переход''' (<tex>n \to n+1)</tex>:<br/><br /> Предположим, что теорема верна для всех графов на <tex>n</tex> вершинах. Рассмотрим графы на <tex>n+1</tex> вершине.<br /> Индукционный переход будем доказывать индукцией по количеству ребер графа <tex>G</tex>. Если <tex>G</tex> не содержит ребер, то есть <tex>G</tex> является <tex>O_{n+1}</tex>, то его хроматический многочлен <tex>P(G,x)=x^{n+1}</tex> обладает доказываемым свойством. Теперь предположим, что для всех <tex>(n+1,m)</tex>-графов теорема верна. Возьмем <tex>(n+1,m+1)</tex>-граф <tex>G_{1}</tex> и его ребро <tex>uv</tex>. Обозначим за <tex>G</tex> граф, полученный из <tex>G_{1}</tex> удалением ребра <tex>uv</tex> (<tex>G=G_{1}-uv</tex>), а за <tex>G_{2}</tex> — граф, полученный из <tex>G_{1}</tex> слиянием вершин <tex>u</tex> и <tex>v</tex>. Тогда из рекуррентной формулы следует:<br/><br /> <tex>P(G_{1},x)=P(G,x)-P(G_{2},x)</tex>.<br /> Так как <tex>G</tex> — <tex>(n+1,m)</tex>-граф, а в <tex>G_{2}</tex> — <tex>n</tex> вершин, то для <tex>G</tex> и <tex>G_{2}</tex> теорема верна:<br/><br /> <tex>{P(G,x)=x^{n+1}-a_{1}x^{n}+a_{2}x^{n-1}-a_{3}x^{n-2}+\ldots}</tex> ,<br/><br /> <tex>{P(G_{2},x)=x^{n}-b_{1}x^{n-1}+b_{2}x^{n-2}+\ldots}</tex> ,<br/><br /> где <tex>a_{1}</tex>, <tex>a_{2}</tex>, …, <tex>a_{n+1}</tex>, <tex>b_{1}</tex>, <tex>b_{2}</tex>, …, <tex>b_{n}</tex> — некоторые неотрицательные целые числа. Из этих равенств получаем:<br/><br /> <tex>P(G_{1},x)=x^{n+1}-(a_{1}+1)x^{n}+(a_{2}+b_{1})x^{n-1}+\ldots</tex>.<br /> Видно, что в этом полученном полиноме коэффициенты составляют знакопеременную последовательность.<br /> }}<br /> <br /> {{Теорема<br /> |about=<br /> 4<br /> |statement=<br /> Второй коэффициент хроматического многочлена равен по модулю количеству ребер графа.<br /> |proof=<br /> Из доказательства '''Теоремы (3)''' видно, что при увеличении количества ребер графа на <tex>1</tex>, второй коэффициент также увеличивается на <tex>1</tex>. Так как для пустого графа второй коэффициент равен <tex>0</tex>, то утверждение верно для любого графа.<br /> }}<br /> <br /> == См. также ==<br /> == Литература ==<br /> 1. Асанов М. О., Баранский В. А., Расин В. В. - Дискретная математика: Графы, матроиды, алгоритмы: Учебное пособие. 2-е изд., испр. и доп. - СПб.: Издательство "Лань", 2010. - 368 с.: ил. - (Учебники для вузов. Специальная литература). '''ISBN 978-5-8114-1068-2'''<br /><br /> 2. Харари Ф. - Теория графов: Изд. 4-е. - М.: Книжный дом "ЛИБРОКОМ", 2009. - 296 с. '''ISBN 978-5-397-00622-4'''<br /> <br /> [[Категория: Алгоритмы и структуры данных]]<br /> [[Категория: Раскраски графов]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5:%D0%AD%D0%B9%D0%BB%D0%B5%D1%80%D0%BE%D0%B2%D0%BE%D1%81%D1%82%D1%8C_%D0%B3%D1%80%D0%B0%D1%84%D0%BE%D0%B2&diff=13746 Обсуждение:Эйлеровость графов 2011-12-01T03:39:12Z

<p>System29a: Новая страница: «~~~~ Вы уверены, что сложность алгоритма нахождения пути <tex>O(VE)</tex>?»</p> <hr /> <div>[[Участник:System29a|System29a]] 06:39, 1 декабря 2011 (MSK)<br /> Вы уверены, что сложность алгоритма нахождения пути <tex>O(VE)</tex>?</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B8%D0%B5_%D1%81%D0%B5%D1%82%D0%B8_%D0%B4%D0%BB%D1%8F_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D1%8B%D1%85_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BE%D0%BA&diff=9924 Сортирующие сети для квадратичных сортировок 2011-06-14T19:44:38Z

<p>System29a: </p> <hr /> <div><br /> Рассмотрим модели сортирующих сетей для квадратичных сортировок. <br /> <br /> == Сортирующие сети с последовательной сортировкой ==<br /> <br /> На один слой будем устанавливать только один компаратор. Все последующие сети получаются простым моделированием соответствующих сортировок.<br /> <br /> === [[Сортировка пузырьком]] ===<br /> <br /> [[Файл:Bubblesort.png]]<br /> <br /> === [[Сортировка вставками]] ===<br /> <br /> [[Файл:Insertsort.png]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesort.png‎]]<br /> <br /> == Сортирующие сети с параллельной сортировкой ==<br /> <br /> На один слой будем устанавливать несколько компараторов.<br /> <br /> === Сортировка пузырьком и вставками ===<br /> <br /> Интересно два факта:<br /> <br /> * Если сжать последовательные сортирующие сети пузырьком и вставками, то результат будет одним и тем же.<br /> * В результирующей сети будет <tex>(2n - 3)</tex> слоев.<br /> <br /> [[Файл:Parralelsort.png‎]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesortparralel.png‎]]<br /> <br /> == Источники ==<br /> * Дональд Э. Кнут. Искусство программирования. Том 3. Сортировка и Поиск.</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B8%D0%B5_%D1%81%D0%B5%D1%82%D0%B8_%D0%B4%D0%BB%D1%8F_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D1%8B%D1%85_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BE%D0%BA&diff=9923 Сортирующие сети для квадратичных сортировок 2011-06-14T19:43:34Z

<p>System29a: /* Сортировка вставками */</p> <hr /> <div>{{В разработке}}<br /> <br /> Рассмотрим модели сортирующих сетей для квадратичных сортировок. <br /> <br /> == Сортирующие сети с последовательной сортировкой ==<br /> <br /> На один слой будем устанавливать только один компаратор. Все последующие сети получаются простым моделированием соответствующих сортировок.<br /> <br /> === [[Сортировка пузырьком]] ===<br /> <br /> [[Файл:Bubblesort.png]]<br /> <br /> === [[Сортировка вставками]] ===<br /> <br /> [[Файл:Insertsort.png]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesort.png‎]]<br /> <br /> == Сортирующие сети с параллельной сортировкой ==<br /> <br /> На один слой будем устанавливать несколько компараторов.<br /> <br /> === Сортировка пузырьком и вставками ===<br /> <br /> Интересно два факта:<br /> <br /> * Если сжать последовательные сортирующие сети пузырьком и вставками, то результат будет одним и тем же.<br /> * В результирующей сети будет <tex>(2n - 3)</tex> слоев.<br /> <br /> [[Файл:Parralelsort.png‎]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesortparralel.png‎]]<br /> <br /> == Источники ==<br /> * Дональд Э. Кнут. Искусство программирования. Том 3. Сортировка и Поиск.</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B8%D0%B5_%D1%81%D0%B5%D1%82%D0%B8_%D0%B4%D0%BB%D1%8F_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D1%8B%D1%85_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BE%D0%BA&diff=9922 Сортирующие сети для квадратичных сортировок 2011-06-14T19:42:24Z

<p>System29a: /* Сортировка пузырьком */</p> <hr /> <div>{{В разработке}}<br /> <br /> Рассмотрим модели сортирующих сетей для квадратичных сортировок. <br /> <br /> == Сортирующие сети с последовательной сортировкой ==<br /> <br /> На один слой будем устанавливать только один компаратор. Все последующие сети получаются простым моделированием соответствующих сортировок.<br /> <br /> === [[Сортировка пузырьком]] ===<br /> <br /> [[Файл:Bubblesort.png]]<br /> <br /> === Сортировка вставками ===<br /> <br /> [[Файл:Insertsort.png]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesort.png‎]]<br /> <br /> == Сортирующие сети с параллельной сортировкой ==<br /> <br /> На один слой будем устанавливать несколько компараторов.<br /> <br /> === Сортировка пузырьком и вставками ===<br /> <br /> Интересно два факта:<br /> <br /> * Если сжать последовательные сортирующие сети пузырьком и вставками, то результат будет одним и тем же.<br /> * В результирующей сети будет <tex>(2n - 3)</tex> слоев.<br /> <br /> [[Файл:Parralelsort.png‎]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesortparralel.png‎]]<br /> <br /> == Источники ==<br /> * Дональд Э. Кнут. Искусство программирования. Том 3. Сортировка и Поиск.</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B8%D0%B5_%D1%81%D0%B5%D1%82%D0%B8_%D0%B4%D0%BB%D1%8F_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D1%8B%D1%85_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BE%D0%BA&diff=9921 Сортирующие сети для квадратичных сортировок 2011-06-14T19:41:05Z

<p>System29a: </p> <hr /> <div>{{В разработке}}<br /> <br /> Рассмотрим модели сортирующих сетей для квадратичных сортировок. <br /> <br /> == Сортирующие сети с последовательной сортировкой ==<br /> <br /> На один слой будем устанавливать только один компаратор. Все последующие сети получаются простым моделированием соответствующих сортировок.<br /> <br /> === Сортировка пузырьком ===<br /> <br /> [[Файл:Bubblesort.png]]<br /> <br /> === Сортировка вставками ===<br /> <br /> [[Файл:Insertsort.png]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesort.png‎]]<br /> <br /> == Сортирующие сети с параллельной сортировкой ==<br /> <br /> На один слой будем устанавливать несколько компараторов.<br /> <br /> === Сортировка пузырьком и вставками ===<br /> <br /> Интересно два факта:<br /> <br /> * Если сжать последовательные сортирующие сети пузырьком и вставками, то результат будет одним и тем же.<br /> * В результирующей сети будет <tex>(2n - 3)</tex> слоев.<br /> <br /> [[Файл:Parralelsort.png‎]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesortparralel.png‎]]<br /> <br /> == Источники ==<br /> * Дональд Э. Кнут. Искусство программирования. Том 3. Сортировка и Поиск.</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%94%D0%B8%D1%81%D0%BA%D1%80%D0%B5%D1%82%D0%BD%D0%B0%D1%8F_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0_%D0%B8_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D1%8B&diff=9910 Дискретная математика и алгоритмы 2011-06-14T17:44:34Z

<p>System29a: /* Сортирующие сети */</p> <hr /> <div>[[Категория:Дискретная математика и алгоритмы]]<br /> == Отношения ==<br /> *[[Определение отношения]]<br /> *[[Степень отношений]]<br /> *[[Рефлексивное отношение|Рефлексивное отношение. Антирефлексивное отношение.]]<br /> *[[Симметричное отношение]]<br /> *[[Антисимметричное отношение]]<br /> *[[Композиция отношений|Композиция отношений. Обратное отношение]]<br /> *[[Транзитивное отношение]]<br /> *[[Транзитивное замыкание|Транзитивное замыкание отношения]]<br /> *[[Алгоритм Флойда — Уоршелла|Алгоритм Флойда-Уоршалла построения транзитивного замыкания отношения]]<br /> <br /> == Булевы функции ==<br /> *[[Определение булевой функции]]<br /> *[[Примеры булевых функций|Примеры булевых функций: все функции от нуля, одной и двух переменных]]<br /> *[[Подстановка одной функции в другую, отождествление переменных]]<br /> *[[Представление функции формулой, полные системы функций]] <br /> *[[СДНФ]]<br /> *[[СКНФ]]<br /> *[[Полином Жегалкина]]<br /> *[[Теорема Поста о полной системе функций]]<br /> *[[Сокращенная и минимальная ДНФ]]<br /> *[[Минимизация ДНФ с помощью покрытий гиперкуба и карт Карно]]<br /> *[[Специальные формы КНФ|Специальные формы КНФ: КНФ в форме Хорна и КНФ в форме Крома]]<br /> *[[Преобразование Мёбиуса для получения коэффициентов полинома Жегалкина]]<br /> *[[Представление функции класса DM с помощью медианы]]<br /> *[[Пороговая функция]]<br /> <br /> == Схемы из функциональных элементов ==<br /> *[[Реализация булевой функции схемой из функциональных элементов]]<br /> *[[Изменение размера оптимальной схемы при переходе к другому базису]]<br /> *[[Cумматор]]<br /> *[[Каскадный сумматор]]<br /> *[[Двоичный каскадный сумматор]]<br /> *[[Матричный умножитель]]<br /> *[[Дерево Уоллеса]]<br /> <br /> == Представление информации ==<br /> *[[Кодирование информации]]<br /> *[[Представление целых чисел: прямой код, код со сдвигом, дополнительный код]]<br /> *[[Представление вещественных чисел]]<br /> *[[Представление символов, таблицы кодировок]]<br /> *[[Алгоритм Хаффмана]]<br /> <br /> == Алгоритмы сжатия ==<br /> *[[Алгоритм LZW]]<br /> *[[Алгоритмы LZ77 и LZ78]]<br /> *[[Преобразование Барроуза-Уиллера]]<br /> *[[Обратное преобразование Барроуза-Уиллера]]<br /> *[[Преобразование MTF]]<br /> *[[Расстояние Хэмминга]]<br /> *[[Избыточное кодирование, код Хэмминга]]<br /> <br /> == Комбинаторика ==<br /> *[[Комбинаторные объекты]]<br /> *[[Лексикографический порядок]]<br /> *[[Формула включения-исключения]]<br /> *[[Генерация комбинаторных объектов в лексикографическом порядке]]<br /> *[[Получение номера по объекту]]<br /> *[[Получение объекта по номеру]]<br /> *[[Получение следующего объекта]]<br /> *[[Коды Грея]]<br /> *[[Коды Грея для перестановок]]<br /> *[[Цепные коды]]<br /> *[[Действие перестановки на набор из элементов, представление в виде циклов]]<br /> *[[Метод генерации случайной перестановки, алгоритм Фишера-Йетса]]<br /> *[[Таблица инверсий]]<br /> *[[Умножение перестановок, обратная перестановка, группа перестановок]]<br /> *[[Теорема Кэли]]<br /> *[[Матричное представление перестановок]]<br /> *[[Задача о минимуме/максимуме скалярного произведения]]<br /> *[[Задача о монотонных подпоследовательностях, теорема о связи длины НВП и НУП]]<br /> *[[Поиск наибольшей возрастающей подпоследовательности и т. д.]]<br /> *[[Нахождение количества разбиений числа на слагаемые | Нахождение количества разбиений числа на слагаемые. Пентагональная теорема Эйлера]]<br /> <br /> == Динамическое программирование ==<br /> *[[Кратчайший путь в ациклическом графе]]<br /> *[[Задача о расстановке знаков в выражении]]<br /> *[[Задача о наибольшей общей подпоследовательности]]<br /> *[[Задача о перемножении матриц]]<br /> *[[Задача о наибольшей возрастающей подпоследовательности]]<br /> *[[Задача о паросочетании максимального веса в дереве, амортизированные оценки для ДП на дереве]]<br /> *[[Метод четырех русских для умножения матриц]]<br /> *[[Применение метода четырех русских в задачах ДП на примере задачи о НОП]]<br /> *[[Задача коммивояжера, ДП по подмножествам]]<br /> *[[Задача о выводе в контекстно-свободной грамматике, алгоритм Кока-Янгера-Касами]]<br /> *[[Задача о редакционном расстоянии, алгоритм Левенштейна]]<br /> *[[Задача об оптимальном префиксном коде с сохранением порядка. Монотонность точки разреза]]<br /> <br /> == Теория вероятности ==<br /> *[[Вероятностное пространство, элементарный исход, событие]]<br /> *[[Независимые события]]<br /> *[[Условная вероятность]]<br /> *[[Формула Байеса]]<br /> *[[Формула полной вероятности]]<br /> *[[Дискретная случайная величина]]<br /> *[[Независимые случайные величины]]<br /> *[[Линейность математического ожидания]]<br /> *[[Ковариация случайных величин]]<br /> *[[Дисперсия случайной величины]]<br /> *[[Энтропия случайного источника]]<br /> *[[Симуляция одним распределением другого]]<br /> *[[Арифметическое кодирование]]<br /> <br /> == [[Марковская цепь|Марковские цепи]] ==<br /> <br /> * [[Теорема о поглощении]]<br /> * [[Фундаментальная матрица]]<br /> * [[Математическое ожидание времени поглощения]]<br /> * [[Расчет вероятности поглощения в состоянии]]<br /> * [[Эргодическая марковская цепь]]<br /> * [[Регулярная марковская цепь]]<br /> <br /> == Амортизационный анализ ==<br /> * [[Амортизационный анализ. Метод предоплаты]]<br /> * [[Саморасширяющийся массив]]<br /> * [[Массив с увеличением/уменьшением размера]]<br /> * [[Стек]]<br /> * [[Очередь]]<br /> * [[Список]]<br /> <br /> == Приоритетные очереди ==<br /> * [[Двоичная куча|Двоичная куча]]<br /> * [[Биномиальная куча|Биномиальная пирамида]]<br /> * [[Фибоначчиевы кучи|Фибоначчиевы кучи]]<br /> <br /> == Система непересекающихся множеств ==<br /> * [[СНМ(наивные реализации) | Наивные реализации]]<br /> * [[СНМ(списки с весовой эвристикой) | Списки с весовой эвристикой]]<br /> * [[СНМ(реализация с помощью леса корневых деревьев) | Реализация с помощью леса корневых деревьев]]<br /> * [[Анализ реализации с ранговой эвристикой | Анализ реализации с ранговой эвристикой]]<br /> <br /> == Деревья поиска ==<br /> * [[Упорядоченное множество]]<br /> * [[Дерево поиска, наивная реализация]]<br /> * [[АВЛ-дерево]]<br /> * [[2-3 дерево]]<br /> * [[B-дерево]]<br /> * [[Красно-черное дерево]]<br /> * [[Декартово дерево]]<br /> * [[Splay-дерево]]<br /> * [[Декартово дерево по неявному ключу]]<br /> <br /> == Дерево отрезков ==<br /> * [[Статистики на отрезках. Корневая эвристика]]<br /> * [[Дерево отрезков. Построение]]<br /> * [[Реализация запроса в дереве отрезков сверху]]<br /> * [[Реализация запроса в дереве отрезков снизу]]<br /> * [[Несогласованные поддеревья. Реализация массового обновления]]<br /> * [[Сжатое многомерное дерево отрезков]]<br /> * [[Многомерное дерево отрезков]]<br /> <br /> == Дерево Фенвика ==<br /> * [[Дерево Фенвика]]<br /> * [[Встречное дерево Фенвика]]<br /> * [[Дерево Фенвика, запрос изменения элемента]]<br /> * [[Многомерное дерево Фенвика]]<br /> <br /> == Хеширование ==<br /> * [[Хеширование]]<br /> * [[Различные алгоритмы хеширования]]<br /> * [[Открытое и закрытое хеширование]]<br /> * [[Поиск свободного места при закрытом хешировании]]<br /> * [[Хеширование кукушки]]<br /> * [[Двойное хеширование]]<br /> * [[Перехеширование. Амортизационный анализ]]<br /> <br /> == Сортировка ==<br /> * [[Сортировка пузырьком]]<br /> * [[Сортировка слиянием]]<br /> * [[Cортировка слиянием с использованием O(1) дополнительной памяти]]<br /> * [[Сортировка вставками]]<br /> * [[Сортировка подсчетом]]<br /> * [[Сортировка подсчетом сложных объектов]]<br /> * [[Поиск k-ой порядковой статистики]]<br /> * [[Поиск k-й порядковой статистики за линейное время]]<br /> * [[Теорема о нижней оценке для сортировки сравнениями]]<br /> <br /> == [[Сортирующие сети]] ==<br /> * [[0-1 принцип | Проверка сети компараторов на то, что она сортирующая. 0-1 принцип]]<br /> * [[Сортирующие сети для квадратичных сортировок]]<br /> * [[Сеть Бетчера]]<br /> <br /> == Алгоритмы поиска ==<br /> * [[Поиск с помощью золотого сечения]]<br /> * [[Интерполяционный поиск]]</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%9E%D0%B1%D1%81%D1%83%D0%B6%D0%B4%D0%B5%D0%BD%D0%B8%D0%B5:%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B8%D0%B9_%D0%BC%D0%B8%D0%BD%D0%B8%D0%BC%D1%83%D0%BC_%D0%BF%D0%BE_%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%BC%D1%83_%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7%D1%83_%D0%B7%D0%B0_2_%D1%81%D0%B5%D0%BC%D0%B5%D1%81%D1%82%D1%80&diff=9674 Обсуждение:Теоретический минимум по математическому анализу за 2 семестр 2011-06-12T02:48:22Z

<p>System29a: </p> <hr /> <div>Вопрос №7. Признак типа Абеля-Дирихле<br /> <br /> казалось бы, недостаточно, чтобы <tex>a_n(x)</tex> стремилась к нулю, нужно еще чтобы она это делала монотонно<br /> :fixed<br /> <br /> 14, 15 вопрос, конечно, очень хотелось бы, что-бы запилили [[Участник:System29a|System29a]] 02:48, 12 июня 2011 (UTC)</div>

System29a http://neerc.ifmo.ru/wiki/index.php?title=%D0%A1%D0%BE%D1%80%D1%82%D0%B8%D1%80%D1%83%D1%8E%D1%89%D0%B8%D0%B5_%D1%81%D0%B5%D1%82%D0%B8_%D0%B4%D0%BB%D1%8F_%D0%BA%D0%B2%D0%B0%D0%B4%D1%80%D0%B0%D1%82%D0%B8%D1%87%D0%BD%D1%8B%D1%85_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BE%D0%BA&diff=9239 Сортирующие сети для квадратичных сортировок 2011-06-07T17:23:24Z

<p>System29a: /* Сортирующие сети с последовательной сортировкой */</p> <hr /> <div>{{В разработке}}<br /> <br /> Рассмотрим модели сортирующих сетей для квадратичных сортировок. <br /> <br /> == Сортирующие сети с последовательной сортировкой ==<br /> <br /> На один слой будем устанавливать только один компаратор. Все последующие сети получаются простым моделированием соответствующих сортировок.<br /> <br /> === Сортировка пузырьком ===<br /> <br /> [[Файл:Bubblesort.png]]<br /> <br /> === Сортировка вставками ===<br /> <br /> [[Файл:Insertsort.png]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesort.png‎]]<br /> <br /> == Сортирующие сети с параллельной сортировкой ==<br /> <br /> На один слой будем устанавливать несколько компараторов.<br /> <br /> === Сортировка пузырьком и вставками ===<br /> <br /> Интересно два факта:<br /> <br /> * Если сжать последовательные сортирующие сети пузырьком и вставками, то результат будет одним и тем же.<br /> * В результирующей сети будет <tex>(2n - 3)</tex> слоев.<br /> <br /> [[Файл:Parralelsort.png‎]]<br /> <br /> === Сортировка выбором ===<br /> <br /> [[Файл:Choosesortparralel.png‎]]</div>

System29a