Обсуждение участницы:Анна — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
Строка 6: Строка 6:
 
== Описание алгоритма ==
 
== Описание алгоритма ==
 
=== Идея ===
 
=== Идея ===
Заметим, что если <tex>d_i < m</tex>, то очевидно, что <tex>C_i > d_i</tex>, следовательно, расписания не существует. Поэтому будем полагать, что <tex>m \leqslant d_i</tex> для <tex>i = 1 \ldots n</tex>.<br>
+
Заметим, что если <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>
 +
        <tex>h(j) = h(j) + 1</tex>
 +
      '''while''' <tex>\exists k > 1</tex> '''and''' <tex>h(k) = m + 1</tex>
 +
        '''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
 +
=== Асимптотика ===
 +
== Доказательство корректности ==
 +
{{Теорема
 +
|statement=
 +
Для множества работ с дедлайнами tex>d_1, d_2, \ldots d_n</tex> задача имеет решение тогда и только тогда, когда <tex>h(1) \leqslant m</tex>.
 +
|proof=
 +
}}

Версия 13:38, 11 мая 2016

[math] O \mid p_{i,j} = 1, d_i \mid - [/math]

Задача:
Дано [math]m[/math] одинаковых станков, которые работают параллельно, и [math]n[/math] работ, которые необходимо выполнить в произвольном порядке на всех станках. Любая работа на любом станке выполняется единицу времени. Для каждой работы есть время окончания [math]d_i[/math] — время, до которого она должна быть выполнена. Необходимо проверить, существует ли расписание, при котором все работы будут выполнены вовремя.

Описание алгоритма

Идея

Заметим, что если [math]d_i \lt m[/math], то очевидно, что [math]C_i \gt d_i[/math], следовательно, расписания не существует. Поэтому будем полагать, что [math]m \leqslant d_i[/math] для [math]i = 1 \ldots n[/math].

Определим [math]T = \max\limits_{i \in [1, n]}d_i[/math] — количество временных интервалов [math][t - 1, t][/math], где [math]t = 1 \ldots T[/math]. Будем обозначать [math][t - 1, t][/math] как [math]t[/math]. Для каждого из них мы можем назначить не более [math]m[/math] работ (по одной на каждый станок). Для каждой работы [math]i[/math] будем назначать времена обработки на каждой из машин следующим образом: на машине [math]m[/math] работа займет временной интервал [math]d_i[/math], на машине [math](m - 1)[/math] — интервал [math](d_i - 1)[/math] и так далее, на машине [math]1[/math] работа займет временной интервал [math]d_i - m + 1[/math]. В случае коллизий, то есть если найдется временной интервал [math]k \gt 1[/math], содержащий [math]m + 1[/math] работу, возьмем минимальный такой [math]k[/math] и перенесем лишнюю работу из него на ту же машину, но на один временной интервал левее. Будем повторять этот процесс, пока необходимо (и пока [math]k \gt 1[/math]). Таким образом, только первый временной интервал может содержать более [math]m[/math] работ. Причем это может произойти тогда и только тогда, когда задача не имеет решения, то есть не существует расписания, при котором все работы будут выполнены вовремя.

Псевдокод

Определим [math]h(t)[/math] — количество работ во временном интервале [math]t[/math].

void checkExistenceOfSchedule(int* [math]d[/math]):
  [math]T = \max\{d_i \mid i = 1 \ldots n\}[/math]
  for [math]t = 1[/math] to [math]T[/math]
     [math]h(t) = 0[/math]
  for [math]i = 1[/math] to [math]n[/math]
     for [math]j = d_i[/math] to [math]d_i - m + 1[/math]
        [math]h(j) = h(j) + 1[/math]
     while [math]\exists k \gt  1[/math] and [math]h(k) = m + 1[/math]
        find [math]\min\{k_0 \mid h(k_0) = m + 1\}[/math]
        [math]h(k_0 - 1) = h(k_0 - 1) + 1[/math]
        [math]h(k_0) = m[/math]
  if [math]h(1) \leqslant m[/math]
     return true
  else
     return false

Асимптотика

Доказательство корректности

Теорема:
Для множества работ с дедлайнами tex>d_1, d_2, \ldots d_n</tex> задача имеет решение тогда и только тогда, когда [math]h(1) \leqslant m[/math].