http://neerc.ifmo.ru/wiki/api.php?action=feedcontributions&feedformat=atom&user=GR1nВикиконспекты - Вклад участника [ru]2026-06-11T17:18:21ZВклад участникаMediaWiki 1.30.0http://neerc.ifmo.ru/wiki/index.php?title=Opi1sumu&diff=32655Opi1sumu2013-06-21T16:27:24Z<p>GR1n: /* Описание алгоритма */</p>
<hr />
<div>==Описание задачи==<br />
Дано <tex>m</tex> одинаковых станков, которые работают параллельно и <tex>n</tex> работ, котороые необходимо выполнить<br />
в произвольном порядке на всех станках. Время выполнения каждой работы на любом станке одинаково и равно одному. <br />
Для каждой работы известно время, до которого её необходимо выполнить. Необходимо успеть выполнить как можно больше работ. <br />
<br />
==Описание алгоритма==<br />
Отсортируем работы в порядке невозрастания дедлайнов. <br />
<br />
{{Утверждение<br />
|statement=Если в оптимальном расписании можно сделать <tex>k</tex> работ, то можно сделать первые <tex>k</tex> работ.<br />
|proof=Пусть в оптимальном расписании были сделаны работы <tex>i_1, i_2, \ldots, i_k</tex>. Докажем, что существует <br />
оптимальное расписание, в котором сделаны работы <tex>1, 2, \ldots, k</tex>. Пусть работы <tex>i_1, i_2, \ldots, i_k</tex><br />
тоже отсортированы в порядке неубывания дедлайна. Тогда <tex>d_{i1} \le d_1, d_{i2}\le d_2, \ldots, d_{ik}\le d_{k}</tex>.<br />
Тогда, если заменить во всём расписании работу <tex>i_j</tex> на работу <tex>j</tex>, то она, тем более, будет выполнена.<br />
}}<br />
<br />
{{Определение<br />
|definition=Обозначим за ''тайм-слот t'' множество из не более, чем <tex>m</tex> различных чисел {{---}} <br />
номера работ, которые мы хотим выполнить в момент времени <tex>t</tex>.<br />
}}<br />
<br />
Введем тайм-слот для каждого момента времени от <tex>0</tex> до <tex>d_n</tex>.<br />
Каждую работу будем пытаться сделать как можно позже. Будем рассматривать работы в порядке невозрастания дедлайнов. <br />
<tex>i</tex>-ю работу попытаемся добавить в тайм-слоты с номерами от <tex>d_i - m + 1</tex> по <tex>d_i</tex>. <br />
После добавления некоторые тайм-слоты могли переполниться (тайм-слот переполнился, если в нём уже находилось<br />
<tex>m</tex> работ, и в него добавили <tex>m+1</tex>-ю). <br />
Для переполнившегося тайм-слота найдём найдем самый правый левее него тайм-слот, который ещё не переполнился и перекинем работу, <br />
которой там еще нет, в него. Так как в нем меньше элементов, то по принципу Дирихле, это можно сделать. <br />
<br />
{{Утверждение<br />
|statement=Следуя этому алгоритму, расписания не существует тогда и только тогда, когда<br />
переполнился нулевой тайм-слот.<br />
|proof=<br />
<tex>\Rightarrow</tex><br />
Расписания не существует, а значит, никакой алгоритм его не найдет.<br />
<br />
<tex>\Leftarrow</tex><br />
Введем понятие ''фронта'' расписания. ''Фронтом'' назовем вектор размеров тайм-слотов. Заметим, что от того, в каком порядке происходят перебрасывания из переполнившихся тайм-слотов, итоговый фронт не зависит. Поэтому, если мы сначала положим все работы в тайм-слоты, игнорируя ограничение на их размер, а потом в каком-то порядке перекинем, итоговый фронт окажется тем же. В случае, если при построении тайм-слотов игнорировалось ограничение на их размер, ни одну единицу работы нельзя назначить позже.<br />
<br />
Будем также рассматривать тайм-слоты без номеров работ: в каждом тайм-слоте просто лежит сколько-то единиц работ. От этого итоговый фронт также не изменится. Заметим, что если нельзя составить корректную в плане наполненности конфигурацию тайм-слотов при данном ослаблении, то нельзя это сделать и в случае существования номера у каждой единицы работы. Будем рассматривать тайм-слоты по убыванию времени с <tex>d_1</tex> до <tex>0</tex>. В каждый момент времени будем хранить сколько работ ''необходимо'' перекинуть на более ранние тайм-слоты. Изначально это число равно нулю.<br />
<br />
Рассмотрим очередной тайм-слот. Пусть в нем занято <tex>h</tex> ячеек из <tex>m</tex>, а также есть еще <tex>a</tex> нераспределяемых позже единиц работы. Здесь возможны два случая:<br />
* <tex>h + a > m</tex>. В этом случае, так как более <tex>m</tex> единиц работы сейчас выполнить нельзя, а также ничего нельзя назначить позже, то оказывается, что невыполняемых сейчас или позже работ стало <tex>h + a - m</tex>.<br />
* Если <tex>h + a <= m</tex>. Здесь можно назначить все нераспределяемые позже работы на это время, и сбросить их счетчик.<br />
<br />
Так как и этот, и изучаемый алгоритм получают в итоге одинаковый фронт, а в этом мы вышли из нулевого времени, а невыполненные единицы работы остались, то так как распределить их никак невозможно, то не существует расписания, в котором бы выполнились все работы.<br />
}}<br />
<br />
Опираясь на это утверждение, можно найти максимальное количество работ, которое можно выполнить. Обозначим его за <tex>k</tex>.<br />
<br />
Сведем задачу построения распинания по построенным тайм-слотам к задаче о покрытии двудольного графа минимальным <br />
количеством паросочетаний.<br />
<br />
Построим двудольный граф. В левой доле вершинам будут соответствовать работы, в правой {{---}} времена. Соответственно, в левой доле будет <tex>n</tex> вершин, в правой {{---}} <tex>d_{max}</tex>. Ребро между работой <tex>i</tex> и временем <tex>t</tex> будет, если работа <tex>i</tex> есть в тайм-слоте <tex>t</tex>.<br />
<br />
Рассмотрим какое-то паросочетание <tex>M</tex> в этом графе. Оно соответствует корректному расписанию работ на одной машине: ни одна работа не выполняется два раза и ни в один момент времени не выполняется более одной работы.<br />
<br />
Тогда, если мы сможем построить множество мощности <tex>m</tex> такое, что каждое ребро находится хотя бы в одном из паросочетаний, то оно будет соответствовать тому, что каждая работа обработана на каждом станке, а значит, составлено корректное расписание для этих <tex>k</tex> работ.<br />
<br />
Достроим граф до регулярного степени <tex>m</tex>. Достраивать будем следующим образом. Каждая вершина в левой доле имеет степень <tex>m</tex>, так как каждая работа представлена в <tex>m</tex> тайм-слотах. В правой доле степень каждой вершины не больше <tex>m</tex>, так как в тайм-слоте не может быть больше, чем <tex>m</tex> работ. Значит, в левой доле не больше вершин, чем в правой.<br />
Добавим в левую долю фиктивных вершин, чтобы количества вершин в левой и правой долях сравнялись. После чего просто будем добавлять ребра между вершинами, степень которых еще меньше <tex>m</tex>. Для покрытия этого графа паросочетаниями воспользуемся тем фактом, что регулярный двудольный граф степени <tex>d</tex> можно покрыть <tex>d</tex> паросочетаниями. <br />
<br />
При помощи построения паросочетаний было построено расписание для тех <tex>k</tex> работ, которые можно успеть сделать. Так как остальные работы уже нельзя успеть, расписание для них можно составить произвольное. Например, выполнять их по очереди после выполнения первых <tex>k</tex> работ.<br />
<br />
==Оценка сложности алгоритма==<br />
Рассмотрим добавление очередной работы в тайм-слоты. За <tex>O(t)</tex> найдём переполнившийся тайм-слот и за <tex>O(m)</tex> перекинем из него элемент. Так как <tex>t=O(nm)</tex>, итоговая сложность этой части {{---}} <tex>O(n^2m)</tex>.<br />
<br />
Достроение графа до регулярного делается за <tex>O(E)</tex>, где <tex>E</tex> {{---}} количество ребер в нем. Количество ребер в регулярном двудольном графе <tex>E = Vd</tex>, где <tex>V</tex> {{---}} количество вершин в одной из долей, а <tex>d</tex> {{---}} степень. Количество вершин в правой доле {{---}} <tex>O(t) = O(nm)</tex>. Значит граф будет построен за <tex>O(nm^2)</tex>, так как степень каждой вершины {{---}} <tex>m</tex>.<br />
<br />
Сложность последней фазы зависит от того, каким алгоритмом граф разбивается на паросочетания. Использовав, например, алгоритм Куна, можно добиться сложности <tex>O(m \cdot M) = O(m \cdot n^3m^3)</tex>. Итоговая сложность алгоритма {{---}} <tex>O(n^3m^4)</tex>.</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=Opi1sumu&diff=32654Opi1sumu2013-06-21T16:25:00Z<p>GR1n: /* Оценка сложности алгоритма */</p>
<hr />
<div>==Описание задачи==<br />
Дано <tex>m</tex> одинаковых станков, которые работают параллельно и <tex>n</tex> работ, котороые необходимо выполнить<br />
в произвольном порядке на всех станках. Время выполнения каждой работы на любом станке одинаково и равно одному. <br />
Для каждой работы известно время, до которого её необходимо выполнить. Необходимо успеть выполнить как можно больше работ. <br />
<br />
==Описание алгоритма==<br />
Отсортируем работы в порядке невозрастания дедлайнов. <br />
<br />
{{Утверждение<br />
|statement=Если в оптимальном расписании можно сделать <tex>k</tex> работ, то можно сделать первые <tex>k</tex> работ.<br />
|proof=Пусть в оптимальном расписании были сделаны работы <tex>i_1, i_2, \ldots, i_k</tex>. Докажем, что существует <br />
оптимальное расписание, в котором сделаны работы <tex>1, 2, \ldots, k</tex>. Пусть работы <tex>i_1, i_2, \ldots, i_k</tex><br />
тоже отсортированы в порядке неубывания дедлайна. Тогда <tex>d_{i1} \le d_1, d_{i2}\le d_2, \ldots, d_{ik}\le d_{k}</tex>.<br />
Тогда, если заменить во всём расписании работу <tex>i_j</tex> на работу <tex>j</tex>, то она, тем более, будет выполнена.<br />
}}<br />
<br />
{{Определение<br />
|definition=Обозначим за ''тайм-слот t'' множество из не более, чем <tex>m</tex> различных чисел {{---}} <br />
номера работ, которые мы хотим выполнить в момент времени <tex>t</tex>.<br />
}}<br />
<br />
Введем тайм-слот для каждого момента времени от <tex>0</tex> до <tex>d_n</tex>.<br />
Каждую работу будем пытаться сделать как можно позже. Будем рассматривать работы в порядке невозрастания дедлайнов. <br />
<tex>i</tex>-ю работу попытаемся добавить в тайм-слоты с номерами от <tex>d_i - m + 1</tex> по <tex>d_i</tex>. <br />
После добавления некоторые тайм-слоты могли переполниться (тайм-слот переполнился, если в нём уже находилось<br />
<tex>m</tex> работ, и в него добавили <tex>m+1</tex>-ю). <br />
Для переполнившегося тайм-слота найдём найдем самый правый левее него тайм-слот, который ещё не переполнился и перекинем работу, <br />
которой там еще нет, в него. Так как в нем меньше элементов, то по принципу Дирихле, это можно сделать. <br />
<br />
{{Утверждение<br />
|statement=Следуя этому алгоритму, расписания не существует тогда и только тогда, когда<br />
переполнился нулевой тайм-слот.<br />
|proof=<br />
<tex>\Rightarrow</tex><br />
Расписания не существует, а значит, никакой алгоритм его не найдет.<br />
<br />
<tex>\Leftarrow</tex><br />
Введем понятие ''фронта'' расписания. ''Фронтом'' назовем вектор размеров тайм-слотов. Заметим, что от того, в каком порядке происходят перебрасывания из переполнившихся тайм-слотов, итоговый фронт не зависит. Поэтому, если мы сначала положим все работы в тайм-слоты, игнорируя ограничение на их размер, а потом в каком-то порядке перекинем, итоговый фронт окажется тем же. В случае, если при построении тайм-слотов игнорировалось ограничение на их размер, ни одну единицу работы нельзя назначить позже.<br />
<br />
Будем также рассматривать тайм-слоты без номеров работ: в каждом тайм-слоте просто лежит сколько-то единиц работ. От этого итоговый фронт также не изменится. Заметим, что если нельзя составить корректную в плане наполненности конфигурацию тайм-слотов при данном ослаблении, то нельзя это сделать и в случае существования номера у каждой единицы работы. Будем рассматривать тайм-слоты по убыванию времени с <tex>d_1</tex> до <tex>0</tex>. В каждый момент времени будем хранить сколько работ ''необходимо'' перекинуть на более ранние тайм-слоты. Изначально это число равно нулю.<br />
<br />
Рассмотрим очередной тайм-слот. Пусть в нем занято <tex>h</tex> ячеек из <tex>m</tex>, а также есть еще <tex>a</tex> нераспределяемых позже единиц работы. Здесь возможны два случая:<br />
* <tex>h + a > m</tex>. В этом случае, так как более <tex>m</tex> единиц работы сейчас выполнить нельзя, а также ничего нельзя назначить позже, то оказывается, что невыполняемых сейчас или позже работ стало <tex>h + a - m</tex>.<br />
* Если <tex>h + a <= m</tex>. Здесь можно назначить все нераспределяемые позже работы на это время, и сбросить их счетчик.<br />
<br />
Так как и этот, и изучаемый алгоритм получают в итоге одинаковый фронт, а в этом мы вышли из нулевого времени, а невыполненные единицы работы остались, то так как распределить их никак невозможно, то не существует расписания, в котором бы выполнились все работы.<br />
}}<br />
<br />
Опираясь на это утверждение, можно найти максимальное количество работ, которое можно выполнить. Обозначим его за <tex>k</tex>.<br />
<br />
Сведем задачу построения распинания по построенным тайм-слотам к задаче о покрытии двудольного графа минимальным <br />
количеством паросочетаний.<br />
<br />
Построим двудольный граф. В левой доле вершинам будут соответствовать работы, в правой {{---}} времена. Соответственно, в левой доле будет <tex>n</tex> вершин, в правой {{---}} <tex>d_{max}</tex>. Ребро между работой <tex>i</tex> и временем <tex>t</tex> будет, если работа <tex>i</tex> есть в тайм-слоте <tex>t</tex>.<br />
<br />
Рассмотрим какое-то паросочетание <tex>M</tex> в этом графе. Оно соответствует корректному расписанию работ на одной машине: ни одна работа не выполняется два раза, и ни в один момент времени не выполняется более одной работы.<br />
<br />
Тогда, если мы сможем построить множество мощности <tex>m</tex> такое, что каждое ребро находится хотя бы в одном из паросочетаний, то оно будет соответствовать тому, что каждая работа обработана на каждом станке, а значит, составлено корректное расписание для этих <tex>k</tex> работ.<br />
<br />
Достроим граф до регулярного степени <tex>m</tex>. Достраивать будем следующим образом. Каждая вершина в левой доле имеет степень <tex>m</tex>, так как каждая работа представлена в <tex>m</tex> тайм-слотах. В правой доле степень каждой вершины не больше <tex>m</tex>, так как в тайм-слоте не может быть больше, чем <tex>m</tex> работ. Значит, в левой доле не больше вершин, чем в правой.<br />
Добавим в левую долю фиктивных вершин, чтобы количества вершин в левой и правой долях сравнялись. После чего просто будем добавлять ребра между вершинами, степень которых еще меньше <tex>m</tex>. Для покрытия этого графа паросочетаниями воспользуемся тем фактом, что регулярный двудольный граф степени <tex>d</tex> можно покрыть <tex>d</tex> паросочетаниями. <br />
<br />
При помощи построения паросочетаний было построено расписание для тех <tex>k</tex> работ, которые можно успеть сделать. Так как остальные работы уже нельзя успеть, расписание для них можно составить произвольное. Например, выполнять их по очереди после выполнения первых <tex>k</tex> работ.<br />
<br />
==Оценка сложности алгоритма==<br />
Рассмотрим добавление очередной работы в тайм-слоты. За <tex>O(t)</tex> найдём переполнившийся тайм-слот и за <tex>O(m)</tex> перекинем из него элемент. Так как <tex>t=O(nm)</tex>, итоговая сложность этой части {{---}} <tex>O(n^2m)</tex>.<br />
<br />
Достроение графа до регулярного делается за <tex>O(E)</tex>, где <tex>E</tex> {{---}} количество ребер в нем. Количество ребер в регулярном двудольном графе <tex>E = Vd</tex>, где <tex>V</tex> {{---}} количество вершин в одной из долей, а <tex>d</tex> {{---}} степень. Количество вершин в правой доле {{---}} <tex>O(t) = O(nm)</tex>. Значит граф будет построен за <tex>O(nm^2)</tex>, так как степень каждой вершины {{---}} <tex>m</tex>.<br />
<br />
Сложность последней фазы зависит от того, каким алгоритмом граф разбивается на паросочетания. Использовав, например, алгоритм Куна, можно добиться сложности <tex>O(m \cdot M) = O(m \cdot n^3m^3)</tex>. Итоговая сложность алгоритма {{---}} <tex>O(n^3m^4)</tex>.</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=Opi1sumu&diff=32653Opi1sumu2013-06-21T16:21:56Z<p>GR1n: /* Описание алгоритма */</p>
<hr />
<div>==Описание задачи==<br />
Дано <tex>m</tex> одинаковых станков, которые работают параллельно и <tex>n</tex> работ, котороые необходимо выполнить<br />
в произвольном порядке на всех станках. Время выполнения каждой работы на любом станке одинаково и равно одному. <br />
Для каждой работы известно время, до которого её необходимо выполнить. Необходимо успеть выполнить как можно больше работ. <br />
<br />
==Описание алгоритма==<br />
Отсортируем работы в порядке невозрастания дедлайнов. <br />
<br />
{{Утверждение<br />
|statement=Если в оптимальном расписании можно сделать <tex>k</tex> работ, то можно сделать первые <tex>k</tex> работ.<br />
|proof=Пусть в оптимальном расписании были сделаны работы <tex>i_1, i_2, \ldots, i_k</tex>. Докажем, что существует <br />
оптимальное расписание, в котором сделаны работы <tex>1, 2, \ldots, k</tex>. Пусть работы <tex>i_1, i_2, \ldots, i_k</tex><br />
тоже отсортированы в порядке неубывания дедлайна. Тогда <tex>d_{i1} \le d_1, d_{i2}\le d_2, \ldots, d_{ik}\le d_{k}</tex>.<br />
Тогда, если заменить во всём расписании работу <tex>i_j</tex> на работу <tex>j</tex>, то она, тем более, будет выполнена.<br />
}}<br />
<br />
{{Определение<br />
|definition=Обозначим за ''тайм-слот t'' множество из не более, чем <tex>m</tex> различных чисел {{---}} <br />
номера работ, которые мы хотим выполнить в момент времени <tex>t</tex>.<br />
}}<br />
<br />
Введем тайм-слот для каждого момента времени от <tex>0</tex> до <tex>d_n</tex>.<br />
Каждую работу будем пытаться сделать как можно позже. Будем рассматривать работы в порядке невозрастания дедлайнов. <br />
<tex>i</tex>-ю работу попытаемся добавить в тайм-слоты с номерами от <tex>d_i - m + 1</tex> по <tex>d_i</tex>. <br />
После добавления некоторые тайм-слоты могли переполниться (тайм-слот переполнился, если в нём уже находилось<br />
<tex>m</tex> работ, и в него добавили <tex>m+1</tex>-ю). <br />
Для переполнившегося тайм-слота найдём найдем самый правый левее него тайм-слот, который ещё не переполнился и перекинем работу, <br />
которой там еще нет, в него. Так как в нем меньше элементов, то по принципу Дирихле, это можно сделать. <br />
<br />
{{Утверждение<br />
|statement=Следуя этому алгоритму, расписания не существует тогда и только тогда, когда<br />
переполнился нулевой тайм-слот.<br />
|proof=<br />
<tex>\Rightarrow</tex><br />
Расписания не существует, а значит, никакой алгоритм его не найдет.<br />
<br />
<tex>\Leftarrow</tex><br />
Введем понятие ''фронта'' расписания. ''Фронтом'' назовем вектор размеров тайм-слотов. Заметим, что от того, в каком порядке происходят перебрасывания из переполнившихся тайм-слотов, итоговый фронт не зависит. Поэтому, если мы сначала положим все работы в тайм-слоты, игнорируя ограничение на их размер, а потом в каком-то порядке перекинем, итоговый фронт окажется тем же. В случае, если при построении тайм-слотов игнорировалось ограничение на их размер, ни одну единицу работы нельзя назначить позже.<br />
<br />
Будем также рассматривать тайм-слоты без номеров работ: в каждом тайм-слоте просто лежит сколько-то единиц работ. От этого итоговый фронт также не изменится. Заметим, что если нельзя составить корректную в плане наполненности конфигурацию тайм-слотов при данном ослаблении, то нельзя это сделать и в случае существования номера у каждой единицы работы. Будем рассматривать тайм-слоты по убыванию времени с <tex>d_1</tex> до <tex>0</tex>. В каждый момент времени будем хранить сколько работ ''необходимо'' перекинуть на более ранние тайм-слоты. Изначально это число равно нулю.<br />
<br />
Рассмотрим очередной тайм-слот. Пусть в нем занято <tex>h</tex> ячеек из <tex>m</tex>, а также есть еще <tex>a</tex> нераспределяемых позже единиц работы. Здесь возможны два случая:<br />
* <tex>h + a > m</tex>. В этом случае, так как более <tex>m</tex> единиц работы сейчас выполнить нельзя, а также ничего нельзя назначить позже, то оказывается, что невыполняемых сейчас или позже работ стало <tex>h + a - m</tex>.<br />
* Если <tex>h + a <= m</tex>. Здесь можно назначить все нераспределяемые позже работы на это время, и сбросить их счетчик.<br />
<br />
Так как и этот, и изучаемый алгоритм получают в итоге одинаковый фронт, а в этом мы вышли из нулевого времени, а невыполненные единицы работы остались, то так как распределить их никак невозможно, то не существует расписания, в котором бы выполнились все работы.<br />
}}<br />
<br />
Опираясь на это утверждение, можно найти максимальное количество работ, которое можно выполнить. Обозначим его за <tex>k</tex>.<br />
<br />
Сведем задачу построения распинания по построенным тайм-слотам к задаче о покрытии двудольного графа минимальным <br />
количеством паросочетаний.<br />
<br />
Построим двудольный граф. В левой доле вершинам будут соответствовать работы, в правой {{---}} времена. Соответственно, в левой доле будет <tex>n</tex> вершин, в правой {{---}} <tex>d_{max}</tex>. Ребро между работой <tex>i</tex> и временем <tex>t</tex> будет, если работа <tex>i</tex> есть в тайм-слоте <tex>t</tex>.<br />
<br />
Рассмотрим какое-то паросочетание <tex>M</tex> в этом графе. Оно соответствует корректному расписанию работ на одной машине: ни одна работа не выполняется два раза, и ни в один момент времени не выполняется более одной работы.<br />
<br />
Тогда, если мы сможем построить множество мощности <tex>m</tex> такое, что каждое ребро находится хотя бы в одном из паросочетаний, то оно будет соответствовать тому, что каждая работа обработана на каждом станке, а значит, составлено корректное расписание для этих <tex>k</tex> работ.<br />
<br />
Достроим граф до регулярного степени <tex>m</tex>. Достраивать будем следующим образом. Каждая вершина в левой доле имеет степень <tex>m</tex>, так как каждая работа представлена в <tex>m</tex> тайм-слотах. В правой доле степень каждой вершины не больше <tex>m</tex>, так как в тайм-слоте не может быть больше, чем <tex>m</tex> работ. Значит, в левой доле не больше вершин, чем в правой.<br />
Добавим в левую долю фиктивных вершин, чтобы количества вершин в левой и правой долях сравнялись. После чего просто будем добавлять ребра между вершинами, степень которых еще меньше <tex>m</tex>. Для покрытия этого графа паросочетаниями воспользуемся тем фактом, что регулярный двудольный граф степени <tex>d</tex> можно покрыть <tex>d</tex> паросочетаниями. <br />
<br />
При помощи построения паросочетаний было построено расписание для тех <tex>k</tex> работ, которые можно успеть сделать. Так как остальные работы уже нельзя успеть, расписание для них можно составить произвольное. Например, выполнять их по очереди после выполнения первых <tex>k</tex> работ.<br />
<br />
==Оценка сложности алгоритма==<br />
Рассмотрим добавление очередной работы в тайм-слоты. За <tex>O(t)</tex> найдём переполнившийся тайм-слот и за <tex>O(m)</tex> перекинем из него элемент. Так как <tex>t=O(nm)</tex>, итоговая сложность этой части {{---}} <tex>O(n^2m)</tex>.<br />
<br />
Достроение графа до регулярного делается за <tex>O(E)</tex>, где <tex>E</tex> {{---}} количество ребер в нем. Количество ребер в регулярном двудольном графе <tex>E = Vd</tex>, где <tex>V</tex> {{---}} количество вершин в одной из долей, а <tex>d</tex> {{---}} степень. Количество вершин в правой доле {{---}} <tex>O(t) = O(nm)</tex>. Значит, граф будет построен за <tex>O(nm^2)</tex>, так как степень каждой вершины {{---}} <tex>m</tex>.<br />
<br />
Сложность последней фазы зависит от того, каким алгоритмом граф разбивается на паросочетания. Использовав, например, алгоритм Куна, можно добиться сложности <tex>O(m \cdot M) = O(m \cdot n^3m^3)</tex>. Итоговая сложность алгоритма {{---}} <tex>O(n^3m^4)</tex>.</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=Opi1sumu&diff=32652Opi1sumu2013-06-21T16:19:15Z<p>GR1n: /* Описание алгоритма */</p>
<hr />
<div>==Описание задачи==<br />
Дано <tex>m</tex> одинаковых станков, которые работают параллельно и <tex>n</tex> работ, котороые необходимо выполнить<br />
в произвольном порядке на всех станках. Время выполнения каждой работы на любом станке одинаково и равно одному. <br />
Для каждой работы известно время, до которого её необходимо выполнить. Необходимо успеть выполнить как можно больше работ. <br />
<br />
==Описание алгоритма==<br />
Отсортируем работы в порядке невозрастания дедлайнов. <br />
<br />
{{Утверждение<br />
|statement=Если в оптимальном расписании можно сделать <tex>k</tex> работ, то можно сделать первые <tex>k</tex> работ.<br />
|proof=Пусть в оптимальном расписании были сделаны работы <tex>i_1, i_2, \ldots, i_k</tex>. Докажем, что существует <br />
оптимальное расписание, в котором сделаны работы <tex>1, 2, \ldots, k</tex>. Пусть работы <tex>i_1, i_2, \ldots, i_k</tex><br />
тоже отсортированы в порядке неубывания дедлайна. Тогда <tex>d_{i1} \le d_1, d_{i2}\le d_2, \ldots, d_{ik}\le d_{k}</tex>.<br />
Тогда, если заменить во всём расписании работу <tex>i_j</tex> на работу <tex>j</tex>, то она, тем более, будет выполнена.<br />
}}<br />
<br />
{{Определение<br />
|definition=Обозначим за ''тайм-слот t'' множество из не более, чем <tex>m</tex> различных чисел {{---}} <br />
номера работ, которые мы хотим выполнить в момент времени <tex>t</tex>.<br />
}}<br />
<br />
Введем тайм-слот для каждого момента времени от <tex>0</tex> до <tex>d_n</tex>.<br />
Каждую работу будем пытаться сделать как можно позже. Будем рассматривать работы в порядке невозрастания дедлайнов. <br />
<tex>i</tex>-ю работу попытаемся добавить в тайм-слоты с номерами от <tex>d_i - m + 1</tex> по <tex>d_i</tex>. <br />
После добавления некоторые тайм-слоты могли переполниться (тайм-слот переполнился, если в нём уже находилось<br />
<tex>m</tex> работ, и в него добавили <tex>m+1</tex>-ю). <br />
Для переполнившегося тайм-слота найдём найдем самый правый левее него тайм-слот, который ещё не переполнился и перекинем работу, <br />
которой там еще нет, в него. Так как в нем меньше элементов, то, по принципу Дирихле, это можно сделать. <br />
<br />
{{Утверждение<br />
|statement=Следуя этому алгоритму, расписания не существует тогда и только тогда, когда<br />
переполнился нулевой тайм-слот.<br />
|proof=<br />
<tex>\Rightarrow</tex><br />
Расписания не существует, а значит, никакой алгоритм его не найдет.<br />
<br />
<tex>\Leftarrow</tex><br />
Введем понятие ''фронта'' расписания. ''Фронтом'' назовем вектор размеров тайм-слотов. Заметим, что от того, в каком порядке происходят перебрасывания из переполнившихся тайм-слотов, итоговый фронт не зависит. Поэтому, если мы сначала положим все работы в тайм-слоты, игнорируя ограничение на их размер, а потом в каком-то порядке перекинем, итоговый фронт окажется тем же. В случае, если при построении тайм-слотов игнорировалось ограничение на их размер, ни одну единицу работы нельзя назначить позже.<br />
<br />
Будем также рассматривать тайм-слоты без номеров работ: в каждом тайм-слоте просто лежит сколько-то единиц работ. От этого итоговый фронт также не изменится. Заметим, что если нельзя составить корректную в плане наполненности конфигурацию тайм-слотов при данном ослаблении, то нельзя это сделать и в случае существования номера у каждой единицы работы. Будем рассматривать тайм-слоты по убыванию времени с <tex>d_1</tex> до <tex>0</tex>. В каждый момент времени будем хранить сколько работ ''необходимо'' перекинуть на более ранние тайм-слоты. Изначально это число равно нулю.<br />
<br />
Рассмотрим очередной тайм-слот. Пусть в нем занято <tex>h</tex> ячеек из <tex>m</tex>, а также есть еще <tex>a</tex> нераспределяемых позже единиц работы. Здесь возможны два случая:<br />
* <tex>h + a > m</tex>. В этом случае, так как более <tex>m</tex> единиц работы сейчас выполнить нельзя, а также ничего нельзя назначить позже, то оказывается, что невыполняемых сейчас или позже работ стало <tex>h + a - m</tex>.<br />
* Если <tex>h + a <= m</tex>. Здесь можно назначить все нераспределяемые позже работы на это время, и сбросить их счетчик.<br />
<br />
Так как и этот, и изучаемый алгоритм получают в итоге одинаковый фронт, а в этом мы вышли из нулевого времени, а невыполненные единицы работы остались, то, так как распределить их никак невозможно, то не существует расписания, в котором бы выполнились все работы.<br />
}}<br />
<br />
Опираясь на это утверждение, можно найти максимальное количество работ, которое можно выполнить. Обозначим его за <tex>k</tex>.<br />
<br />
Сведем задачу построения распинания по построенным тайм-слотам к задаче о покрытии двудольного графа минимальным <br />
количеством паросочетаний.<br />
<br />
Построим двудольный граф. В левой доле вершинам будут соответствовать работы, в правой {{---}} времена. Соответственно, в левой доле будет <tex>n</tex> вершин, в правой {{---}} <tex>d_{max}</tex>. Ребро между работой <tex>i</tex> и временем <tex>t</tex> будет, если работа <tex>i</tex> есть в тайм-слоте <tex>t</tex>.<br />
<br />
Рассмотрим какое-то паросочетание <tex>M</tex> в этом графе. Оно соответствует корректному расписанию работ на одной машине: ни одна работа не выполняется два раза, и ни в один момент времени не выполняется более одной работы.<br />
<br />
Тогда, если мы сможем построить множество мощности <tex>m</tex> такое, что каждое ребро находится хотя бы в одном из паросочетаний, то оно будет соответствовать тому, что каждая работа обработана на каждом станке, а значит, составлено корректное расписание для этих <tex>k</tex> работ.<br />
<br />
Достроим граф до регулярного степени <tex>m</tex>. Достраивать будем следующим образом. Каждая вершина в левой доле имеет степень <tex>m</tex>, так как каждая работа представлена в <tex>m</tex> тайм-слотах. В правой доле степень каждой вершины не больше <tex>m</tex>, так как в тайм-слоте не может быть больше, чем <tex>m</tex> работ. Значит, в левой доле не больше вершин, чем в правой.<br />
Добавим в левую долю фиктивных вершин, чтобы количества вершин в левой и правой долях сравнялись. После чего просто будем добавлять ребра между вершинами, степень которых еще меньше <tex>m</tex>. Для покрытия этого графа паросочетаниями воспользуемся тем фактом, что регулярный двудольный граф степени <tex>d</tex> можно покрыть <tex>d</tex> паросочетаниями. <br />
<br />
При помощи построения паросочетаний было построено расписание для тех <tex>k</tex> работ, которые можно успеть сделать. Так как остальные работы уже нельзя успеть, расписание для них можно составить произвольное. Например, выполнять их по очереди после выполнения первых <tex>k</tex> работ.<br />
<br />
==Оценка сложности алгоритма==<br />
Рассмотрим добавление очередной работы в тайм-слоты. За <tex>O(t)</tex> найдём переполнившийся тайм-слот и за <tex>O(m)</tex> перекинем из него элемент. Так как <tex>t=O(nm)</tex>, итоговая сложность этой части {{---}} <tex>O(n^2m)</tex>.<br />
<br />
Достроение графа до регулярного делается за <tex>O(E)</tex>, где <tex>E</tex> {{---}} количество ребер в нем. Количество ребер в регулярном двудольном графе <tex>E = Vd</tex>, где <tex>V</tex> {{---}} количество вершин в одной из долей, а <tex>d</tex> {{---}} степень. Количество вершин в правой доле {{---}} <tex>O(t) = O(nm)</tex>. Значит, граф будет построен за <tex>O(nm^2)</tex>, так как степень каждой вершины {{---}} <tex>m</tex>.<br />
<br />
Сложность последней фазы зависит от того, каким алгоритмом граф разбивается на паросочетания. Использовав, например, алгоритм Куна, можно добиться сложности <tex>O(m \cdot M) = O(m \cdot n^3m^3)</tex>. Итоговая сложность алгоритма {{---}} <tex>O(n^3m^4)</tex>.</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=Opi1sumu&diff=32651Opi1sumu2013-06-21T16:15:14Z<p>GR1n: /* Описание алгоритма */</p>
<hr />
<div>==Описание задачи==<br />
Дано <tex>m</tex> одинаковых станков, которые работают параллельно и <tex>n</tex> работ, котороые необходимо выполнить<br />
в произвольном порядке на всех станках. Время выполнения каждой работы на любом станке одинаково и равно одному. <br />
Для каждой работы известно время, до которого её необходимо выполнить. Необходимо успеть выполнить как можно больше работ. <br />
<br />
==Описание алгоритма==<br />
Отсортируем работы в порядке невозрастания дедлайнов. <br />
<br />
{{Утверждение<br />
|statement=Если в оптимальном расписании можно сделать <tex>k</tex> работ, то можно сделать первые <tex>k</tex> работ.<br />
|proof=Пусть в оптимальном расписании были сделаны работы <tex>i_1, i_2, \ldots, i_k</tex>. Докажем, что существует <br />
оптимальное расписание, в котором сделаны работы <tex>1, 2, \ldots, k</tex>. Пусть работы <tex>i_1, i_2, \ldots, i_k</tex><br />
тоже отсортированы в порядке неубывания дедлайна. Тогда <tex>d_{i1} \le d_1, d_{i2}\le d_2, \ldots, d_{ik}\le d_{k}</tex>.<br />
Тогда, если заменить во всём расписании работу <tex>i_j</tex> на работу <tex>j</tex>, то она, тем более, будет выполнена.<br />
}}<br />
<br />
{{Определение<br />
|definition=Обозначим за ''тайм-слот t'' множество из не более, чем <tex>m</tex> различных чисел {{---}} <br />
номера работ, которые мы хотим выполнить в момент времени <tex>t</tex>.<br />
}}<br />
<br />
Введем тайм-слот для каждого момента времени от <tex>0</tex> до <tex>d_n</tex>.<br />
Каждую работу будем пытаться сделать как можно позже. Будем рассматривать работы в порядке невозрастания дедлайнов. <br />
<tex>i</tex>-ю работу попытаемся добавить в тайм-слоты с номерами от <tex>d_i - m + 1</tex> по <tex>d_i</tex>. <br />
После добавления некоторые тайм-слоты могли переполниться (тайм-слот переполнился, если в нём уже находилось<br />
<tex>m</tex> работ, и в него добавили <tex>m+1</tex>-ю). <br />
Для переполнившегося тайм-слота найдём найдем самый правый левее него тайм-слот, который ещё не переполнился и перекинем работу, <br />
которой там еще нет, в него. Так как в нем меньше элементов, то, по принципу Дирихле, это можно сделать. <br />
<br />
{{Утверждение<br />
|statement=Следуя этому алгоритму, расписания не существует тогда и только тогда, когда<br />
переполнился нулевой тайм-слот.<br />
|proof=<br />
<tex>\Rightarrow</tex><br />
Расписания не существует, а значит, никакой алгоритм его не найдет.<br />
<br />
<tex>\Leftarrow</tex><br />
Введем понятие ''фронта'' расписания. ''Фронтом'' назовем вектор размеров тайм-слотов. Заметим, что от того, в каком порядке происходят перебрасывания из переполнившихся тайм-слотов, итоговый фронт не зависит. Поэтому, если мы сначала положим все работы в тайм-слоты, игнорируя ограничение на их размер, а потом в каком-то порядке перекинем, итоговый фронт окажется тем же. В случае, если при построении тайм-слотов игнорировалось ограничение на их размер, ни одну единицу работы нельзя назначить позже.<br />
<br />
Будем также рассматривать тайм-слоты без номеров работ: в каждом тайм-слоте просто лежит сколько-то единиц работ. От этого итоговый фронт также не изменится. Заметим, что если нельзя составить корректную в плане наполненности конфигурацию тайм-слотов при данном ослаблении, то нельзя это сделать и в случае существования номера у каждой единицы работы. Будем рассматривать тайм-слоты по убыванию времени с <tex>d_1</tex> до <tex>0</tex>. В каждый момент времени будем хранить сколько работ ''необходимо'' перекинуть на более ранние тайм-слоты. Изначально это число равно нулю.<br />
<br />
Рассмотрим очередной тайм-слот. Пусть в нем занято <tex>h</tex> ячеек из <tex>m</tex>, а также, есть еще <tex>a</tex> нераспределяемых позже единиц работы. Здесь возможны два случая:<br />
* <tex>h + a > m</tex>. В этом случае, так как более <tex>m</tex> единиц работы сейчас выполнить нельзя, а также, ничего нельзя назначить позже, то оказывается, что невыполняемых сейчас или позже работ стало <tex>h + a - m</tex>.<br />
* Если <tex>h + a <= m</tex>. Здесь можно назначить все нераспределяемые позже работы на это время, и сбросить их счетчик.<br />
<br />
Так как и этот, и изучаемый алгоритм получают в итоге одинаковый фронт, а в этом мы вышли из нулевого времени, а невыполненные единицы работы остались, то, так как распределить их никак невозможно, то не существует расписания, в котором бы выполнились все работы.<br />
}}<br />
<br />
Опираясь на это утверждение, можно найти максимальное количество работ, которое можно выполнить. Обозначим его за <tex>k</tex>.<br />
<br />
Сведем задачу построения распинания по построенным тайм-слотам к задаче о покрытии двудольного графа минимальным <br />
количеством паросочетаний.<br />
<br />
Построим двудольный граф. В левой доле вершинам будут соответствовать работы, в правой {{---}} времена. Соответственно, в левой доле будет <tex>n</tex> вершин, в правой {{---}} <tex>d_{max}</tex>. Ребро между работой <tex>i</tex> и временем <tex>t</tex> будет, если работа <tex>i</tex> есть в тайм-слоте <tex>t</tex>.<br />
<br />
Рассмотрим какое-то паросочетание <tex>M</tex> в этом графе. Оно соответствует корректному расписанию работ на одной машине: ни одна работа не выполняется два раза, и ни в один момент времени не выполняется более одной работы.<br />
<br />
Тогда, если мы сможем построить множество мощности <tex>m</tex> такое, что каждое ребро находится хотя бы в одном из паросочетаний, то оно будет соответствовать тому, что каждая работа обработана на каждом станке, а значит, составлено корректное расписание для этих <tex>k</tex> работ.<br />
<br />
Достроим граф до регулярного степени <tex>m</tex>. Достраивать будем следующим образом. Каждая вершина в левой доле имеет степень <tex>m</tex>, так как каждая работа представлена в <tex>m</tex> тайм-слотах. В правой доле степень каждой вершины не больше <tex>m</tex>, так как в тайм-слоте не может быть больше, чем <tex>m</tex> работ. Значит, в левой доле не больше вершин, чем в правой.<br />
Добавим в левую долю фиктивных вершин, чтобы количества вершин в левой и правой долях сравнялись. После чего просто будем добавлять ребра между вершинами, степень которых еще меньше <tex>m</tex>. Для покрытия этого графа паросочетаниями воспользуемся тем фактом, что регулярный двудольный граф степени <tex>d</tex> можно покрыть <tex>d</tex> паросочетаниями. <br />
<br />
При помощи построения паросочетаний было построено расписание для тех <tex>k</tex> работ, которые можно успеть сделать. Так как остальные работы уже нельзя успеть, расписание для них можно составить произвольное. Например, выполнять их по очереди после выполнения первых <tex>k</tex> работ.<br />
<br />
==Оценка сложности алгоритма==<br />
Рассмотрим добавление очередной работы в тайм-слоты. За <tex>O(t)</tex> найдём переполнившийся тайм-слот и за <tex>O(m)</tex> перекинем из него элемент. Так как <tex>t=O(nm)</tex>, итоговая сложность этой части {{---}} <tex>O(n^2m)</tex>.<br />
<br />
Достроение графа до регулярного делается за <tex>O(E)</tex>, где <tex>E</tex> {{---}} количество ребер в нем. Количество ребер в регулярном двудольном графе <tex>E = Vd</tex>, где <tex>V</tex> {{---}} количество вершин в одной из долей, а <tex>d</tex> {{---}} степень. Количество вершин в правой доле {{---}} <tex>O(t) = O(nm)</tex>. Значит, граф будет построен за <tex>O(nm^2)</tex>, так как степень каждой вершины {{---}} <tex>m</tex>.<br />
<br />
Сложность последней фазы зависит от того, каким алгоритмом граф разбивается на паросочетания. Использовав, например, алгоритм Куна, можно добиться сложности <tex>O(m \cdot M) = O(m \cdot n^3m^3)</tex>. Итоговая сложность алгоритма {{---}} <tex>O(n^3m^4)</tex>.</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=32650J2pij1Lmax2013-06-21T16:10:00Z<p>GR1n: /* Описание решения */</p>
<hr />
<div>==Условие задачи==<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> \varnothing</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 />
Для доказательство того, что алгоритм решения задачи корректен, необходимо показать то, что он строит достижимое расписание. Это справедливо тогда и только тогда, когда до исполнения строчек (*) и (**) пусты A(t) и B(t) соответственно. Иначе две разные операции будут выполняться в один момент времени на одной машине. Для того, чтобы показать достижимость докажем лемму. <br />
<br />
{{Лемма<br />
|id=lemma6.12 <br />
|statement=Пусть <tex>Y = (A(t), B(t))</tex> — расписание, где <tex>B(t) = \emptyset</tex> <tex>(A(t) = \emptyset)</tex>. Тогда для каждого <tex>s > t</tex>, где <tex>B(s) = O_{ij}</tex> <tex>(A(s) = O_{ij})</tex> выполняется <tex>A(s -1) = O_{i, j - 1}</tex> <tex>(B(s - 1) = O_{i, j -1}))</tex><br />
|proof={{в разработке}}<br />
}}<br />
<br />
{{Теорема<br />
|id=theorem6.13. <br />
|statement=Пусть <tex>O_{ij}</tex> — операция, которую планируют строчкой (*) или (**) и <tex>t = LAST(i) > T1(T2)</tex>. Тогда <tex>A(t) = \emptyset</tex> <tex>(B(t) = \emptyset)</tex><br />
|proof={{в разработке}}<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma6.14 <br />
|statement=Если существует расписание без опозданий, то данный алгоритм построит расписание без опозданий.<br />
|proof={{в разработке}} <br />
}}<br />
<br />
{{Теорема<br />
|id=theorem6.15. <br />
|statement=Расписание, построенное данным алгоритмом, оптимально.<br />
|proof={{в разработке}}<br />
}}<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 180 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=32649J2pij1Lmax2013-06-21T16:08:03Z<p>GR1n: /* Описание решения */</p>
<hr />
<div>==Условие задачи==<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> \varnothing</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 />
Для доказательство того, что алгоритм решения задачи корректен, необходимо показать то, что он строит достижимое расписание. Это справедливо тогда и только тогда, когда до исполнения строчек (*) и (**) пусты A(t) и B(t) соответственно. Иначе две разные операции будут выполняться в один момент времени на одной машине. Для того, чтобы показать достижимость докажем лемму. <br />
<br />
{{Лемма<br />
|id=lemma6.12 <br />
|statement=Пусть <tex>Y = (A(t), B(t))</tex> — расписание, где <tex>B(t) = \emptyset</tex> <tex>(A(t) = \emptyset)</tex>. Тогда для каждого <tex>s > t</tex>, где <tex>B(s) = O_{ij}</tex> <tex>(A(s) = O_{ij})</tex> выполняется <tex>A(s -1) = O_{i, j - 1}</tex> <tex>(B(s - 1) = O_{i, j -1}))</tex><br />
|proof={{в разработке}}<br />
}}<br />
<br />
{{Теорема<br />
|id=theorem6.13. <br />
|statement=Пусть <tex>O_{ij}</tex> — операция, которую планируют строчкой (*) или (**) и <tex>t = LAST(i) > T1(T2)</tex>. Тогда <tex>A(t) = \emptyset</tex> <tex>(B(t) = \emptyset)</tex><br />
|proof={{в разработке}}<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma6.14 <br />
|statement=Если существует расписание без опозданий, то данный алгоритм построит расписание без опозданий.<br />
|proof={{в разработке}} <br />
}}<br />
<br />
{{Теорема<br />
|id=theorem6.15. <br />
|statement=Расписание, построенное данным алгоритмом, оптимально.<br />
|proof={{в разработке}}<br />
}}<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 180 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=J2pij1Lmax&diff=32648J2pij1Lmax2013-06-21T16:05:33Z<p>GR1n: /* Описание решения */</p>
<hr />
<div>==Условие задачи==<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> \varnothing</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 />
Для доказательство того, что алгоритм решения задачи корректен, необходимо показать то, что он строит достижимое расписание. Это справедливо тогда и только тогда, когда до исполнения строчек (*) и (**) пусты A(t) и B(t) соответственно. Иначе две разные операции будут выполняться в один момент времени на одной машине. Для того, чтобы показать достижимость докажем лемму. <br />
<br />
{{Лемма<br />
|id=lemma6.12 <br />
|statement=Пусть <tex>Y = (A(t), B(t))</tex> — расписание, где <tex>B(t) = \emptyset</tex> <tex>(A(t) = \emptyset)</tex>. Тогда для каждого <tex>s > t</tex>, где <tex>B(s) = O_{ij}</tex> <tex>(A(s) = O_{ij})</tex> выполняется <tex>A(s -1) = O_{i, j - 1}</tex> <tex>(B(s - 1) = O_{i, j -1}))</tex><br />
|proof={{в разработке}}<br />
}}<br />
<br />
{{Теорема<br />
|id=theorem6.13. <br />
|statement=Пусть <tex>O_{ij}</tex> — операция, которую планируют строчкой (*) или (**) и <tex>t = LAST(i) > T1(T2)</tex>. Тогда <tex>A(t) = \emptyset</tex> <tex>(B(t) = \emptyset)</tex><br />
|proof={{в разработке}}<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma6.14 <br />
|statement=Если существует расписание без опозданий, то данный алгоритм построит расписание без опозданий.<br />
|proof={{в разработке}} <br />
}}<br />
<br />
{{Теорема<br />
|id=theorem6.15. <br />
|statement=Расписание, построенное данным алгоритмом, оптимально.<br />
|proof={{в разработке}}<br />
}}<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 180 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=32615F2Cmax2013-06-18T17:18:25Z<p>GR1n: </p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец списка <tex> L </tex>, иначе ставим в начало списка <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим список <tex> T = L \circ R</tex>. Утверждается, что этот список является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
{{<br />
Теорема|statement=<br />
Существует оптимальное расписание, в котором станки выполняют работы в одном и том же порядке.<br />
<br />
|proof=<br />
[[Файл:f2cmax_first_fixed.png|400px|thumb|right|Рис. 1]]<br />
Предположим обратное, что не существует оптимального расписания с одиннаковыми перестановками работ на станках. Рассмотрим некоторое оптимальное расписание с максимальным по длине общим префиксом на станках. <br />
<br />
Пусть его длина равна <tex> k </tex>, где <tex> k < n </tex>. Пусть на <tex> k </tex> позиции на первом и втором станках стоит работа <tex> i </tex>, а на втором станке на позиции <tex> k + 1 </tex> стоит работа <tex> j </tex>. Тогда заметим, что если мы поставим работу <tex> j </tex> на первом станке сразу после работы <tex> i </tex>, то последовательные работы с <tex> h </tex> по <tex> m </tex> (см. Рис. 1) по-прежнему будут успевать выполниться, так как на втором станке они выполняются в текущем расписании после <tex> j </tex>. Таким образом нам удалось увеличить длину наибольшего общего префикса, а так как по нашему предположению она была максимальна, то наше предположение неверно, то искомое расписание с одиннаковым порядком выполнения работ на обоих станках существует.<br />
}}<br />
<br />
Таким образом задача сводится к поиску этой искомой перестановки. Докажем, что полученный нашим алгоритмом список является отпимальной перестановкой работ. <br />
<br />
{{лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких-то работ <tex> i </tex> и <tex> j </tex> из списка <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в списке <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже (в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеем произвольное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшения целевой функции. <br />
|proof=<br />
[[Файл:f2cmax_fixed.png|400px|thumb|right|Рис. 2 - Расположение последовательных работ]]<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
Рассмотрим возможные случаи расположения работ <tex> i </tex> и <tex> j </tex> (см. Рис. 2)<br />
<ol><br />
<li>Работа <tex> i </tex> начинается на втором станке сразу же после завершения ее на первом<br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{i2} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
<li>Работа <tex> i </tex> не может начаться на втором станке сразу же после завершения ее на первом <br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае снова имеем <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. Пусть <tex> delta </tex> {{---}} время прошедшее с начала выполнения работы <tex> i</tex> на первом станке и до начала ее выполнения на втором станке. Тогда имеем, что <tex> w_{ij} = delta + p_{i2} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
</ol><br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим произвольную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=32612F2Cmax2013-06-18T17:00:14Z<p>GR1n: </p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец списка <tex> L </tex>, иначе ставим в начало списка <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим список <tex> T = L \circ R</tex>. Утверждается, что этот список является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
{{<br />
Теорема|statement=<br />
Существует оптимальное расписание, в котором станки выполняют работы в одном и том же порядке.<br />
<br />
|proof=<br />
[[Файл:f2cmax_first_fixed.png|400px|thumb|right|Рис. 1]]<br />
Предположим обратное, что не существует оптимального расписания с одиннаковыми перестановками работ на станках. Рассмотрим некоторое оптимальное расписание с максимальным по длине общим префиксом на станках. <br />
<br />
Пусть его длина равна <tex> k </tex>, где <tex> k < n </tex>. Пусть на <tex> k </tex> позиции на первом и втором станках стоит работа <tex> i </tex>, а на втором станке на позиции <tex> k + 1 </tex> стоит работа <tex> j </tex>. Тогда заметим, что если мы поставим работу <tex> j </tex> на первом станке сразу после работы <tex> i </tex>, то последовательные работы с <tex> h </tex> по <tex> m </tex> (см. Рис. 1) по-прежнему будут успевать выполниться, так как на втором станке они выполняются в текущем расписании после <tex> j </tex>. Таким образом нам удалось увеличить длину наибольшего общего префикса, а так как по нашему предположению она была максимальна, то наше предположение неверно, то искомое расписание с одиннаковым порядком выполнения работ на обоих станках существует.<br />
}}<br />
<br />
Таким образом задача сводится к поиску этой искомой перестановки. Докажем, что полученный нашим алгоритмом список является отпимальной перестановкой работ. <br />
<br />
{{лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из списка <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в списке <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже (в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функции. <br />
|proof=<br />
[[Файл:f2cmax_fixed.png|400px|thumb|right|Рис. 2 - Расположение последовательных работ]]<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
Рассмотрим возможные случаи расположения работ <tex> i </tex> и <tex> j </tex> (см. Рис. 2)<br />
<ol><br />
<li>Работа <tex> i </tex> начинается на втором станке сразу же после завершения ее на первом<br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{i2} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
<li>Работа <tex> i </tex> не может начаться на втором станке сразу же после завершения ее на первом <br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае снова имеем <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. Пусть <tex> delta </tex> {{---}} время прошедшее с начала выполнения работы <tex> i</tex> на первом станке и до начала ее выполнения на втором станке. Тогда имеем, что <tex> w_{ij} = delta + p_{i2} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
</ol><br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим произвольную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=32611F2Cmax2013-06-18T16:55:35Z<p>GR1n: </p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец списка <tex> L </tex>, иначе ставим в начало списка <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим список <tex> T = L \circ R</tex>. Утверждается, что этот список является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
{{<br />
Теорема|statement=<br />
Существует оптимальное расписание, в котором станки выполняют работы в одном и том же порядке.<br />
<br />
|proof=<br />
[[Файл:f2cmax_first_fixed.png|400px|thumb|right|Рис. 1]]<br />
Предположим обратное, что не существует оптимального расписания с одиннаковыми перестановками работ на станках. Рассмотрим некоторое оптимальное расписание с максимальным по длине общим префиксом на станках. <br />
<br />
Пусть его длина равна <tex> k </tex>, где <tex> k < n </tex>. Пусть на <tex> k </tex> позиций на первом и втором станках стоит работа <tex> i </tex>, а на втором станке на позиций <tex> k + 1 </tex> стоит работа <tex> j </tex>. Тогда заметим, что если мы поставим работу <tex> j </tex> на первом станке сразу после работы <tex> i </tex>, то последовательные работы с <tex> h </tex> по <tex> m </tex> (см. Рис. 1) по-прежнему будут успевать выполниться, так как на втором станке они выполняются в текущем расписаний после <tex> j </tex>. Таким образом нам удалось увеличить длину наибольшего общего префикса, а так как по нашему предположению она была максимальна, то наше предположение неверно, то искомое расписание с одиннаковым порядком выполнения работ на обоих станках существует.<br />
}}<br />
<br />
Таким образом задача сводится к поиску этой искомой перестановки. Докажем, что полученный нашим алгоритмом список является отпимальной перестановкой работ. <br />
<br />
{{лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из списка <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в списке <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже (в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
[[Файл:f2cmax_fixed.png|400px|thumb|right|Рис. 2 - Расположение последовательных работ]]<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
Рассмотрим возможные случаи расположения работ <tex> i </tex> и <tex> j </tex> (см. Рис. 2)<br />
<ol><br />
<li>Работа <tex> i </tex> начинается на втором станке сразу же после завершения ее на первом<br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{i2} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
<li>Работа <tex> i </tex> не может начаться на втором станке сразу же после завершения ее на первом <br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае снова имеем <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. Пусть <tex> delta </tex> {{---}} время прошедшее с начала выполнения работы <tex> i</tex> на первом станке и до начала ее выполнения на втором станке. Тогда имеем, что <tex> w_{ij} = delta + p_{i2} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
</ol><br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=32541F2Cmax2013-06-16T16:53:06Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
{{<br />
Теорема|statement=<br />
Существует оптимальное расписание, в котором станки выполняют работы в одном и том же порядке.<br />
<br />
|proof=<br />
[[Файл:f2cmax_first_fixed.png|400px|thumb|right|Рис. 1]]<br />
Предположим обратное, что не существует оптимального расписания с одиннаковыми перестановками работ на станках. Рассмотрим некоторое оптимальное расписание с максимальным по длине общим префиксом на станках. <br />
<br />
Пусть его длина равна <tex> k </tex>, где <tex> k < n </tex>. Пусть на <tex> k </tex> позиций на первом и втором станках стоит работа <tex> i </tex>, а на втором станке на позиций <tex> k + 1 </tex> стоит работа <tex> j </tex>. Тогда заметим, что если мы поставим работу <tex> j </tex> на первом станке сразу после работы <tex> i </tex>, то последовательные работы с <tex> h </tex> по <tex> m </tex> (см. Рис. 1) по-прежнему будут успевать выполниться, так как на втором станке они выполняются в текущем расписаний после <tex> j </tex>. Таким образом нам удалось увеличить длину наибольшего общего префикса, а так как по нашему предположению она была максимальна, то наше предположение неверно, то искомое расписание с одиннаковым порядком выполнения работ на обоих станках существует.<br />
}}<br />
<br />
Таким образом задача сводится к поиску этой искомой перестановки. Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
<br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже (в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
[[Файл:f2cmax_fixed.png|400px|thumb|right|Рис. 2 - Расположение последовательных работ]]<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
Рассмотрим возможные случаи расположения работ <tex> i </tex> и <tex> j </tex> (см. Рис. 2)<br />
<ol><br />
<li>Работа <tex> i </tex> начинается на втором станке сразу же после завершения ее на первом<br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{i2} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
<li>Работа <tex> i </tex> не может начаться на втором станке сразу же после завершения ее на первом <br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае снова имеем <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. Пусть <tex> delta </tex> {{---}} время прошедшее с начала выполнения работы <tex> i</tex> на первом станке и до начала ее выполнения на втором станке. Тогда имеем, что <tex> w_{ij} = delta + p_{i2} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
</ol><br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=32540F2Cmax2013-06-16T16:51:48Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
{{<br />
Теорема|statement=<br />
Существует оптимальное расписание, в котором станки выполняют работы в одном и том же порядке.<br />
<br />
|proof=<br />
[[Файл:f2cmax_first_fixed.png|400px|thumb|right|Рис. 1]]<br />
Предположим обратное, что не существует оптимального расписания с одиннаковыми перестановками работ на станках. Рассмотрим некоторое оптимальное расписание с максимальным по длине общим префиксом на станках. <br />
<br />
Пусть его длина равна <tex> k </tex>, где <tex> k < n </tex>. Пусть на <tex> k </tex> позиций на первом и втором станках стоит работа <tex> i </tex>, а на втором станке на позиций <tex> k + 1 </tex> стоит работа <tex> j </tex>. Тогда заметим, что если мы поставим работу <tex> j </tex> на первом станке сразу после работы <tex> i </tex>, то последовательные работы с <tex> h </tex> по <tex> m </tex> (см. Рис. 1) по-прежнему будут успевать выполниться, так как на втором станке они выполняются в текущем расписаний после <tex> j </tex>. Таким образом нам удалось увеличить длину наибольщего общего префикса, а так как по нашему предположению она была максимальна, то наше предположение неверно, то искомое расписание с одиннаковым порядком выполнения работ на обоих станках существует.<br />
}}<br />
<br />
Таким образом задача сводится к поиску этой искомой перестановки. Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже (в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
[[Файл:f2cmax_fixed.png|400px|thumb|right|Рис. 2 - Расположение последовательных работ]]<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
Рассмотрим возможные случаи расположения работ <tex> i </tex> и <tex> j </tex> (см. Рис. 2)<br />
<ol><br />
<li>Работа <tex> i </tex> начинается на втором станке сразу же после завершения ее на первом<br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{i2} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
<li>Работа <tex> i </tex> не может начаться на втором станке сразу же после завершения ее на первом <br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае снова имеем <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. Пусть <tex> delta </tex> {{---}} время прошедшее с начала выполнения работы <tex> i</tex> на первом станке и до начала ее выполнения на втором станке. Тогда имеем, что <tex> w_{ij} = delta + p_{i2} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
</ol><br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=32539F2Cmax2013-06-16T16:50:54Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
{{<br />
Теорема|statement=<br />
Существует оптимальное расписание, в котором станки выполняют работы в одном и том же порядке.<br />
<br />
|proof=<br />
[[Файл:f2cmax_first_fixed.png|400px|thumb|right|Рис. 1]]<br />
Предположим обратное, что не существует оптимального расписания с одиннаковыми перестановками работ на станках. Рассмотрим некоторое оптимальное расписание с максимальным по длине общим префиксом на станках. <br />
<br />
Пусть его длина равна <tex> k </tex>, где <tex> k < n </tex>. Пусть на <tex> k </tex> позиций на первом и втором станках стоит работа <tex> i </tex>, а на втором станке на позиций <tex> k + 1 </tex> стоит работа <tex> j </tex>. Тогда заметим, что если мы поставим работу <tex> j </tex> на первом станке сразу после работы <tex> i </tex>, то работы <tex> h </tex> по <tex> m </tex> (см. Рис. 1) по-прежнему будут успевать выполниться, так как на втором станке они выполняются в текущем расписаний после <tex> j </tex>. Таким образом нам удалось увеличить длину наибольщего общего префикса, а так как по нашему предположению она была максимальна, то наше предположение неверно, то искомое расписание с одиннаковым порядком выполнения работ на обоих станках существует.<br />
}}<br />
<br />
Таким образом задача сводится к поиску этой искомой перестановки. Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже (в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
[[Файл:f2cmax_fixed.png|400px|thumb|right|Рис. 2 - Расположение последовательных работ]]<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
Рассмотрим возможные случаи расположения работ <tex> i </tex> и <tex> j </tex> (см. Рис. 2)<br />
<ol><br />
<li>Работа <tex> i </tex> начинается на втором станке сразу же после завершения ее на первом<br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{i2} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
<li>Работа <tex> i </tex> не может начаться на втором станке сразу же после завершения ее на первом <br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае снова имеем <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. Пусть <tex> delta </tex> {{---}} время прошедшее с начала выполнения работы <tex> i</tex> на первом станке и до начала ее выполнения на втором станке. Тогда имеем, что <tex> w_{ij} = delta + p_{i2} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
</ol><br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:F2cmax_first_fixed.png&diff=32538Файл:F2cmax first fixed.png2013-06-16T16:44:34Z<p>GR1n: </p>
<hr />
<div></div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:F2cmax_first.png&diff=32537Файл:F2cmax first.png2013-06-16T16:39:26Z<p>GR1n: </p>
<hr />
<div></div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=32536F2Cmax2013-06-16T16:12:06Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
{{<br />
Теорема|statement=<br />
Существует оптимальное расписание, в котором станки выполняют работы в одном и том же порядке.<br />
<br />
|proof=<br />
<br />
TODO<br />
}}<br />
<br />
Таким образом задача сводится к поиску этой искомой перестановки. Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже (в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
[[Файл:f2cmax_fixed.png|400px|thumb|right|Рис. 1 - Расположение последовательных работ]]<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
Рассмотрим возможные случаи расположения работ <tex> i </tex> и <tex> j </tex> (см. Рис. 1)<br />
<ol><br />
<li>Работа <tex> i </tex> начинается на втором станке сразу же после завершения ее на первом<br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{i2} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
<li>Работа <tex> i </tex> не может начаться на втором станке сразу же после завершения ее на первом <br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае снова имеем <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. Пусть <tex> delta </tex> {{---}} время прошедшее с начала выполнения работы <tex> i</tex> на первом станке и до начала ее выполнения на втором станке. Тогда имеем, что <tex> w_{ij} = delta + p_{i2} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
</ol><br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31760F2Cmax2013-06-11T11:10:43Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
TODO Доказательство равенства перестановок на первом и втором станках<br />
<br />
Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже (в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
[[Файл:f2cmax_fixed.png|400px|thumb|right|Рис. 1 - Расположение последовательных работ]]<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
Рассмотрим возможные случаи расположения работ <tex> i </tex> и <tex> j </tex> (см. Рис. 1)<br />
<ol><br />
<li>Работа <tex> i </tex> начинается на втором станке сразу же после завершения ее на первом<br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{i2} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
<li>Работа <tex> i </tex> не может начаться на втором станке сразу же после завершения ее на первом <br />
<ul><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается раньше, чем работы <tex> j </tex> на первом. В этом случае снова имеем <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li> Выполнение работы <tex> i </tex> на втором станке заканчивается позже, чем работы <tex> j </tex> на первом. Пусть <tex> delta </tex> {{---}} время прошедшее с начала выполнения работы <tex> i</tex> на первом станке и до начала ее выполнения на втором станке. Тогда имеем, что <tex> w_{ij} = delta + p_{i2} + p_{j2} </tex>. </li><br />
</ul><br />
</li><br />
</ol><br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:F2cmax_fixed.png&diff=31759Файл:F2cmax fixed.png2013-06-11T10:58:25Z<p>GR1n: </p>
<hr />
<div></div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31758F2Cmax2013-06-11T10:50:35Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
TODO Доказательство равенства перестановок на первом и втором станках<br />
<br />
Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже (в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
[[Файл:f2cmax.png|400px|thumb|right|Рис. 1 - Расположение последовательных работ]]<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
Рассмотрим возможные случаи расположения работ <tex> i </tex> и <tex> j </tex> (см. Рис. 1):<br />
<ol><br />
<li>В этом случае <tex> w_{ij} = p_{i1} + p_{i2} + p_{j2} </tex>.</li><br />
<li>В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li>В этом случае <tex> w_{ij} = p_{i1} + p_{j1} + p_{j2} </tex>.</li><br />
<li>В этом случае <tex> w_{ij} = delta + p_{i2} + p_{j2} </tex>.</li><br />
<br />
</ol><br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%B0%D0%B9%D0%BB:F2cmax.png&diff=31757Файл:F2cmax.png2013-06-11T10:43:31Z<p>GR1n: </p>
<hr />
<div></div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31626F2Cmax2013-06-10T17:59:09Z<p>GR1n: </p>
<hr />
<div><div style="background-color: #ABCDEF; font-size: 16px; font-weight: bold; color: #000000; text-align: center; padding: 4px; border-style: solid; border-width: 1px;">Эта статья находится в разработке!</div><br />
<includeonly>[[Категория: В разработке]]</includeonly><br />
<br />
== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
TODO Доказательство равенства перестановок на первом и втором станках<br />
<br />
Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже( в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
...<br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31625F2Cmax2013-06-10T17:58:09Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
TODO Доказательство равенства перестановок на первом и втором станках<br />
<br />
Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже( в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
...<br />
<br />
Таким образом, <tex> w_{ij} = \max (p_{i1} + p_{j1} + p_{j2}, p_{i1} + p_{i2} + p_{j2}, delta + p_{i2} + p_{j2}) </tex>. Иначе говоря <tex> w_{ij} = \max (p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2}, delta + p_{i2} + p_{j2}) </tex>.<br />
<br />
Аналогично имеем, что <tex> w_{ji} = \max (p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2}, delta + p_{i2} + p_{j2}) </tex><br />
<br />
Так как <tex> \min(a, b) = - \max(-a, -b)</tex>, то из условию леммы имеем <tex> \max(-p_{i1}, -p_{j2}) \leq \max(-p_{j1}, -p_{i2}) </tex>, то добавим <tex> p_{i1} + p_{i2} + p_{j1} + p_{j2} </tex> к обеим частям. То получим, что <tex> p_{j1} + \max(p_{i1}, p_{j2}) + p_{i2} \leq p_{i1} + \max(p_{j1}, p_{i2}) + p_{j2} </tex>, то есть <tex> w_{ji} \leq w_{ij} </tex>, то при смене местами работ <tex> i </tex> и <tex> j </tex> ответ не ухудшается. <br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31619F2Cmax2013-06-10T17:39:55Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
TODO Доказательство равенства перестановок на первом и втором станках<br />
<br />
Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже( в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
Пусть <tex> w_{ij} </tex> {{---}} время, прошедшее с начала выполнения работы <tex> i </tex> на первом станке до окончания работы <tex> j </tex> на втором станке. <br />
<br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31618F2Cmax2013-06-10T17:26:34Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
TODO Доказательство равенства перестановок на первом и втором станках<br />
<br />
Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже( в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
TODO<br />
<br />
}}<br />
<br />
<br />
{{<br />
Теорема|statement=<br />
Построенная перестановка <tex> T </tex> является оптимальной. <br />
<br />
|proof=<br />
Рассмотрим случайную перестановку <tex> S </tex>. Пусть перестановки <tex> T </tex> и <tex> S </tex> имеют общий префикс длины <tex> l-1 </tex>. Пусть <tex> i = T_{l} </tex> и <tex> j = S_{l} </tex>. Рассмотрим множество работ <tex>M = \{T_{r} \mid r = l, \dots, n\}</tex>. Заметим, что для любой работы <tex> k \in M </tex> верно, что <tex> \min(p_{k1}, p_{i2}) \geq \min(p_{i1}, p_{k2}) </tex>, так как если было бы верно обратное, то есть <tex> \min(p_{k1}, p_{i2}) < \min(p_{i1}, p_{k2}) </tex>, то по Лемме 1 было бы верно, что <tex> k </tex> идет раньше <tex> i </tex>, что неверно. <br />
<br />
Очевидно, что в перестановке <tex> S </tex> работа <tex> i </tex> будет стоять после <tex> j </tex> (иначе общий префикс был бы короче), то заметим, что в этой перестановке для работы <tex> i </tex> и для предыдущей работы <tex> w </tex> верно <tex> \min(p_{w1}, p_{i2}) \geq \min(p_{i1}, p_{w2}) </tex> (так как <tex> w \in M </tex>), то по Лемме 2 можем поменять местами работы <tex> i </tex> и <tex> w </tex> без ухудшения ответа. То такими операциями сможем дойти до пары работ <tex> i </tex> и <tex> j </tex>, которые при смене увеличат общий префикс перестановок <tex> S </tex> и <tex> T </tex>. <br />
<br />
Таким образом любая перестановка сводится к нашей без ухудшения ответа такими операциями, что подтверждает оптимальность перестановки <tex> T </tex><br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31599F2Cmax2013-06-10T16:51:46Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
TODO Доказательство равенства перестановок на первом и втором станках<br />
<br />
Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже( в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
TODO<br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31598F2Cmax2013-06-10T16:50:51Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже( в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
{{Лемма<br />
|id=lemma2<br />
|about=2<br />
|statement= Пусть имеет случайное расписание, в котором работа <tex> j </tex> идет сразу же после работы <tex> i </tex>. Тогда если <tex> \min(p_{j1}, p_{i2}) \leq \min(p_{i1}, p_{j2}) </tex>, то можем поменять местами эти работы без ухудшение целевой функций. <br />
|proof=<br />
TODO<br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31594F2Cmax2013-06-10T16:44:55Z<p>GR1n: /* Доказательство корректности алгоритма */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
Докажем, что полученный нашим алгоритмом лист является отпимальной перестановкой работ. <br />
{{Лемма<br />
|id=lemma1<br />
|about=1<br />
|statement= Если для каких работ <tex> i </tex> и <tex> j </tex> из листа <tex> T </tex> верно неравенство <tex> \min(p_{i1}, p_{j2}) < \min(p_{j1}, p_{i2}) </tex>, то работа <tex> i </tex> встречается в листе <tex> T </tex> раньше, чем <tex> j </tex><br />
|proof=<br />
Пусть <tex> p_{i1} < p_{j2} </tex>. Случай <tex> p_{i1} > p_{j2} </tex> рассматривается аналогично. <br />
<br />
То есть имеем, что <tex> p_{i1} < \min(p_{j1}, p_{i2}) </tex>. Так как <tex> p_{i1} < \min(p_{j1}, p_{i2}) \leq p_{i2} </tex>, то работа <tex> i \in L </tex>. Работа <tex> j </tex> либо стоит в <tex> R </tex>, либо она стоит в <tex> L </tex> и при этом <tex> p_{i1} < p_{j1} </tex>. Заметим, что в обоих случаях она расположена позже( в силу нашего построения), чем работа <tex> i </tex>, то лемма доказана. <br />
<br />
}}<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31584F2Cmax2013-06-10T16:10:40Z<p>GR1n: /* Сложность алгоритма */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
Заметим, что на каждом шаге алгоритма мы выбираем минимум из оставшихся элементов за <tex>O(\log n)</tex> (либо предварительной сортировкой, либо любой структурой данных, поддеживающей нахождение минимума и удаление за <tex>O(\log n)</tex>). И делаем мы это <tex> n </tex> раз, следовательно алгоритм работает за <tex>O(n\log n)</tex>.<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31580F2Cmax2013-06-10T15:57:44Z<p>GR1n: /* Псевдокод */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
<br />
==Псевдокод==<br />
<tex>L \leftarrow \varnothing </tex><br />
<tex>R \leftarrow \varnothing </tex><br />
<tex>X \leftarrow \{1, \dots, n\}</tex><br />
while <tex> X \neq \varnothing</tex><br />
Найти <tex> i </tex> и <tex> j </tex>, где <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex><br />
if j = 1<br />
<tex>L \leftarrow L \circ i </tex><br />
else <br />
<tex>R \leftarrow i \circ R </tex><br />
<tex>X \leftarrow X \setminus \{i\} </tex><br />
<tex>T \leftarrow L \circ R</tex><br />
<br />
Расставляем работы на первом станке согласно перестановке <tex> T </tex><br />
<br />
Расставляем работы на втором станке согласно перестановке <tex> T </tex><br />
и времени начала соответсвующей работы на первом станке.<br />
<br />
==Сложность алгоритма==<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31567F2Cmax2013-06-10T15:38:56Z<p>GR1n: /* Описание алгоритма */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то поставим работу <tex> i </tex> в конец листа <tex> L </tex>, иначе ставим в начало листа <tex> R </tex> </li><br />
<li>Удаляем работу <tex> i </tex> из множества <tex> X </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L \circ R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
<br />
==Псевдокод==<br />
<br />
==Сложность алгоритма==<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31564F2Cmax2013-06-10T15:32:17Z<p>GR1n: /* Описание алгоритма */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
Пусть <tex>p_{i1}</tex> {{---}} время выполнения <tex>i</tex>-ой работы на первом станке, а <tex>p_{i2}</tex> {{---}} на втором.<br/><br />
<ol><br />
<li>Будем в ходе нашего алгоритма строить два списка <tex> L </tex> и <tex> R </tex>. Изначально оба списка пусты. И будем поддерживать множество еще не распределенных по спискам <tex> L </tex> и <tex> R </tex> работ <tex>X = \{i \mid i = 1, \dots, n\}</tex> </li><br />
<li> Пока множество <tex> X </tex> непусто будем распределять работы по спискам следующим образом:<br />
<ul><br />
<li> Находим такие индексы <tex> i </tex> и <tex> j </tex>, что <tex>p_{ij} = \min \{ p_{ij} \mid i \in X; j = 1, 2\}</tex> </li><br />
<li>Если минимум достигается на первом станке (иными словами <tex> j = 1 </tex>), то допишем работу <tex> i </tex> в конец листа <tex> L </tex>, иначе дописываем в начало листа <tex> R </tex> </li><br />
</ul><br />
</li><br />
<li> Рассмотрим лист <tex> T = L + R</tex>. Утверждается, что этот лист является оптимальной перестановкой работ как на первом, так и на втором станке. Далее расставляем подряд работы на первом станке согласно перестановке, после чего ставим в том же порядке работы на втором стане, при этом избегая одновременного выполнения одной и той же работы. </li><br />
<br />
</ol><br />
<br />
==Доказательство корректности алгоритма==<br />
<br />
==Псевдокод==<br />
<br />
==Сложность алгоритма==<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31556F2Cmax2013-06-10T15:03:44Z<p>GR1n: /* Постановка задачи */</p>
<hr />
<div>== Постановка задачи ==<br />
Рассмотрим задачу:<br />
<ol><br />
<li>Дано <tex>n</tex> работ и <tex>2</tex> станка.</li><br />
<li>Для каждой работы известно её время выполнения на каждом станке.</li><br />
<li>Каждую работу необходимо выполнить сначала на первом станке, а потом на втором.</li><br />
</ol><br />
Требуется минимизировать время окончания всех работ.<br />
<br />
== Описание алгоритма ==<br />
<br />
==Доказательство корректности алгоритма==<br />
<br />
==Псевдокод==<br />
<br />
==Сложность алгоритма==<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=F2Cmax&diff=31554F2Cmax2013-06-10T14:56:22Z<p>GR1n: Новая страница: «== Постановка задачи == == Описание алгоритма == ==Доказательство корректности алгоритма== ...»</p>
<hr />
<div>== Постановка задачи ==<br />
<br />
== Описание алгоритма ==<br />
<br />
==Доказательство корректности алгоритма==<br />
<br />
==Псевдокод==<br />
<br />
==Сложность алгоритма==<br />
<br />
==Источники==<br />
* Peter Brucker. «Scheduling Algorithms» {{---}} «Springer», 2006 г. {{---}} 175 стр. {{---}} ISBN 978-3-540-69515-8<br />
<br />
[[Категория: Дискретная математика и алгоритмы]]<br />
[[Категория: Теория расписаний]]</div>GR1nhttp://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=31553Дискретная математика, алгоритмы и структуры данных2013-06-10T14:52:00Z<p>GR1n: /* Теория расписаний */</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 />
*[[Meet-in-the-middle]]<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 />
* [[Fusion tree]]<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 />
* [[Timsort]]<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 />
* [[Граф блоков-точек сочленения]]<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 />
* [[Алгоритм Дейкстры]]<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 />
* [[Наивный алгоритм поиска подстроки в строке]]<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 />
* [[F2Cmax|<tex>F2 \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>]]<br />
* [[P1sumu|<tex>1 \mid \mid \sum U_{i}</tex>]]</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11848Формула включения-исключения2011-10-25T00:45:46Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A_1| </tex> {{---}} истинно). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} объединение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n | (*)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> B \cap A_n = \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n = \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) (**)</tex><br />
<br />
<br />
Опираясь на предположение индукции и равенство <tex> (**) </tex> имеем, что <tex> |B \cap A_n| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(*)</tex>:<br />
<br />
<br />
<tex> | A | = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex> <tex> =| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex><br />
<br />
<br />
Докажем, что <tex> | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex> = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex><br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex>.<br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex>.<br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно и <tex>|A| = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> .<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11847Формула включения-исключения2011-10-25T00:43:46Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A_1| </tex> {{---}} истинно). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} объединение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n | (*)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> B \cap A_n = \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n = \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) (**)</tex><br />
<br />
<br />
Опираясь на предположение индукции и равенство <tex> (**) </tex> имеем, что <tex> |B \cap A_n| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(*)</tex>:<br />
<br />
<br />
<tex> | A | = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex> <tex> \!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex><br />
<br />
<br />
Докажем, что <tex> | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex> =\! \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex><br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex>.<br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex>.<br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно и <tex>|A| = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> .<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11846Формула включения-исключения2011-10-25T00:41:06Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A_1| </tex> {{---}} истинно). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} объединение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n | (*)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> B \cap A_n = \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n = \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) (**)</tex><br />
<br />
<br />
Опираясь на предположение индукции и равенство <tex> (**) </tex> имеем, что <tex> |B \cap A_n| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(*)</tex>:<br />
<br />
<br />
<tex> | A |\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex> <tex> \!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex><br />
<br />
<br />
Докажем, что <tex> | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex> =\! \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex><br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex>.<br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex>.<br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно и <tex>|A| = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> .<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11845Формула включения-исключения2011-10-25T00:17:57Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} объединение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n | (*)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> B \cap A_n = \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n = \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) (**)</tex><br />
<br />
<br />
Опираясь на предположение индукции и равенство <tex> (**) </tex> имеем, что <tex> |B \cap A_n| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(*)</tex>:<br />
<br />
<br />
<tex> | A |\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex> <tex> \!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex><br />
<br />
<br />
Докажем, что <tex> | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex> =\! \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex><br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex>.<br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex>.<br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно и <tex>|A| = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> .<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11844Формула включения-исключения2011-10-25T00:16:58Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n | (*)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> B \cap A_n = \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n = \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) (**)</tex><br />
<br />
<br />
Опираясь на предположение индукции и равенство <tex> (**) </tex> имеем, что <tex> |B \cap A_n| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(*)</tex>:<br />
<br />
<br />
<tex> | A |\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex> <tex> \!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex><br />
<br />
<br />
Докажем, что <tex> | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex> =\! \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex><br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex>.<br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex>.<br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно и <tex>|A| = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> .<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11842Формула включения-исключения2011-10-24T23:49:52Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n | (*)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(*)</tex>:<br />
<br />
<br />
<tex> | A |\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex> <tex> \!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex><br />
<br />
<br />
Докажем, что <tex> | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex> =\! \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex><br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex>.<br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex>.<br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно и <tex>|A| = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> .<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11834Формула включения-исключения2011-10-24T23:35:40Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n | (*)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(*)</tex>:<br />
<br />
<br />
<tex> | A |\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex><br />
<br />
В силу того, что <tex> - \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| = \ \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \</tex><br />
<br />
Имеем в предыдущей формуле<br />
<br />
<tex> | A |\!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
= </tex><tex> \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> . <br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex>.<br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex>.<br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно.<br />
<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11832Формула включения-исключения2011-10-24T23:31:10Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n |(1)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(1)</tex>:<br />
<br />
<br />
<tex> | A |\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex><br />
<br />
В силу того, что <tex> - \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| = \ \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \</tex><br />
<br />
Имеем в предыдущей формуле<br />
<br />
<tex> | A |\!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
= </tex><tex> \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> . <br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex>.<br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex>.<br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно.<br />
<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11831Формула включения-исключения2011-10-24T23:27:46Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n |(1)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(1)</tex>:<br />
<br />
<br />
<tex> | A |\!\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex><br />
<br />
В силу того, что <tex> - \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| = \ \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \</tex><br />
<br />
Имеем в предыдущей формуле<br />
<br />
<tex> | A |\!\!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex>= \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> . <br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex>.<br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex>.<br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно.<br />
<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11830Формула включения-исключения2011-10-24T23:27:07Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n |(1)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(1)</tex>:<br />
<br />
<br />
<tex> | A |\!\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex><br />
<br />
В силу того, что <tex> - \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| = \ \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \</tex><br />
<br />
Имеем в предыдущей формуле<br />
<br />
<tex> | A |\!\!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex>= \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> . <br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на две группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex><br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex><br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно.<br />
<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11829Формула включения-исключения2011-10-24T23:26:50Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n |(1)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(1)</tex>:<br />
<br />
<br />
<tex> | A |\!\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex><br />
<br />
В силу того, что <tex> - \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| = \ \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \</tex><br />
<br />
Имеем в предыдущей формуле<br />
<br />
<tex> | A |\!\!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex>= \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> . <br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на три группы :<br />
<br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex><br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex><br />
<br />
Как видно из равенства, первое и третье слагаемое "отвечают" за вторую группу, а второе слагаемое за первую группу. Значит, равенство истинно.<br />
<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11828Формула включения-исключения2011-10-24T23:24:45Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n |(1)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(1)</tex>:<br />
<br />
<br />
<tex> | A |\!\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex><br />
<br />
В силу того, что <tex> - \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| = \ \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \</tex><br />
<br />
Имеем в предыдущей формуле<br />
<br />
<tex> | A |\!\!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex>= \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> . <br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на три группы :<br />
<br />
# <tex> \{ n \} </tex><br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex><br />
# <tex>\{n\} \cup I</tex>, где <tex>I \in N'</tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex><br />
<br />
Как видно из равенства, каждое слагаемое "отвечает" за соответствующие группы. Значит, равенство истинно.<br />
<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11827Формула включения-исключения2011-10-24T23:13:42Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n |(1)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значения в <tex>(1)</tex>:<br />
<br />
<br />
<tex> | A |\!\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex><br />
<br />
В силу того, что <tex> - \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| = \ \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \</tex><br />
<br />
Имеем в предыдущей формуле<br />
<br />
<tex> | A |\!\!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex>= \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> . <br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на три группы :<br />
<br />
# <tex> \{ n \} </tex><br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex><br />
# <tex> \{ n \} \cup I \in 2^{N'} </tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex><br />
<br />
Как видно из равенства, каждое слагаемое "отвечает" за соответствующие группы. Значит, равенство истинно.<br />
<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11826Формула включения-исключения2011-10-24T23:11:46Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n |(1)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значение в <tex>(1)</tex>:<br />
<br />
<br />
<tex> | A |\!\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex><br />
<br />
В силу того, что <tex> - \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| = \ \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \</tex><br />
<br />
Имеем в предыдущей формуле<br />
<br />
<tex> | A |\!\!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex>= \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> . <br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на три группы :<br />
<br />
# <tex> \{ n \} </tex><br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex><br />
# <tex> \{ n \} \cup I \in 2^{N'} </tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex><br />
<br />
Как видно из равенства, каждое слагаемое "отвечает" за соответствующие группы. Значит, равенство истинно.<br />
<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1nhttp://neerc.ifmo.ru/wiki/index.php?title=%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D0%B0_%D0%B2%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F-%D0%B8%D1%81%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%BD%D0%B8%D1%8F&diff=11825Формула включения-исключения2011-10-24T23:10:38Z<p>GR1n: </p>
<hr />
<div>'''Формула включения–исключения''' {{---}} это комбинаторная формула, которая позволяет определить мощность объединения конечных множеств, если известны их мощности и мощности всех их возможных пересечений.<br />
<br />
[[Файл:пересечение двух множеств.svg.png|thumb|right|Случай для двух множеств]]<br />
<br />
Например, в случае двух множеств <tex>~A, B</tex> формула включения{{---}}исключения имеет вид:<br />
<center><br />
<tex> | A \cup B | = | A | + | B | - | A \cap B |</tex><br />
</center><br />
В сумме <tex>~| A | + | B |</tex> элементы пересечения <tex>A \cap B</tex> учтены дважды, и, чтобы компенсировать это, мы вычитаем <tex> | A \cap B |</tex> из правой части формулы. Справедливость этого рассуждения видна из диаграммы Эйлера–Венна для двух множеств, приведенной на рисунке справа.<br />
<br />
Таким же образом и в случае <tex>~n>2</tex> множеств процесс нахождения количества элементов объединения <tex>A_1 \cup A_2 \cup \ldots \cup A_n</tex> состоит во включении всего, затем исключении лишнего, затем включении ошибочно исключенного и так далее, то есть в попеременном включении и исключении. Отсюда и происходит название формулы.<br />
<br />
{{Теорема <br />
|statement=Пусть <tex> A = \bigcup \limits_{i=1}^{n}A_i </tex> , тогда по формуле включения–исключения: <center> <tex> | A | = \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex> </center><br />
Причем <tex> N = \{ 1,2, \ldots ,n \} </tex>. За <tex> 2^N </tex> примем множество всех подмножеств <tex> N </tex>.<br />
<br />
<br />
||proof=<br />
Доказываем теорему по индукции.<br />
<br />
Пусть <tex>~l</tex> {{---}} это количество множеств, мощность пересечения которых мы ищем. Для случая <tex>~l=1</tex> равенство обращается в тривиальное (<tex> |A| = |A| </tex>). Для случая <tex>~l=2</tex> справедливость теоремы пояснена выше. Таким образом, <tex>~l=2</tex> {{---}} база индукции. <br />
<br />
Предположим, что для <tex>~l=n-1</tex> равенство верно. Докажем, что равенство истинно для <tex>~l=n</tex> <br />
<br />
<br />
Пусть <tex> A </tex> {{---}} пересечение <tex>~n</tex> множеств. Тогда очевидно, что <tex> A = \bigcup \limits_{i=1}^{n}A_i = \left( {\bigcup \limits_{i=1}^{n-1}A_i} \right) \cup A_n </tex>. Пусть <tex> B = \bigcup \limits_{i=1}^{n-1}A_i </tex>; <tex>N' = \{ 1,2, \ldots ,n-1 \} </tex>.<br />
<br />
<br />
Исходя из предположения индукции, имеем, что <br />
<tex> | B | = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| </tex><br />
<br />
<br />
Кроме того, так как формула верна для <tex>~l=2</tex> (из базы индукции), то верно равенство <tex> | A | = | B | + | A_n | - | B \cap A_n |(1)</tex>. Найдем <tex>~| B \cap A_n |</tex>:<br />
<br />
<br />
Очевидно, что <tex> | B \cap A_n | = \left| \left( \bigcup \limits_{i=1}^{n-1}A_i \right) \cap A_n \right|= \left| \bigcup \limits_{i=1}^{n-1} \left( A_i \cap A_n \right) \right| (2)</tex><br />
<br />
<br />
Из предположения индукции имеем, что <tex> (2) = </tex> <tex> \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} \left( A_j \cap A_n \right) \right| = \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| </tex><br />
<br />
<br />
Подставим полученные значение в <tex>(1)</tex>:<br />
<br />
<br />
<tex> | A |\!\! = | A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I} A_j \right| \right) - \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right)</tex><br />
<br />
В силу того, что <tex> - \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| = \ \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \</tex><br />
<br />
Имеем в предыдущей формуле<br />
<br />
<tex> | A |\!\!=| A_n |+\left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| \right) + \left( \sum \limits_{I \in 2^{N'}} (-1)^{|I|+2} \left| \bigcap \limits_{ j\in I \cup \{ n \} } A_j \right| \right) <br />
</tex> <tex>= \sum \limits_{I \in 2^N} (-1)^{|I|+1} \left| \bigcap \limits_{ j \in I } A_j \right| </tex> . <br />
<br />
Равенство справедливо, потому что все наборы <tex> I \in 2^N </tex> можно разбить на три группы :<br />
<br />
# <tex> \{ n \} </tex><br />
# <tex> I \in 2^{N'} </tex> Это означает, что в наборе точно '''не''' будет присутствовать индекс <tex> n </tex>, а будут все различные варианты индексов остальных множеств, т.е. <tex> I \in 2^{N'}</tex><br />
# <tex> \{ n \} \cup I \in 2^{N'} </tex> Аналогично предыдущему, только в наборе будет индекс <tex> n </tex><br />
<br />
Как видно из равенства, каждое слагаемое "отвечает" за соответствующие группы. Значит, равенство истинно.<br />
<br />
Таким образом, для <tex>~l=n</tex> мы доказали, что равенство верно. Значит, индукционный переход верен, то есть теорема доказана.<br />
}}</div>GR1n