Як описати алгоритми, довести та проаналізувати їх?

Перш ніж читати «Мистецтво комп’ютерного програмування» (TAOCP) , я глибоко не розглядав ці питання. Я б використовував псевдо-код для опису алгоритмів, розуміння їх та оцінки часу виконання лише щодо порядків зростання. TAOCP ретельно змінює свою думку.

TAOCP використовує англійську мову, змішану з кроками та goto, для опису алгоритму, а також використовує діаграми потоків для більш легкого зображення алгоритму. Це здається низьким, але я вважаю, що є деякі переваги, особливо з блок-схемою, яку я багато ігнорував. Ми можемо позначити кожну зі стрілок твердженням про поточний стан справ у момент, коли обчислення проходить цю стрілку, і зробити індуктивний доказ алгоритму. Автор каже:

Автор стверджує, що ми дійсно розуміємо, чому алгоритм дійсний лише тоді, коли ми досягнемо того, що наш розум неявно заповнив усі твердження, як це було зроблено на рис.4.

Я такого не відчував. Ще одна перевага полягає в тому, що ми можемо порахувати кількість разів, які виконують кожен крок. Це легко перевірити за допомогою першого закону Кірхгофа. Я точно не проаналізував час роботи, тому деякі можливо, були опущені, коли я оцінював час роботи.$\pm1$

Аналіз порядків зростання іноді марний. Наприклад, ми не можемо відрізнити quicksort від гипсорта, оскільки всі вони є , де - очікуване число випадкової величини , тому ми повинні проаналізувати постійну, скажімо, і , таким чином ми можемо порівняти і краще. А також, іноді нам слід порівнювати інші кількості, наприклад, дисперсії. Недостатньо лише грубого аналізу порядків зростання часу роботи. Як TAOCP$E(T(n))=\Theta(n\log n)$$EX$$X$$E(T_1(n))=A_1n\lg n+B_1n+O(\log n)$T 1 T $E(T_2(n))=A_2\lg n+B_2n+O(\log n)$$T_1$$T_2$ переводить алгоритми в мову складання і обчислює час роботи. Мені це занадто важко, тому я хочу знати деякі методи аналізу трохи більш грубого часу, що також корисно для мов вищого рівня, таких як C, C ++ або псевдокоди.

І я хочу знати, який стиль опису використовується в основному в науково-дослідних роботах та як лікувати ці проблеми.

Існує величезна різноманітність можливих підходів. Що найкраще підходить, залежить від

• що ви намагаєтесь показати,
• скільки деталей ви хочете чи потребуєте.

Якщо алгоритм широко відомий, який ви використовуєте як підпрограму, ви часто залишаєтеся на більш високому рівні. Якщо алгоритм є основним досліджуваним об’єктом, ви, ймовірно, хочете бути більш детальним. Те саме можна сказати і для аналізів: якщо вам потрібна приблизна верхня межа виконання, ви поступаєте інакше, ніж потрібні точні підрахунки тверджень.

Я наведу вам три приклади для відомого алгоритму Mergesort, який, сподіваємось, це ілюструє.

Високий рівень

Алгоритм Mergesort приймає список, розбиває його на дві (приблизно) однаково довгі частини, повторюється за цими частковими списками і об'єднує (сортував) результати так, щоб кінцевий результат був відсортований. У одиночному або порожньому списках він повертає вхід.

Цей алгоритм, очевидно, є правильним алгоритмом сортування. Розбиття списку та його об'єднання може бути реалізоване у часі , що дає нам повтор у найгіршому випадку виконання T ( n ) = 2 T ( $\Theta(n)$. За теоремою Майстра це оцінюється заT(n)∈Θ(nlogn).$T(n) = 2T\left(\frac{n}{2}\right) + \Theta(n)$$T(n) \in \Theta(n\log n)$

Середній рівень

Алгоритм Mergesort задається наступним псевдокодом:

procedure mergesort(l : List) {
  if ( l.length < 2 ) {
    return l
  }

  left  = mergesort(l.take(l.length / 2)
  right = mergesort(l.drop(l.length / 2)
  result = []

  while ( left.length > 0 || right.length > 0 ) {
    if ( right.length == 0 || (left.length > 0 && left.head <= right.head) ) {
      result = left.head :: result
      left = left.tail
    }
    else {
      result = right.head :: result
      right = right.tail
    }
  }

  return result.reverse
}

Доводимо правильність за допомогою індукції. Для списків довжиною нульовою або одиничною алгоритм є тривіально правильним. Як гіпотеза про індукцію, припустимо, що вона mergesortвиконує правильно у списках довжини не більше для деякого довільного, але фіксованого природного n > 1 . Тепер нехай L - список довжини n + 1 . За індукційною гіпотезою та утримуйте (не зменшуючи) відсортовані версії першої респ. друга половина L після рекурсивних викликів. Тому цикл вибирає в кожній ітерації найменший ще не досліджений елемент і додає його ; таким чином , це не все більш відсортований список, що містить усі елементи з$n$$n>1$$L$$n+1$leftright$L$whileresultresultleftі right. Зворотна сторона - це не зменшувана сортована версія , яка є поверненим - і бажаним - результатом.$L$

Щодо часу виконання, порахуймо порівняння елементів та перерахуємо операції (які домінують під час виконання асимптотично). Списки довжиною менше двох не викликають жодного. Для списків довжиною ми маємо ті операції, викликані підготовкою входів для рекурсивних викликів, тих із самих рекурсивних викликів плюс циклу та однієї . Обидва рекурсивних параметра можна обчислити з не більше n операцій зі списком. Цикл виконується рівно п раз і кожній ітерації причини не більше одного елемента порівняння і рівно два списки операцій. Фінал може бути реалізований з використанням 2 $n>1$whilereverse$n$while$n$reverse$2n$операції зі списком - кожен елемент видаляється із вхідних даних та заноситься у вихідний список. Отже, кількість операцій відповідає наступному повторенню:

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq T\left(\left\lceil\frac{n}{2}\right\rceil\right) + T\left(\left\lfloor\frac{n}{2}\right\rfloor\right) + 7n\end{align}$

Оскільки явно не зменшується, для асимптотичного зростання достатньо врахувати n = 2 k . У цьому випадку рецидив спрощується до$T$$n=2^k$

$\qquad \begin{align}T(0) = T(1) &= 0 \\ T(n) &\leq 2T\left(\frac{n}{2}\right) + 7n\end{align}$

За теоремою Мастера отримуємо який поширюється на час виконання .$T \in \Theta(n \log n)$mergesort

Наднизький рівень

Розглянемо цю (узагальнену) реалізацію Mergesort в Ізабелі / HOL :

types dataset  =  "nat * string"

fun leq :: "dataset \<Rightarrow> dataset \<Rightarrow> bool" where
   "leq (kx::nat, dx) (ky, dy) = (kx \<le> ky)"

fun merge :: "dataset list \<Rightarrow> dataset list \<Rightarrow> dataset list" where
"merge [] b = b" |
"merge a [] = a" |
"merge (a # as) (b # bs) = (if leq a b then a # merge as (b # bs) else b # merge (a # as) bs)"

function (sequential) msort :: "dataset list \<Rightarrow> dataset list" where
  "msort []  = []" |
  "msort [x] = [x]" |
  "msort l   = (let mid = length l div 2 in merge (msort (take mid l)) (msort (drop mid l)))"
by pat_completeness auto
  termination
  apply (relation "measure length")
by simp+

Це вже включає докази чітко визначеності та припинення. Знайти (майже) повний доказ коректності тут .

Для "часу виконання", тобто кількості порівнянь, можна встановити повторення, подібне до попереднього розділу. Замість використання теореми Мастера та забуття констант можна також проаналізувати її, щоб отримати наближення, яке асимптотично дорівнює справжній величині. Повний аналіз можна знайти в [1]; ось приблизний контур (він не обов'язково відповідає коду Ізабель / HOL):

Як і вище, повторність для кількості порівнянь є

$\qquad \begin{align}f_0 = f_1 &= 0 \\ f_n &= f_{\left\lceil\frac{n}{2}\right\rceil} + f_{\left\lfloor\frac{n}{2}\right\rfloor} + e_n\end{align}$

$e_n$$n$

$\qquad \displaystyle \begin{cases} f_{2m} &= 2f_m + e_{2m} \\ f_{2m+1} &= f_m + f_{m+1} + e_{2m+1} \end{cases}$

$f_n$$e_n$

$\qquad \displaystyle \sum\limits_{k=1}^{n-1} (n-k) \cdot \Delta\kern-.2em\nabla f_k = f_n - nf_1$

$\Delta\kern-.2em\nabla f_k$

$\qquad \displaystyle W(s) = \sum\limits_{k\geq 1} \Delta\kern-.2em\nabla f_k k^{-s} = \frac{1}{1-2^{-s}} \cdot \underbrace{\sum\limits_{k \geq 1} \frac{\Delta\kern-.2em\nabla e_k}{k^s}}_{=:\ \boxminus(s)}$

що разом з формулою Перрона веде нас до

$\qquad \displaystyle f_n = nf_1 + \frac{n}{2\pi i} \int\limits_{3-i\infty}^{3+i\infty} \frac{\boxminus(s)n^s}{(1-2^{-s})s(s+1)}ds$

$\boxminus(s)$

$\qquad \displaystyle f_n \sim n \cdot \log_2(n) + n \cdot A(\log_2(n)) + 1$

$A$$[-1,-0.9]$

1. Меллінові перетворення та асимптотика: повторення злиття Флайолета та Голіна (1992)
2. $e_n = \left\lfloor\frac{n}{2}\right\rfloor$
   $e_n = n-1$
   $e_n = n - \frac{\left\lfloor\frac{n}{2}\right\rfloor}{\left\lceil\frac{n}{2}\right\rceil + 1} - \frac{\left\lceil\frac{n}{2}\right\rceil}{\left\lfloor\frac{n}{2}\right\rfloor + 1}$

"Дисципліна програмування" Дейкстри - це все про аналіз та доведення алгоритмів та розробку доцільності. У передмові до цієї книги Дійкстра пояснює, як досить простого побудованого міні-мови, належним чином розробленого для аналізу, достатньо для формального пояснення багатьох алгоритмів:

Починаючи подібну книгу, відразу стикається з питанням: "Якою мовою програмування я буду користуватися?", А це непросто питання презентації! Найважливішим, але й найбільш невловимим аспектом будь-якого інструменту є його вплив на звички тих, хто навчає себе у його використанні. Якщо інструмент є мовою програмування, цей вплив - це нам подобається чи ні - вплив на наші мислячі звички. Проаналізувавши цей вплив, наскільки мені було відомо, я прийшов до висновку, що жодна із існуючих мов програмування, а також їх підмножина не відповідає моєму призначенню; з іншого боку, я знав себе настільки не готовим до створення нової мови програмування, що я дав обітницю не робити цього протягом наступних п’яти років, і у мене було найбільш чітке відчуття, що цей період ще не минув! (До цього, серед багатьох інших, ця монографія мала бути написана.

Пізніше він пояснює, наскільки маленьким він зумів отримати свою міні-мову.

Я завдячую читачеві пояснення, чому я зберегла міні-мову такою маленькою, що вона навіть не містить процедур та рекурсії. ... Справа в тому, що я не відчував потреби в них, щоб передати своє повідомлення, а саме. як ретельно обраний розбір питань має важливе значення для розробки якісних програм у будь-якому відношенні; скромні інструменти міні-мови дали нам вже більш ніж достатньо широти для нетривіальних, але дуже задовільних конструкцій.