|
|
| Строка 1: |
Строка 1: |
| − | <tex dpi = "200"> O \mid p_{i,j} = 1, d_i \mid - </tex> | + | <tex dpi = "200"> O \mid p_{i,j} = 1 \mid \sum T_{i} </tex> |
| | {{Задача | | {{Задача |
| | |definition= | | |definition= |
| − | Дано <tex>m</tex> одинаковых станков, которые работают параллельно, и <tex>n</tex> работ, которые необходимо выполнить в произвольном порядке на всех станках. Любая работа на любом станке выполняется единицу времени. Для каждой работы есть время окончания <tex>d_i</tex> {{---}} время, до которого она должна быть выполнена. Необходимо проверить, существует ли расписание, при котором все работы будут выполнены вовремя. | + | Дано <tex>m</tex> одинаковых станков, которые работают параллельно, и <tex>n</tex> работ, которые необходимо выполнить в произвольном порядке на всех станках. Любая работа на любом станке выполняется единицу времени. Для каждой работы есть время окончания <tex>d_i</tex> {{---}} время, до которого она должна быть выполнена. Необходимо минимизировать суммарную [[Классификация_задач#Критерий оптимизации|медлительность]]. |
| | }} | | }} |
| | == Описание алгоритма == | | == Описание алгоритма == |
| | === Идея === | | === Идея === |
| − | {| class="wikitable" style="float:right; margin-left: 10px;"
| |
| − | |-
| |
| − | !
| |
| − | ! style="width:50px;"|<tex>t = 1</tex>
| |
| − | ! style="width:50px;"|<tex>2</tex>
| |
| − | ! style="width:50px;"|<tex>...</tex>
| |
| − | ! style="width:50px;"|<tex>d_i - m + 1</tex>
| |
| − | ! style="width:50px;"|<tex>d_i - m + 2</tex>
| |
| − | ! style="width:50px;"|<tex>...</tex>
| |
| − | ! style="width:50px;"|<tex>d_i - 1</tex>
| |
| − | ! style="width:50px;"|<tex>d_i</tex>
| |
| − | |-
| |
| − | ! style="width:50px;"|<tex>m = 1</tex>
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | | style="text-align:center;"|<tex>i</tex>
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |-
| |
| − | ! style="width:50px;"|<tex>2</tex>
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | | style="text-align:center;"|<tex>i</tex>
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |-
| |
| − | ! style="width:50px;"|<tex>\vdots</tex>
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |-
| |
| − | ! style="width:50px;"|<tex>m - 1</tex>
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | | style="text-align:center;"|<tex>i</tex>
| |
| − | |
| |
| − | |-
| |
| − | ! style="width:50px;"|<tex>m</tex>
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | |
| |
| − | | style="text-align:center;"|<tex>i</tex>
| |
| − | |-
| |
| − | ! colspan="9"|Табл. 1. Работа <tex>i</tex> назначена на интервалы <tex>d_i - m + 1 \ldots d_i</tex>.
| |
| − | |}
| |
| − | Заметим, что если <tex>d_i < m</tex>, то очевидно, что <tex>C_i > d_i</tex>, следовательно, расписания не существует. Поэтому будем полагать, что <tex>m \leqslant d_i</tex> для <tex>i = 1 \ldots n</tex>.
| |
| − |
| |
| − | Определим <tex>T = \max\limits_{i \in [1, n]}d_i</tex> {{---}} количество временных интервалов <tex>[t - 1, t]</tex>, где <tex>t = 1 \ldots T</tex>. Будем обозначать <tex>[t - 1, t]</tex> как <tex>t</tex>. Для каждого из них мы можем назначить не более <tex>m</tex> работ (по одной на каждый станок). Для каждой работы <tex>i</tex> будем назначать времена обработки на каждой из машин следующим образом: на машине <tex>m</tex> работа займет временной интервал <tex>d_i</tex>, на машине <tex>(m - 1)</tex> {{---}} интервал <tex>(d_i - 1)</tex> и так далее, на машине <tex>1</tex> работа займет временной интервал <tex>d_i - m + 1</tex>. В случае коллизий, то есть если найдется временной интервал <tex>k > 1</tex>, содержащий <tex>m + 1</tex> работу, возьмем минимальный такой <tex>k</tex> и перенесем лишнюю работу из него на ту же машину, но на один временной интервал левее. Будем повторять этот процесс, пока необходимо (и пока <tex>k > 1</tex>). Таким образом, только первый временной интервал может содержать более <tex>m</tex> работ. Причем это может произойти тогда и только тогда, когда задача не имеет решения, то есть не существует расписания, при котором все работы будут выполнены вовремя.
| |
| | | | |
| | === Псевдокод === | | === Псевдокод === |
| − | Определим <tex>h(t)</tex> {{---}} количество работ во временном интервале <tex>t</tex>.
| |
| − |
| |
| − | '''void''' checkExistenceOfSchedule('''int'''* <tex>d</tex>):
| |
| − | <tex>T = \max\{d_i \mid i = 1 \ldots n\}</tex>
| |
| − | '''for''' <tex>t = 1</tex> '''to''' <tex>T</tex>
| |
| − | <tex>h(t) = 0</tex>
| |
| − | '''for''' <tex>i = 1</tex> '''to''' <tex>n</tex>
| |
| − | '''for''' <tex>j = d_i</tex> '''to''' <tex>d_i - m + 1</tex> <font color=green>(1)</font>
| |
| − | <tex>h(j) = h(j) + 1</tex>
| |
| − | '''while''' <tex>\exists k > 1</tex> '''and''' <tex>h(k) = m + 1</tex> <font color=green>(2)</font>
| |
| − | '''find''' <tex>\min\{k_0 \mid h(k_0) = m + 1\}</tex>
| |
| − | <tex>h(k_0 - 1) = h(k_0 - 1) + 1</tex>
| |
| − | <tex>h(k_0) = m</tex>
| |
| − | '''if''' <tex>h(1) \leqslant m</tex>
| |
| − | '''return''' true
| |
| − | '''else'''
| |
| − | '''return''' false
| |
| − | ''Замечание:'' если расписание существует, то оно может быть вычислено данным алгоритмом, если добавить в цикл (1) функцию, отвечающую за добавление работы <tex>i</tex> на момент <tex>j</tex> в расписании для соответствующей машины и в цикл (2) функцию, отвечающую за перемещение работы, которой нет во временном интервале <tex>k_0 - 1</tex>, но которая есть в <tex>k_0</tex>, на момент <tex>k_0 - 1</tex> в той же машине (этот шаг будет обоснован далее в доказательстве корректности).
| |
| | | | |
| | === Асимптотика === | | === Асимптотика === |
| − | Покажем, что данный алгоритм может быть реализован за время <tex>O(nm)</tex>.<br>
| |
| − | Для начала рассмотрим следующий вопрос: пусть <tex>U</tex> {{---}} множество работ, для которого существует расписание, в котором отсутствуют опаздывающие работы, пусть <tex>i</tex> {{---}} работа, не принадлежащая <tex>U</tex>, для которой выполняется неравенство <tex>d_j \leqslant d_i</tex> для любой <tex>j \in U</tex>. Можно ли построить расписание для множества <tex>V = U \cup \{i\}</tex>, в котором так же будут отсутствовать опаздывающие работы.<br>
| |
| − | Введем несколько обозначений. Вектора <tex>h</tex>, соответствующие множествам <tex>U</tex> и <tex>V</tex> обозначим как <tex>h^U</tex> и <tex>h^V</tex> соответственно. <tex>x(d_i)</tex> {{---}} количество временных интервалов <tex>t</tex> со свойствами
| |
| − | *<tex>d_i - m + 1 \leqslant t \leqslant d_i</tex>,
| |
| − | *<tex>h^U(t) < m</tex>.
| |
| − | Будем говорить, что множество работ может быть выполнено ''вовремя'', если существует расписание, в котором все работы из этого множества успевают выполниться без опозданий.
| |
| − | {{Лемма
| |
| − | |statement=
| |
| − | Пусть даны работы <tex>1, 2 \ldots i</tex> с дедлайнами <tex>d_1 \leqslant d_2 \leqslant \ldots \leqslant d_i</tex>, <tex>U = \{1, 2, \ldots i - 1\}</tex> и <tex>V = U \cup \{i\}</tex>. Тогда для всех работ <tex>j = d_i - m + 1 \ldots d_i</tex>, для которых <tex>h^U(j) < m</tex>, будет верно, что <tex>h^V(j) = h^U(j) + 1</tex>.
| |
| − | |proof=
| |
| − | Рассмотрим вектора <tex>h^U</tex> и <tex>h^V</tex> после <tex>i - 1</tex> и <tex>i</tex> итераций алгоритма. Заметим, что значения вектора <tex>h</tex>, не превосходящие <tex>m</tex>, то есть <tex>h(j) < m</tex>, никогда не уменьшаются. Следовательно, если <tex>d_i - m + 1 \leqslant j \leqslant d_i</tex> и <tex>h^U(j) < m</tex>, то <tex>h^V(j) \geqslant h^U(j) + 1</tex>. Чтобы показать, что ситуация, когда при тех же условиях <tex>h^V(j) \geqslant h^U(j) + 2</tex>, невозможна, рассмотрим расписание, построенное алгоритмом.<br>
| |
| − | Если <tex>h^V(j) \geqslant h^U(j) + 2</tex>, то это значит, что в течение <tex>i</tex> итерации во временной интервал <tex>j</tex> была добавлена работа <tex>i</tex> и еще как минимум одна работа, пусть работа <tex>k</tex>, была перемещена из временного интервала <tex>j + 1</tex> в <tex>j</tex>. Это возможно только если работа <tex>k</tex> ни на одной машине не была назначена до временного интервала <tex>j</tex>. Следовательно, работа <tex>k</tex> выполняется во временной интервал <tex>j</tex> и некоторые временные интервалы <tex>v > j + 1</tex>, откуда следует, что <tex>j < d_k - m + 1 \leqslant d_i - m + 1</tex>, что приводит нас к противоречию.
| |
| − | }}
| |
| − | {{Теорема
| |
| − | |statement=
| |
| − | Пусть <tex>U</tex> {{---}} множество работ, которое может быть выполнено вовремя, пусть <tex>i</tex> {{---}} работа, не принадлежащая <tex>U</tex>, для которой выполняется неравенство <tex>d_j \leqslant d_i</tex> для любой <tex>j \in U</tex>. Тогда множество работ <tex>V = U \cup \{i\}</tex> может быть выполнено вовремя тогда и только тогда, когда <tex>x(d_i) + \sum\limits_{t = 1}^{d_i - m}(m - h^U(t)) \geqslant m</tex> (1).
| |
| − | |proof=
| |
| − | Неравенство (1) равносильно <tex>(d_i - m)m \geqslant \sum\limits_{t = 1}^{d_i - m}h^U(t) + m - x(d_i)</tex>. По лемме имеем <tex>\sum\limits_{j = d_i - m + 1}^{d_i}h^V(j) = \sum\limits_{j = d_i - m + 1}^{d_i}h^U(j) + x(d_i)</tex>. Вычитая это равенство из <tex>\sum\limits_{j = 1}^{d_i}h^V(j) = \sum\limits_{j = 1}^{d_i}h^U(j) + m</tex>, получим <tex>\sum\limits_{t = 1}^{d_i - m}h^V(t) = m - x(d_i) + \sum\limits_{t = 1}^{d_i - m}h^U(t)</tex>. Следовательно, мы пришли к тому, что (1) равносильно <tex>(d_i - m)m \geqslant \sum\limits_{t = 1}^{d_i - m}h^U(t)</tex>. Обозначим <tex>T = d_i - m</tex>, тогда предыдущее равенство превращается в <tex>Tm \geqslant \sum\limits_{t = 1}^{T}h^U(t)</tex> (2).<br>
| |
| − | Остается показать, что если равенство (2) выполняется для <tex>T = d_i - m</tex>, тогда оно выполняется и для <tex>T = 1, \ldots d_i - m - 1</tex>.
| |
| − | }}
| |
| | | | |
| | == Доказательство корректности == | | == Доказательство корректности == |
| − | {{Теорема
| |
| − | |statement=
| |
| − | Для множества работ с дедлайнами <tex>d_1, d_2, \ldots d_n</tex> задача имеет решение тогда и только тогда, когда <tex>h(1) \leqslant m</tex>.
| |
| − | |proof=
| |
| − | <tex>\Rightarrow</tex><br>
| |
| − | Если задача имеет решение, то очевидно, что первый временной интервал не может быть переполнен.<br>
| |
| − | <tex>\Leftarrow</tex>
| |
| − | Изначально алгоритм присваивает все стадии обработки каждой работы <tex>i</tex> (то есть обработку на каждом станке) попарно различным временным интервалам. Если <tex>\exists k > 1 : h(k) = m + 1</tex> и <tex>h(k - 1) \leqslant m</tex>, то это значит, что существует как минимум одна работа, которая назначена временному интервалу <tex>k</tex>, но которой нет во временном интервале <tex>k - 1</tex>. Следовательно, после перемещения вектор <tex>h</tex> по-прежнему будет удовлетворять условию, что каждая работа принадлежит <tex>m</tex> разным временным интервалам, причем в каждом из них она будет выполняться на разных машинах, так как при перемещении работ машины остаются прежними. Таким образом, если <tex>h(1) \leqslant m</tex>, то <tex>h(t) \leqslant m</tex>, где <tex>t = 1 \ldots T</tex>, то есть существует решение, при котором все работы будут выполнены вовремя.
| |
| − | }}
| |
