Участник:Dominica — различия между версиями

Материал из Викиконспекты
Перейти к: навигация, поиск
м (Анализ работы сети)
м
 
(не показана 31 промежуточная версия 2 участников)
Строка 1: Строка 1:
Ажтаи (Ajtai), Комлос (Komlos) и Шимереди (Szemeredi) сконструировали сортирующую сеть на N входов глубины <tex> O(\log N) </tex>, при они не углублялись в исследование значения константы, получавшейся при правильном соблюдении необходимой ассимптотики. Впоследствии Патерсон выяснил, что <tex> O(\log N) </tex> можно заменить на <tex> c\log_2 N </tex> с константой приблизительно равной <tex> 6100 </tex>. Здесь будет описана более поздняя реализация, которая включает в себя меньшую константу <tex>c</tex>, а именно, будет доказано, что для любого целого числа <tex>N</tex> такого,что <tex>N \ge 2^{78}</tex> существует сортирующая сеть на <tex>N</tex> входов, такая, что  глубина в худшем случае будет <tex>1830 \log_2 N - 58657 </tex>.
+
<tex dpi = "200" >1 \mid\mid \sum w_i U_i</tex>
 +
{{Утверждение
 +
|id=krit_dol3
 +
|statement=
 +
Критерии Делоне для ребер и треугольников равносильны.
 +
|proof=
 +
[[Файл:dol3.png|400px|thumb|right|]]
 +
Из треугольника в ребра: если для каждого треугольника выполнен критерий, то для каждого ребра можно рассматривать плоскость при любом треугольнике при ребре.
 +
Обратно: Рассмотрим треугольник <tex>ABC</tex>, для каждого из ребра можно провести плоскость и они образуют трехмерный угол, снаружи которого нет точек. В пересечении угла и плосокости <tex>ABC</tex> образуется тетраэдр. Если в нем есть точки, то точки есть внутри треугольника, тогда это не триангуляция <tex>\implies</tex> точек в тетраэдре нет <tex>\implies</tex> плоскостью <tex>ABC</tex> можно отделить пространство с точками <tex>\implies</tex> выполняется глобальный критерий.
 +
}}
 +
Будем называть '''хорошими''' те рёбра, для которых выполняется локальный критерий Делоне.
 +
{{Лемма
 +
|about=4
 +
|id=fliplemmasphere
 +
|statement=
 +
Из двух рёбер, которые можно провести для пары треугольников, как минимум одно хорошее.
 +
|proof=
 +
}}
  
Основными составяющими этой конструкции будут сортирующие сети на <tex>M</tex> входов, такие ,что <tex>M</tex> относительно мало. Мы назовем их <tex>M</tex>-сортировщикамиДля любых выбранных положительных целых чисел <tex>M</tex> и <tex>N</tex> таких что <tex> N \ge M</tex>, конструкция будет включать в себя <tex>N</tex> проводов, и будет сделана из <tex>M</tex>-сортировщиков, глубина которых в худшем случае <tex>(48 + о(1))\log_MN + 115</tex> при <tex>M \to \inf</tex>.
+
{{nohate2}}
(Стоит отметить, что асимптотическое <tex>o(1)</tex> здесь относится к <tex>M</tex>, а не к <tex>N</tex>).
+
{{wasted}}
 
+
{{под кат
== Представление в виде дерева и разделители ==
+
|title = Заголовок блока
 
+
|content = Содержимое
Сначала введем все необходимые понятия для построения сортирующей сети.
+
|frame-style = border:1px solid Plum
 
+
|title-style = color:black;background-color:lavender;font-weight:bold
{{Определение
+
|content-style = color:black;background-color:ghostwhite;text-align:center
|definition=
+
|footer = См. [[другая статья|другую статью]]
'''Идеальным разделителем''' будем называть сеть, выходные провода которой разделены на K  блоков одинакового размера, таких, что принимая на вход любые <tex>a</tex> значений, сеть размещает первые <tex>a/k</tex> минимальные по величине  ключи в первый блок, следующие <tex>a/k</tex> по величине ключи – во второй, и т.д.
+
  |footer-style = background-color:lightgray;text-align:right
 +
}}
 +
{{Задача
 +
|definition= Есть один станок и <tex>n</tex> работ. Для каждой работы заданы время выполнения <tex> p_i,</tex> дедлаин <tex>d_i</tex> и стоимось выполнения этой работы <tex>w_i \geqslant 0</tex>.
 +
Необходим минимизировать <tex>\sum w_i U_i</tex>.
 
}}
 
}}
Эти идеальные разделители могут быть использованы как модули для построения сортирующей сети на <tex>N</tex>  входов, где <tex>N  = k^d</tex> для некоторого положительного числа d. Такая сеть будет представлять собой композицию сетей <tex>N_0, N_1, N_2 \dots N_{d-1}</tex>, где <tex>N_t</tex> – парраллельная композиция <tex>k^t</tex> идеальных разделителей одинакового размера. <tex>k^{d - t}</tex> Выходных проводов уровня <tex>N_t</tex> разделены на <tex>k</tex> блоков одинакового размерв и каждый из этих блоков формирует вход для идеального разделителя из N_{t+1}.
 
Можно рассмотреть другую интерпретацию этой конструкции. k^d входных данных мы будем рассматривать как листья полного k-ичного дерева глубины d;  каждый модуль(разделитель) из N_t будем считать узлом, находящимся на высоте t  в нашем дереве. Будем считать, что в каждый момент времени t = 0, 1, 2, ... в - 1 входные провода распределены по всему уровню t нашего дерева. В то же время, каждый узел х на t уровне принимает k^{d - t}  проводов и эти провода затем используются как вход  для идеального разделителя который разбивает их на k блоков одинакового размера в промежуток времени между t  и t + 1. Выходные провода из  j получившегося блока идут в j ребенка вершины x. К моменту времени d каждый лист дерева содершит в себе только один провод, а этот провод содержит в себе значение, которое и приписывается к листу.
 
 
К сожалению, эта схема описывает сортирующую сеть глубины <tex>\Omega((\log_k N)(\log_m N)) </tex>: каждый идеальный разделитель на а проводов, если его делать из М-разделителей, должен иметь глубину более чем <tex>\log_M(\dfrac{k-1}{k}a). (Чтобы осознать это, заметим, что для каждого выхода y должно быть более чем <tex>\dfrac{k -1}{k}a</tex> входов x , таких, что ключ мог бы дойти от x до y). К счастью, схему можно переделать так, чтобы она описывала сортирующую сеть глубины <tex>O(\log_M N)</tex> : идеальные разделители можно заменить на более слабые модули константной глубины,чья слабость будет компенсироваться более сложным перемещением ключей через дерево.
 
 
Слабые модули мы назовем сепараторами. У каждого такого сепаратора есть а выходных проводов, которые делятся на блоки <tex> F_1, B_1, B_2, \dots, B_k, F_2 </tex> так, что <tex> |F_1| = |F_2|</tex> <tex> |B_1| = |B_2| = \dots = |B_k| </tex>;
 
 
Как правило, "обрамляющие блоки" <tex>F_1</tex> и <tex>F_2</tex> гораздо меньше всех остальных. В каком-то смысле, можно сказать, что сепаратор аппроксимирует идеальный разделитель. Тогда будем измерять точность аппроксимации величинами <tex> \delta_F, \varepsilon_F </tex> и <tex>\varepsilon_B</tex>. Сортирующая сеть, с такими же выходными проводами как и наш сепаратор, принимая на вход I, состоящее из a отдельных проводов, распределяет соответствующие <tex>I_j</tex> в выходные блоки <tex>B_j</tex>. Сераратор же распределяет вход <tex>I</tex> таким образом, что 1) для каждого <tex> j = 1, 2, \dots, k, </tex> не более <tex>\varepsilon_B a</tex> ключей из <tex>I_j</tex> не попадут в <tex>B_j</tex>.
 
2)для каждого целого j такого, что <tex>1\le j\le \delta_F|F_i|</tex>не более <tex>\varepsilon_F j</tex> из <tex>j</tex> самых маленьких чисел могут не попасть в <tex>F_1</tex> и не более <tex>\varepsilon_F j</tex> из <tex>j</tex> самых больших чисел могут не попасть в <tex>F_2</tex>
 
Что касается перемещения значений в дереве, то в момент времени <tex>t = 0</tex>  все <tex>k^d</tex> проводов входят в корень. Между временами <tex> t</tex> и <tex>t + 1</tex> каждый узел <tex>x</tex>, в который входят какие-нибудь провода, использует эти а проводов как вход для сепаратора, с разумно выбранным размером для выходных блоков. Провода из каждого выходного блока <tex>B_j</tex> посывлаются в <tex>j</tex>того сына узла <tex>x</tex>а провода попавшие в <tex>F_1</tex> или <tex>F_2/tex> посылаются обратно к родителю <tex>x</tex>. (Если <tex>x</tex>. - корень, то <tex>F_1</tex> и <tex>F_2</tex> должны быть пустыми. Так как  <tex>F_1</tex> и <tex>F_2</tex> сравнительно маленькие, то большинство значений провалится ниже к листам дерева;  так как сепаратор не идеальный, то некоторые ключи могут быть посланы вниз в неправильном направлениии. Свойство 1) гарантирует, что очень малое количество собъется с пути, а свойство 2) гарантирует, что большинство из этих ключей вернутся назад и смогут исправить свое положение позже.
 
== Конструкция сети ==
 
Пускай число детей у каждой вершины <tex>k</tex> будет степенью двойки, и число входных ключей - <tex> N = k ^ d </tex>. В любой момент времени <tex>t</tex> все <tex>N</tex> проводов распределены внутри дерева таким образом, что число проводов, содержащихся в вершине <tex>x</tex> зависит только от времени <tex>t</tex> и глубины <tex>i</tex> на которой находится вершина <tex>x</tex>. Тогда пускай <tex>a(i, t)</tex> будет описывать это число. Значение <tex>a(i, t)</tex> зависит от двух параметров <tex>A</tex> и <tex>\nu</tex>, таких, что <tex>\nu < 1 </tex> и <tex>A\nu > 1</tex>
 
 
В самом начале, число проводов, входящих в корень :
 
 
<tex>a(0, 0) = N</tex>
 
 
При переходе к <tex>t = 1</tex> корень делит <tex>N</tex> проводов на <tex>k</tex> групп и отправляет их своим <tex> k </tex> детям:
 
 
<tex>a(1, 1) = N/ k</tex>
 
 
При переходе к <tex>t = 2</tex> каждый узел, находящийся на 1 уровне отправляет <tex>N\nu / Ak^2 </tex> своих <tex>N/k</tex> проводов обратно в корень и распределяет оставшиеся провода равномерно среди детей :
 
 
<tex> a(0, 2) = \dfrac{\nu}{Ak}N</tex>
 
<tex> a(2, 2) = \dfrac{Ak - \nu}{Ak^3}N</tex>
 
 
Обозначим <tex>\alpha (t)</tex> и <tex>\omega (t)</tex> - верхний и нижний уровни, соответственно, такие что на на них содержатся непустые узлы на момент времени <tex>t</tex>. Иначе говоря, <tex>\alpha (t)</tex> - это наименьшее <tex>i</tex>, такое что
 
<tex>a(i, t) \neq 0</tex>, а <tex>\omega (t)</tex> - это наибольшее <tex>i</tex>, такое что
 
<tex>a(i, t) \neq 0</tex>
 
  
Так получаем, что
+
==Решение==
<tex>\alpha (0) = \omega (0) = 0; \quad \alpha (1) = \omega (1) = 1; \quad  \alpha (2) = 0 \omega (2) = 2; </tex>
+
Применим для решения данной задачи [[Динамическое программирование|динамическое программирование]].
  
Значения  <tex>\alpha (t)</tex> и <tex>\omega(t)</tex> расходятся в момент <tex>t = 2</tex>и сойдутся, когда перемещение значений по сети и их сортировка будет окончена.
+
Обозначим <tex>T = \sum\limits_{i=1}^n p_i</tex>.
Запишем
+
Для всех <tex>t = 0, 1, \ldots, T </tex> и <tex>j = 1, \ldots, n</tex> будем рассчитывать <tex>F_j(t)</tex> {{---}} значение целевой функции, при условии, что были рассмотрены первые <tex>j</tex> работ и общее время выполнения тех из них, что будут закончены вовремя, не превышает времени <tex>t</tex>.
<tex>\alpha^*(t) = \dfrac{t\log \dfrac{1}{\nu} - \log N + \log(2A\nu k^3)}{\log A}</tex>
+
#Если <tex>0 \leqslant t \leqslant  d_j </tex> и работа <tex>j</tex> успевает выполниться вовремя в расписании, соответствующем <tex>F_j(t)</tex>, то <tex>F_j(t) = F_{j- 1}(t - p_j)</tex>, иначе <tex>F_j(t) = F_{j- 1}(t) + w_i</tex>.
и
+
#Если <tex>t > d_j</tex>, то <tex>F_j(t) = F_{j}(d_j)</tex>, поскольку все работы с номерами <tex>j = 1, \ldots, j</tex>, законченные позже, чем  <tex> d_j \geqslant \ldots \geqslant d_1 </tex>,  будут выполнены с опозданием.
<tex>\omega^*(t) = \dfrac{t\log \dfrac{1}{\nu} + \log(A\nu k)}{\log Ak}</tex>
 
  
Пускай <tex>\alpha(t)</tex> будет наименьшим неотрицательным челым числом, таким что
+
Отсюда, получим соотношение:
 
+
<p>
<tex>\alpha(t) \ge \alpha^*(t),\quad  \alpha (t)\equiv t\mod 2 </tex>
+
<tex>
 
+
F_j(t) =
Пускай <tex>\omega(t)</tex> будет наименьшим челым числом, таким что
+
\left \{\begin{array}{ll} \min(F_{j-1}(t-p_j), F_{j-1}(t) + w_j), 0 \leqslant t \leqslant  d_j \\
 
+
F_j(d_j), & d_j < t < T
<tex>\omega(t) \ge \omega^*(t),\quad  \omega (t)\equiv t\mod  2 </tex>
+
\end{array} \right.
 
 
Поскольку <tex>A\nu \ge 1 </tex> получаем, что <tex>\alpha^*(t + 1) \le \alpha^* (t) + 1, \omega^*(t + 1) \le \omega^* (t) </tex> для любого <tex>t</tex> и поэтому
 
 
 
<tex> |\alpha(t + 1) - \alpha(t) | = 1, \quad |\omega(t + 1) - \omega(t)| = 1 </tex>
 
 
 
для любого <tex>t</tex>.
 
Нижнее значение может уменьшаться и увеличиваться, но в среднем оно спадает со скоростью  <tex>\log\dfrac{1}{\nu} </tex> уровней на каждые <tex> \log(Ak) </tex> итераций. Верхнее же значение первые <tex>\log N/\log\dfrac{1}{\nu} </tex> итераций колеблется между значениями 0 и 1 ,а дальше начинает так же  уменьщаться со скоростью <tex>\log\dfrac{1}{\nu}</tex> уровней на каждые <tex>\log(A)</tex> итераций. Обозначим за <tex>t_f </tex> время, когда верхнее и нижнее значения совпадут: <tex>t_f </tex> - это наибольшее целое положтельное число такое, что:
 
<tex> \alpha(t) < \omega(t)</tex> <tex> 1 < t < t_f </tex>
 
Также
 
<tex> \alpha(t_f) = omega(t_f) </tex>
 
(Это будет понятно из дальнейшего изложения. Так же будет проверено, что общее значение <tex> \alpha(t_f)</tex> и <tex>omega(t_f) </tex> меньше, чем <tex>d</tex>)
 
 
 
<tex> c(i, t) = \dfrac{N}{A\nu k} A^i\nu ^i </tex>
 
Значение <tex> c(i, t) </tex> можно рассматривать как вместимость узла  на <tex> i </tex>  уровне во время <tex> t </tex>: для любого <tex> t</tex>, такого, что <tex> 1 < t < t_f </tex> имеем
 
<tex> \dfrac{a(\alpha(t), t)}{c(\alpha(t), t)} = 1 </tex>,
 
 
 
<tex> \dfrac{a(i, t)}{c(i, t)} = 1 - \dfrac{1}{A^2 k^2} </tex> где
 
<tex> \alpha(t) < i < \omega(t) </tex>
 
и
 
<tex> i \equiv t \mod 2 </tex>
 
 
 
<tex> a(\omega(t),t) = Nk ^{-\omega(t)} - dfrac{c(\omega(t), t)}{A^2k^2}</tex>
 
(Если
 
<tex> i \not\equiv t \mod 2</tex> тогда
 
<tex> a(i, t) = 0 </tex>) Начиная с
 
<tex> N k ^{-\omega(t)} \le c(\omega(t), t) < A^2k^2Nk^{-\omega(t)}), </tex>
 
имеем
 
 
 
<tex> 0 < \dfrac{a(\omega(t), t)}{c(\omega(t), t)} \le 1 - \dfrac{1}{A^2k^2} </tex>
 
 
 
Начиная с
 
<tex>c(\alpha(t), t) \ge 2k^2 /tex> мы имеем <tex>c(i, t) \ge 2A^2k^2 </tex> когда <tex>i\ge \alpha(t) + 2 </tex>. Это следует из того, что все
 
<tex> a(i, t) </tex> целые.
 
 
 
Чтобы как-то перераспределить провода между временами <tex>t</tex> и <tex>t + 1 </tex> каждый узел на уровне i посылает <tex>\pi(i, t) </tex> значений своим родителям и <tex>\chi(i, t) </tex> значений каждому из своих <tex>k</tex> детей. Если <tex>2 \le t < t_f </tex>, то
 
 
 
<tex> \pi(\alpha(t),t) =
 
\begin{cases}
 
0,&\text{если $\alpha(t + 1)>\alpha(t)$,}\\
 
\dfrac{\nu}{AK}c(a(t),t), &\text{если $\alpha(t + 1)>\alpha(t)$.}
 
\end{cases}
 
 
</tex>
 
</tex>
 +
</p>
 +
В качестве начальных условий следует взять <tex>F_j(t) = \infty </tex>  при  <tex>t < 0, j = 0,\ldots, n </tex>  и  <tex>F_0(t) = 0 </tex>  при  <tex>t \geqslant 0 </tex>.
  
 +
Ответом на задачу будет <tex>F_n(d_n)</tex>.
  
 +
Приведенный ниже алгоритм вычисляет <tex>F_j(t)</tex> для <tex>j = 0,\ldots, n </tex> и <tex>t = 0,\ldots, d_j </tex>. За <tex>p_{max}</tex> обозначим самое большое из времен выполнения заданий.
  
<tex> \pi(i,t) = \dfrac{A\nu k - 1}{A^2k^2}c(i,t),\qquad\quad \text{если $\alpha(t) < i < \omega(t)$,}
+
  отсортиртировать работы по неубыванию времен дедлайнов <tex>d_i</tex>
</tex>
+
  <tex>t_1</tex> = <tex>r_1</tex>
 +
  '''for''' <tex>t = -p_{max}</tex> '''to''' <tex>-1</tex>
 +
    '''for''' <tex>j = 0</tex> '''to''' <tex>n</tex>
 +
      F_j(t) = \infty
 +
  '''for''' <tex>t = 0</tex> '''to''' <tex>T</tex>
 +
    F_0(t) = 0
 +
  '''for''' <tex>j = 1</tex> '''to''' <tex>n</tex>
 +
    '''for''' <tex>t = 0</tex> '''to''' <tex>d_j</tex>
 +
      '''if''' <tex> F_{j-1}(t) + w_j  < F_{j-1}(t-p_j) </tex> 
 +
        <tex> F_j(t) = F_{j-1}(t) + w_j </tex>
 +
      '''else'''
 +
        <tex> F_j(t) = F_{j-1}(t-p_j) </tex>
 +
    '''for''' <tex>t = d_j + 1</tex> '''to''' <tex>T</tex>
 +
      <tex> F_j(t) = F_{j}(d_j) </tex>
  
 +
Время работы данного алгоритма {{---}} <tex>O(n \sum\limits_{i=1}^n p_i)</tex>.
  
 +
Для того, чтобы найти само расписание, по доказанной ниже лемме, нам достаточно найти множество работ, которые будут выполнены с опозданием. Это может быть сделано следующим способом:
 +
  t = d_n
 +
  L = \varnothing
 +
  '''for''' <tex>j = n</tex> '''downto''' <tex>1</tex>
 +
    <tex>t = \min(t, d_j)</tex>
 +
    '''if''' <tex> F_j(t) = F_{j-1}(t) + w_j </tex>
 +
      <tex> L = L \cup \{j\} </tex> </tex>
 +
    '''else'''
 +
      <tex> t = t - p_j </tex>
  
<tex> \pi(\omega(t),t) =
+
==Доказательство корректности и оптимальности==
\begin{cases}
 
\dfrac{A\nu k - 1}{A^2k^2}c(\omega(t),t),&\text{ $\omega(t + 1)>\omega(t)$,}\\
 
\alpha(\omega(t),t),&\text{если $\omega(t + 1)<\omega(t)$,}
 
\end{cases}
 
</tex>
 
  
 +
{{Лемма
 +
|id=lemma1
 +
|statement= Пусть все работы отсортированы в порядке неубывания дедлайнов <tex>d_i</tex>.
 +
Тогда существует оптимальное расписание вида <tex>i_1, i_2, \ldots, i_s, i_{s+1}, \ldots, i_n </tex>, такое, что  <tex>i_1 < i_2 < \ldots < i_s </tex> {{---}} номера работ, которые успеют выполниться вовремя, а  <tex>i_{s+1}, \ldots, i_n </tex> {{---}} номера просроченных работ.
 +
|proof= Пусть у нас есть некоторое оптимальное раписание <tex>S</tex>. Получим необходимое нам расписание путем переставления некоторых работ.
 +
#Если работа с номером <tex> i</tex>  выполнится  в <tex>S</tex> с опозданием, то переставим эту работу в конец. При этом, так как работа просрочна в оптимальном расписании <tex>S</tex>, при такой перестановке не произойдет увеличения целевой функции.
 +
#Если работы с номерами <tex>i</tex> и <tex>j</tex> в расписании <tex>S</tex> выполняются вовремя, но при этом <tex>d_i < d_j </tex>, но <tex>j</tex> стоит в <tex>S</tex> раньше <tex>i</tex>. Тогда переставим работу с номером <tex>j</tex> так, чтобы она выполнялась после работы <tex>i</tex>. Таким образом, каждая из работ, находившихся в <tex>S</tex> между <tex>j</tex> и <tex>i</tex>, включая <tex>i</tex>, будет выполняться в новом расписании на <tex>p_j</tex> единиц времени раньше. Эта перестановка не повлияет на оптимальнось расписания:
 +
#*Ни одна из работ, котарая успевала выполниться в расписании <tex>S</tex>, не попадет в список просроченных работ при переставлении её на более раннее время.
 +
#*Число работ, не успевающих выполниться вовремя, не может уменьшится, иначе бы возникло противоречие в исходным выбором <tex>S</tex>, как оптимального решения.
 +
#*Поскольку <tex>d_i < d_j </tex> и работа <tex>i</tex> будет заканчиваться на <tex>p_j</tex> единиц времени раньше, то стоящая сразу послее нее работа <tex>j</tex> тоже будет успевать выполниться.
 +
}}
  
 +
==См. также ==
 +
* [[Классификация задач]]
 +
* [[1ripipsumwu|<tex> 1 \mid r_i,p_i=p \mid \sum w_i U_i</tex>]]
 +
* [[1pi1sumwu|<tex>1 \mid p_{i} = 1 \mid \sum w_{i}U_{i}</tex>]]
 +
* [[R2Cmax|<tex>R2 \mid \mid C_{max}</tex>]]
  
<tex> \chi(\alpha(t),t) =
+
== Источники информации ==
\begin{cases}
+
* P. Brucker. Scheduling Algorithms (2006), 5th edition, стр. 26 - 28
\dfrac{1}{k}c(\alpha(t),t),&\text{ $\alpha(t + 1)>\alpha(t)$,}\\
 
\dfrac{Ak - \nu}{Ak^2}c(\alpha(t),t),&\text{если $\alpha(t + 1)<\alpha(t)$,}
 
\end{cases}
 
</tex>
 
 
 
 
 
 
 
<tex> \chi(i,t) = \dfrac{Ak - \nu}{Ak^2}c(i,t),\qquad\quad  \text{если $\alpha(t) < i < \omega(t)$,}
 
</tex>
 
 
 
 
 
 
 
<tex> \pi(\omega(t),t) =
 
\begin{cases}
 
\alpha(\omega(t + 1), t + 1)), &\text{ $\omega(t + 1)>\omega(t)$,}\\
 
0,&\text{если $\omega(t + 1)<\omega(t)$,}
 
\end{cases}
 
</tex>
 
 
 
Отметим, что для все <tex>\pi(i, t)</tex> и <tex>\chi(i, t)</tex> целые: в частности, если <tex>\alpha(t + 1) < \alpha(t)</tex>, то
 
<tex>c(\alpha(t), t) = (A/\nu)c(\alpha(t + 1), t + 1) \ge 2Ak^2/\nu</tex>
 
 
 
Если сепараторы, используемые для построения сети достаточно хорошие, то(мы проверим чуто позже) существует такое целое число <tex>\gamma </tex>, не превосходящее <tex>\alpha(t_f) </tex>, но при этом отличающееся от  <tex>\alpha(t_f) </tex>не более чем на константу, не зависящую от <tex>N</tex>, такое, что для любого узла <tex>x</tex>, находящегося на уровне <tex>\gamma </tex>, все ключи, являющиеся потомками узла <tex>x</tex> в момент времени <tex>t_f</tex> адресуются толко к ключам, являющимся потомками <tex>x</tex>. Следовательно, построеная сеть может быть дополнена до сортирующей единственным слоем из параллельных сортирующих сетей, каждая из которых будет содержать <tex>k^{d - \gamma} </tex> входных проводов.
 
 
 
 
 
Далее мы будем использовать следующие утверждения
 
 
 
 
 
Лемма 3.1 Если <tex>\alpha(i, t) \neq 0</tex> тогда
 
 
 
 
 
<tex> \sum\limits^d_{j=0} k^{j-i}a(j, t) =
 
\begin{cases}
 
Nk^{-i}, &\text{ $i = \alpha(t)$,}\\
 
Nk^{-i} - \dfrac{c(i,t)}{A^2k^2}, &\text{ $i > \alpha(t)$,}
 
\end{cases}
 
</tex>
 
 
 
 
 
Доказательство
 
Это утверждение следует из того
 
<tex>\sum\limits^d_{j=0} k^ja(j, t) = N </tex>
 
 
 
Непосредственно, когда <tex> i = \alpha(t) </tex> и подставляется
 
 
 
 
 
<tex> a(j,t) =
 
\begin{cases}
 
0, &\text{ $j \not\equiv i \mod 2$,}\\
 
c(j, t), &\text{ $j = \alpha(t)$,}\\
 
(1 - \dfrac{1}{A^2k^2})c(j, t) &\text{ $\alpha(t) < j < i, \quad j \equiv i \mod 2$}
 
\end{cases}
 
</tex>
 
 
 
 
 
где <tex> c(j, t) = c(i, t)A^{j-i}</tex> при <tex>i\ge\alpha(t)+2</tex>.
 
 
 
 
 
лемма 3.2 Если <tex>\alpha(t + 1) > \alpha(t) </tex> тогда <tex>\alpha(t) = 0</tex> или <tex>c(\alpha(t),t)\le Ak^2/\nu</tex>
 
 
 
Доказательство
 
Если <tex>\alpha(t+1) > \alpha(t) > 0</tex>, тогда <tex>\alpha(t) - 1 < \alpha^*(t + 1) </tex>, а значит и <tex>c(\alpha(t),t) < 2Ak^2/\nu</tex>.
 
 
 
== Анализ работы сети ==
 
Посторонним ключем будем называть ключ, находящийся в узле <tex>x</tex>, котороый при этом не будет отправлен ниже по дереву при переходе к следующему шагу. Посторонним ключем порядка <tex>r</tex> будем называть такой ключ, который останется посторонним, даже если его переместить в его предка, находящегося на <tex>r</tex> уровней выше по дереву.(По сути, посторонний ключ -  посторонний ключ порядка ноль).
 
Далее мы докажем, что в момент времени <tex>t_f</tex> узлы на уровне <tex>\alpha(t_f) </tex> не содержат посторонних ключей порядка <tex>r</tex> для некоторой константы <tex>r</tex>, зависящей только от <tex>A, k, \nu</tex> Для этого рассмотрим следующее предположение
 
  Для любого <tex> i = 0, 1, \dots , d </tex> и для любого <tex> r = 0, 1, \dots , d </tex> каждый узел на уровне <tex>i</tex> содержит менее чем <tex>\mu \delta^r c(i, t) </tex> посторонних ключей порядка <tex> r </tex>.
 
 
 
 
 
Так как <tex>c(\alpha(t_f), t_f) < 2 A^2 k^2 </tex>, то остается только проверить, что предположение выполняеся во время tex>t_f</tex> для некоторых <tex>\mu</tex> и <tex>\delta</tex> (зависящего только от <tex> i = 0, 1, \dots , d </tex>) ,такого, что <tex>\delta < 1 </tex>
 
 
 
 
 
 
 
<tex>(\dfrac{1}{k} + \dfrac{\mu\delta kA^2}{1 - \delta^2k^2A^2})c(i,t)</tex>
 
 
 
 
 
<tex> \dfrac{1}{k}(Nk^{-i} - c(i,t)) </tex>
 
 
 
 
 
<tex> \sum\limits_{j\ge 1} k^{2j-1}\mu\delta^{2j-1}c(i+2j, t) </tex>
 
 
 
 
 
<tex> \sum\limits_{j\ge 1} (k\delta)^{2j-1}c(i+2j, t) = c(i,t)\sum\limits_{j\ge 1} (k\delta)^{2j-1}A^{2j} < c(i,t)\dfrac{\delta k A^2}{1-\delta^2k^2A^2} </tex>
 
 
 
<tex>\dfrac{1}{k}Nk^{-i}</tex>
 
 
 
 
 
лемма 4.2
 
 
 
<tex>(\mu + (k - 1)\dfrac{\mu\delta k A^2}{1 - \delta^2k^2A^2} + \dfrac{A\nu k - 2A\nu + 1}{2k^2A^2} + \varepsilon_B)c(i,t)</tex>
 
 
 
 
 
<tex>c=c(i, t), \quad a=a(i,t),\quad \pi=\pi(i,t), \quad \chi=\chi(i, t) </tex>
 
 
 
 
 
<tex>\Delta_1 = \dfrac{\mu\delta kA^2}{1-\delta^2k^2A^2}c</tex>
 
 
 
 
 
<tex>\Delta_2 = \dfrac{\nu}{1 - \delta^2k^2A^2}c</tex>
 
 
 
dfrac
 
<tex> \Delta =
 
\begin{cases}
 
\Delta_1,&\text{ $i = \alpha(t) < \alpha(t+1)$,}\\
 
\Delta_2,&\text{ $i = \omega(t) < \omega(t+1)$,}\\
 
\Delta_1 + \Delta_2,&\text{если $\alpha(t) <i < \omega(t)  \quad ||\quad i = \alpha(t) > \alpha(t + 1), t \ge 2$,}
 
\end{cases}
 
</tex>
 
 
 
 
 
<tex>(k - 1)\Delta - \dfrac{1}{2}\pi \le (k - 1)\Delta_1 + \dfrac{A\nu k - 2A\nu + 1}{2A^2k^2}c </tex>
 
 
 
 
 
лемма 4.3
 
 
 
<tex> \varepsilon^* \le \dfrac{\mu}{k},</tex>
 
 
 
<tex>(\mu + (k - 1)\dfrac{\mu\delta k A^2}{1 - \delta^2k^2A^2} + \dfrac{A\nu k - 2A\nu + 1}{2k^2A^2} + \varepsilon_B)\dfrac{1}{A\nu} + \mu\delta\dfrac{Ak}{\nu} \le \mu </tex>
 
 
 
Лемма 4.4
 
 
 
<tex>\mu \le \dfrac{\nu}{Ak^2}, </tex>
 
 
 
 
 
<tex>\mu\le\dfrac{1}{2}\delta_F\dfrac{A\nu k - 1}{A^2k^2},</tex>
 
 
 
 
 
<tex>\varepsilon_F\dfrac{1}{A\nu} + \delta^2\dfrac{Ak}{\nu} \le \delta </tex>
 
 
 
 
 
<tex>\dfrac{\pi(i,t)}{c(i,t)} \ge \dfrac{A\nu k - 1}{A^2k^2}</tex>
 
 
 
Лемма 4.5
 
 
 
<tex>\mu\delta^rc(\alpha(t_f),t_f) \le 1</tex>
 
 
 
== Мусор ==
 

Текущая версия на 23:21, 28 ноября 2016

[math]1 \mid\mid \sum w_i U_i[/math]

Утверждение:
Критерии Делоне для ребер и треугольников равносильны.
[math]\triangleright[/math]
Dol3.png

Из треугольника в ребра: если для каждого треугольника выполнен критерий, то для каждого ребра можно рассматривать плоскость при любом треугольнике при ребре.

Обратно: Рассмотрим треугольник [math]ABC[/math], для каждого из ребра можно провести плоскость и они образуют трехмерный угол, снаружи которого нет точек. В пересечении угла и плосокости [math]ABC[/math] образуется тетраэдр. Если в нем есть точки, то точки есть внутри треугольника, тогда это не триангуляция [math]\implies[/math] точек в тетраэдре нет [math]\implies[/math] плоскостью [math]ABC[/math] можно отделить пространство с точками [math]\implies[/math] выполняется глобальный критерий.
[math]\triangleleft[/math]

Будем называть хорошими те рёбра, для которых выполняется локальный критерий Делоне.

Лемма (4):
Из двух рёбер, которые можно провести для пары треугольников, как минимум одно хорошее.
nothumb
НЯ!
Эта статья полна любви и обожания.
Возможно, стоит добавить ещё больше?
nothumb


Задача:
Есть один станок и [math]n[/math] работ. Для каждой работы заданы время выполнения [math] p_i,[/math] дедлаин [math]d_i[/math] и стоимось выполнения этой работы [math]w_i \geqslant 0[/math]. Необходим минимизировать [math]\sum w_i U_i[/math].


Решение

Применим для решения данной задачи динамическое программирование.

Обозначим [math]T = \sum\limits_{i=1}^n p_i[/math]. Для всех [math]t = 0, 1, \ldots, T [/math] и [math]j = 1, \ldots, n[/math] будем рассчитывать [math]F_j(t)[/math] — значение целевой функции, при условии, что были рассмотрены первые [math]j[/math] работ и общее время выполнения тех из них, что будут закончены вовремя, не превышает времени [math]t[/math].

  1. Если [math]0 \leqslant t \leqslant d_j [/math] и работа [math]j[/math] успевает выполниться вовремя в расписании, соответствующем [math]F_j(t)[/math], то [math]F_j(t) = F_{j- 1}(t - p_j)[/math], иначе [math]F_j(t) = F_{j- 1}(t) + w_i[/math].
  2. Если [math]t \gt d_j[/math], то [math]F_j(t) = F_{j}(d_j)[/math], поскольку все работы с номерами [math]j = 1, \ldots, j[/math], законченные позже, чем [math] d_j \geqslant \ldots \geqslant d_1 [/math], будут выполнены с опозданием.

Отсюда, получим соотношение:

[math] F_j(t) = \left \{\begin{array}{ll} \min(F_{j-1}(t-p_j), F_{j-1}(t) + w_j), & 0 \leqslant t \leqslant d_j \\ F_j(d_j), & d_j \lt t \lt T \end{array} \right. [/math]

В качестве начальных условий следует взять [math]F_j(t) = \infty [/math] при [math]t \lt 0, j = 0,\ldots, n [/math] и [math]F_0(t) = 0 [/math] при [math]t \geqslant 0 [/math].

Ответом на задачу будет [math]F_n(d_n)[/math].

Приведенный ниже алгоритм вычисляет [math]F_j(t)[/math] для [math]j = 0,\ldots, n [/math] и [math]t = 0,\ldots, d_j [/math]. За [math]p_{max}[/math] обозначим самое большое из времен выполнения заданий.

 отсортиртировать работы по неубыванию времен дедлайнов [math]d_i[/math]
 [math]t_1[/math] = [math]r_1[/math]
 for [math]t = -p_{max}[/math] to [math]-1[/math]
   for [math]j = 0[/math] to [math]n[/math]
     F_j(t) = \infty
 for [math]t = 0[/math] to [math]T[/math]
   F_0(t) = 0
 for [math]j = 1[/math] to [math]n[/math]
   for [math]t = 0[/math] to [math]d_j[/math]
     if [math] F_{j-1}(t) + w_j  \lt  F_{j-1}(t-p_j) [/math]   
        [math] F_j(t) = F_{j-1}(t) + w_j [/math]
     else
       [math]  F_j(t) = F_{j-1}(t-p_j) [/math]
   for [math]t = d_j + 1[/math] to [math]T[/math]
     [math] F_j(t) = F_{j}(d_j) [/math]

Время работы данного алгоритма — [math]O(n \sum\limits_{i=1}^n p_i)[/math].

Для того, чтобы найти само расписание, по доказанной ниже лемме, нам достаточно найти множество работ, которые будут выполнены с опозданием. Это может быть сделано следующим способом:

 t = d_n
 L = \varnothing
 for [math]j = n[/math] downto [math]1[/math]
   [math]t = \min(t, d_j)[/math]
   if [math] F_j(t) = F_{j-1}(t) + w_j [/math] 
     [math] L = L \cup \{j\} [/math] </tex>
   else
     [math] t = t - p_j [/math]

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

Лемма:
Пусть все работы отсортированы в порядке неубывания дедлайнов [math]d_i[/math]. Тогда существует оптимальное расписание вида [math]i_1, i_2, \ldots, i_s, i_{s+1}, \ldots, i_n [/math], такое, что [math]i_1 \lt i_2 \lt \ldots \lt i_s [/math] — номера работ, которые успеют выполниться вовремя, а [math]i_{s+1}, \ldots, i_n [/math] — номера просроченных работ.
Доказательство:
[math]\triangleright[/math]

Пусть у нас есть некоторое оптимальное раписание [math]S[/math]. Получим необходимое нам расписание путем переставления некоторых работ.

  1. Если работа с номером [math] i[/math] выполнится в [math]S[/math] с опозданием, то переставим эту работу в конец. При этом, так как работа просрочна в оптимальном расписании [math]S[/math], при такой перестановке не произойдет увеличения целевой функции.
  2. Если работы с номерами [math]i[/math] и [math]j[/math] в расписании [math]S[/math] выполняются вовремя, но при этом [math]d_i \lt d_j [/math], но [math]j[/math] стоит в [math]S[/math] раньше [math]i[/math]. Тогда переставим работу с номером [math]j[/math] так, чтобы она выполнялась после работы [math]i[/math]. Таким образом, каждая из работ, находившихся в [math]S[/math] между [math]j[/math] и [math]i[/math], включая [math]i[/math], будет выполняться в новом расписании на [math]p_j[/math] единиц времени раньше. Эта перестановка не повлияет на оптимальнось расписания:
    • Ни одна из работ, котарая успевала выполниться в расписании [math]S[/math], не попадет в список просроченных работ при переставлении её на более раннее время.
    • Число работ, не успевающих выполниться вовремя, не может уменьшится, иначе бы возникло противоречие в исходным выбором [math]S[/math], как оптимального решения.
    • Поскольку [math]d_i \lt d_j [/math] и работа [math]i[/math] будет заканчиваться на [math]p_j[/math] единиц времени раньше, то стоящая сразу послее нее работа [math]j[/math] тоже будет успевать выполниться.
[math]\triangleleft[/math]

См. также

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

  • P. Brucker. Scheduling Algorithms (2006), 5th edition, стр. 26 - 28