Чи існує система, що стоїть за магією аналізу алгоритму?

Є багато запитань щодо того, як проаналізувати час виконання алгоритмів (див., Наприклад, час виконання та алгоритм аналізу ). Багато з них схожі, наприклад, ті, хто запитує аналіз витрат вкладених циклів або алгоритмів ділення та підкорення, але, здається, більшість відповідей зроблені спеціально.

З іншого боку, відповіді на інше загальне запитання пояснюють більшу картину (зокрема, стосовно асимптотичного аналізу) на деяких прикладах, але не про те, як забруднити руки.

Чи існує структурований загальний метод аналізу вартості алгоритмів? Вартість може бути часом роботи (складністю часу) або іншим показником витрат, таким як кількість виконаних порівнянь, складність простору чи щось інше.

^{Це має стати еталонним питанням, яке можна використовувати для вказівки на початківців; отже, її більш широка, ніж зазвичай, сфера застосування. Будь ласка, не забудьте дати загальні, дидактично представлені відповіді, які проілюстровані хоча б одним прикладом, але, тим не менш, охоплюють багато ситуацій. Дякую!}

Переклад коду на математику

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

Приклад: Порівняння в Bubblesort

Розглянемо цей алгоритм, який сортує заданий масив A:

 bubblesort(A) do                   1
  n = A.length;                     2
  for ( i = 0 to n-2 ) do           3
    for ( j = 0 to n-i-2 ) do       4
      if ( A[j] > A[j+1] ) then     5
        tmp    = A[j];              6
        A[j]   = A[j+1];            7
        A[j+1] = tmp;               8
      end                           9
    end                             10
  end                               11
end                                 12

Скажімо, ми хочемо провести звичайний аналіз алгоритму сортування, тобто підрахувати кількість порівнянь елементів (рядок 5). Відразу зазначимо, що ця величина не залежить від вмісту масиву A, лише від його довжини . Таким чином, ми можемо перекласти (вкладені) -крутки буквально буквально на (вкладені) суми; змінна циклу стає змінною підсумовування і діапазон переноситься. Ми отримуємо:$n$for

,$\qquad\displaystyle C_{\text{cmp}}(n) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \dots = \frac{n(n-1)}{2} = \binom{n}{2}$

де - вартість кожного виконання рядка 5 (який ми рахуємо).$1$

Приклад: Обміни в Bubblesort

Я позначу через підпрограму, що складається з рядків до та C i , j витрати на виконання цієї підпрограми (один раз).$P_{i,j}$ij$C_{i,j}$

Тепер скажімо, що ми хочемо порахувати свопи , тобто часто виконується . Це "базовий блок", тобто підпрограма, яка завжди виконується атомно і має деяку постійну вартість (тут, 1 ). Укладання таких блоків - це одне корисне спрощення, яке ми часто застосовуємо, не задумуючись і не розмовляючи про це.$P_{6,8}$$1$

З аналогічним перекладом, як описано вище, ми приходимо до наступної формули:

.$\qquad\displaystyle C_{\text{swaps}}(A) = \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$

позначає стан масиву перед ( i , j ) -ю ітерацією P 5 , 9 .$A^{(i,j)}$$(i,j)$$P_{5,9}$

Зауважте, що я використовую замість n як параметр; ми скоро зрозуміємо, чому. Я не додаю i і j як параметри C 5 , 9, оскільки витрати тут не залежать від них (в єдиній моделі витрат , тобто); загалом, вони просто можуть.$A$$n$$i$$j$$C_{5,9}$

Зрозуміло, що витрати на залежать від змісту A (значення та , зокрема), тому ми маємо це враховувати. Зараз перед нами стоїть виклик: як ми «розмотуємо» C 5 , 9 ? Що ж, ми можемо зробити залежність від змісту A явною:$P_{5,9}$$A$A[j]A[j+1]$C_{5,9}$$A$

.$\qquad\displaystyle C_{5,9}(A^{(i,j)}) = C_5(A^{(i,j)}) + \begin{cases} 1 &, \mathtt{A^{(i,j)}[j] > A^{(i,j)}[j+1]} \\ 0 &, \text{else} \end{cases}$

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

1. Найгірший випадок

   Тільки переглянувши суму і зазначивши, що , ми можемо знайти тривіальну верхню межу вартості:$C_{5,9}(A^{(i,j)}) \in \{0,1\}$

   .$\qquad\displaystyle C_{\text{swaps}}(A) \leq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 1 = \frac{n(n-1)}{2} = \binom{n}{2}$

   Але це може статися , тобто чи досягнуто для цієї верхньої межі? Як виявляється, так: якщо ми вводимо зворотно відсортований масив попарно відмінних елементів, кожна ітерація повинна здійснювати своп¹. Таким чином, ми вивели точну найгірше число свопів BubbleSort.$A$

2. Найкращий випадок

   І навпаки, існує тривіальна нижня межа:

   .$\qquad\displaystyle C_{\text{swaps}}(A) \geq \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} 0 = 0$

   Це також може статися: на масиві, який вже відсортований, Bubblesort не виконує жодного свопу.

3. Середній випадок

   Найгірший і найкращий випадок відкриває досить прогалину. Але яка типова кількість свопів? Для того, щоб відповісти на це запитання, нам потрібно визначити, що означає «типовий». Теоретично у нас немає причин віддавати перевагу одному входу над іншим, тому ми зазвичай припускаємо рівномірний розподіл на всіх можливих входах, тобто кожен вхід є однаково вірогідним. Обмежимось масивами з парно розрізненими елементами і, таким чином, припустимо модель випадкової перестановки .

   Тоді ми можемо переписати наші витрати так:

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \sum_{i=0}^{n-2} \sum_{j=0}^{n-i-2} C_{5,9}(A^{(i,j)})$

   Тепер нам належить вийти за рамки простого маніпулювання сумами. Дивлячись на алгоритм, ми зазначимо, що кожен своп видаляє рівно одну інверсію в (ми лише коли-небудь міняємо сусіди³). Тобто, число свопів , виконаних на А саме число інверсій INV ( A ) від . Таким чином, ми можемо замінити внутрішні дві суми і отримати$A$$A$$\operatorname{inv}(A)$$A$

   .$\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{n!} \sum_{A} \operatorname{inv}(A)$

   Пощастило для нас, середня кількість інверсій визначена

   $\qquad\displaystyle \mathbb{E}[C_{\text{swaps}}] = \frac{1}{2} \cdot \binom{n}{2}$

   який наш кінцевий результат. Зауважте, що це рівно половина найгірших витрат.

1. Зауважимо, що алгоритм був ретельно сформульований так, що "остання" ітерація i = n-1зовнішнього циклу, який ніколи нічого не робить, не виконується.
2. " " - математичне позначення для "очікуваного значення", яке тут просто середнє.$\mathbb{E}$
3. Ми довідаємось, що жоден алгоритм, який замінює лише сусідні елементи, не може бути асимптотично швидшим, ніж Bubblesort (навіть у середньому) - кількість інверсій є нижньою межею для всіх таких алгоритмів. Це стосується, наприклад, сортування вставки та сортування вибору .

Загальний метод

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

Позначимо з поточний стан (уявимо це як набір змінних призначень). Коли ми виконуємо програму, починаючи з стану ψ , ми закінчуємо стан ψ / P (за умови припинення).$\psi$P$\psi$$\psi / \mathtt{P}$P

• Індивідуальні заяви

  Враховуючи лише одне твердження S;, ви присвоюєте йому вартість . Зазвичай це буде постійною функцією.$C_S(\psi)$

• Вирази

  Якщо у вас є вираз Eформи E1 ∘ E2(скажімо, арифметичний вираз, де ∘може бути додавання чи множення, ви складаєте витрати рекурсивно:

  .$\qquad\displaystyle C_E(\psi) = c_{\circ} + C_{E_1}(\psi) + C_{E_2}(\psi)$

  Зауважте, що

  • експлуатаційні витрати можуть бути не постійними, але залежать від значень E 1 і E 2 і$c_{\circ}$$E_1$$E_2$
  • оцінка виразів може змінити стан багатьох мов,

  тому вам, можливо, доведеться бути гнучкими з цим правилом.

• Послідовність

  Давши програму Pяк послідовність програм Q;R, ви додаєте витрати до

  .$\qquad\displaystyle C_P(\psi) = C_Q(\psi) + C_R(\psi / \mathtt{Q})$

• Умовні умови

  Враховуючи програму Pформи if A then Q else R end, витрати залежать від держави:

  $\qquad\displaystyle C_P(\psi) = C_A(\psi) + \begin{cases} C_Q(\psi/\mathtt{A}) &, \mathtt{A} \text{ evaluates to true under } \psi \\ C_R(\psi/\mathtt{A}) &, \text{else} \end{cases}$

  Загалом, оцінка Aможе дуже змінити стан, отже, оновлення витрат окремих галузей.

• For-Loops

  Враховуючи програму Pформи for x = [x1, ..., xk] do Q end, призначте витрати

  $\qquad\displaystyle C_P(\psi) = c_{\text{init_for}} + \sum_{i=1}^k c_{\text{step_for}} + C_Q(\psi_i \circ \{\mathtt{x := xi\}})$

  $\psi_i$Qxixx1xi-1

  $c_{\text{init_for}}$$c_{\text{step_for}}$

  • обчислення наступних xiможе бути дорогим і
  • a for-loop з порожнім корпусом (наприклад, після спрощення в найкращому випадку з конкретною вартістю) не має нульової вартості, якщо він виконує ітерації.

• Хоча-петлі

  Враховуючи програму Pформи while A do Q end, призначте витрати

  $\qquad\displaystyle C_P(\psi) \\\qquad\ = C_A(\psi) + \begin{cases} 0 &, \mathtt{A} \text{ evaluates to false under } \psi \\ C_Q(\psi/\mathtt{A}) + C_P(\psi/\mathtt{A;Q}) &, \text{ else} \end{cases}$

  Перевіряючи алгоритм, ця повторюваність часто може бути представлена ​​красиво як сума, подібна до тієї для for-циклів.

  Приклад: Розглянемо цей короткий алгоритм:

  while x > 0 do    1
    i += 1          2
    x = x/2         3
  end               4
  

  Застосовуючи правило, ми отримуємо

  $\qquad\displaystyle C_{1,4}(\{i := i_0; x := x_0\}) \\\qquad\ = c_< + \begin{cases} 0 &, x_0 \leq 0 \\ c_{+=} + c_/ + C_{1,4}(\{i := i_0 + 1; x := \lfloor x_0/2 \rfloor\}) &, \text{ else} \end{cases}$

  $c_{\dots}$ix

  $C_{1,4}$i

  $\qquad\displaystyle C_{1,4}(x) = \begin{cases} c_> &, x \leq 0 \\ c_> + c_{+=} + c_/ + C_{1,4}(\lfloor x/2 \rfloor) &, \text{ else} \end{cases}$

  Це вирішується елементарними засобами до

  $\qquad\displaystyle C_{1,4}(\psi) = \lceil \log_2 \psi(x) \rceil \cdot (c_> + c_{+=} + c_/) + c_>$

  $\psi = \{ \dots, x := 5, \dots\}$$\psi(x) = 5$

• Процедурні дзвінки

  З огляду на програму Pформи M(x)для деяких параметрів, xде Mце процедура з (іменованим) параметром p, призначте витрати

  $\qquad\displaystyle C_P(\psi) = c_{\text{call}} + C_M(\psi_{\text{glob}} \circ \{p := x\})$

  $c_{\text{call}}$$\psi$

  Я розглядаю деякі смислові питання, які у вас можуть виникнути з державою тут. Ви хочете розрізнити глобальний стан та такі локальні для процедури дзвінки Давайте припустимо , що ми тільки пройти глобальнестан тут і Mотримують нове локальне стан, ініційовані, встановивши значення pдля x. Крім того, це xможе бути вираз, який ми (як правило) вважаємо оціненим перед його передачею.

  Приклад: Розглянемо процедуру

  fac(n) do                  
    if ( n <= 1 ) do         1
      return 1               2
    else                     3
      return n * fac(n-1)    4
    end                      5
  end                        
  

  Згідно з правилами, ми отримуємо:

  $\qquad\displaystyle\begin{align*} C_{\text{fac}}(\{n := n_0\}) &= C_{1,5}(\{n := n_0\}) \\ &= c_{\leq} + \begin{cases} C_2(\{n := n_0 \}) &, n_0 \leq 1 \\ C_4(\{n := n_0 \}) &, \text{ else} \end{cases} \\ &= c_{\leq} + \begin{cases} c_{\text{return}} &, n_0 \leq 1 \\ c_{\text{return}} + c_* + c_{\text{call}} + C_{\text{fac}}(\{n := n_0 - 1\}) &, \text{ else} \end{cases} \end{align*}$

  Зауважте, що ми нехтуємо глобальною державою, оскільки facявно не отримуємо жодного доступу. Цей конкретний повтор легко вирішити

  $\qquad\displaystyle C_{\text{fac}}(\psi) = \psi(n) \cdot (c_{\leq} + c_{\text{return}}) + (\psi(n) - 1) \cdot (c_* + c_{\text{call}})$

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

Якщо ви зараз думаєте , що це занадто складно, порадьте: вона є ! Отримати точні витрати на алгоритми в будь-якій моделі, настільки близькій до реальних машин, що дозволяє передбачити час виконання (навіть відносні) - важке починання. І це навіть не враховуючи кешування та інші неприємні ефекти на реальних машинах.

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

Примітка про асимптотичну вартість

$n$

Це (найчастіше) справедливо, оскільки абстрактні висловлювання фактично мають деякі (як правило, невідомі) витрати, залежно від машини, операційної системи та інших факторів, і короткий час виконання може домінувати в операційній системі, яка налаштовує процес в першу чергу і багато чого іншого. Таким чином, ви все одно отримаєте деяке збурення.

Ось як асимптотичний аналіз стосується цього підходу.

1. Визначте домінуючі операції (що спричиняють витрати), тобто операції, які відбуваються найчастіше (аж до постійних факторів). У прикладі Bubblesort одним із можливих варіантів є порівняння у рядку 5.

   Крім того, зв'язати всі константи для елементарних операцій їх максимальним (зверху) відповідним. їх мінімум (знизу) та виконують звичайний аналіз.

2. Виконайте аналіз, використовуючи кількість операцій цієї операції як вартість.
3. $O$$\Omega$

$O$

Подальше читання

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

• Як придумати виконання алгоритмів?
  Як описати алгоритми, довести та проаналізувати їх?
• Навіщо використовувати порівняння замість часу виконання для порівняння двох алгоритмів?
  Як можна припустити, що основні операції над числами займають постійний час?
  Що становить одну одиницю часу в аналізі часу виконання?
• Розв’язування або наближення відношень повторення для послідовностей чисел
• Основи амортизованого аналізу

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

Кількість виписок про виконання

Існує ще один метод, який підтримує Дональд Е. Кнут у серії "Мистецтво комп'ютерного програмування ". На відміну від перекладу всього алгоритму в одну формулу , він працює незалежно від семантики коду на стороні "складання речей" і дозволяє перейти на нижчий рівень лише в разі необхідності, починаючи з погляду "орлиного ока". Кожне твердження можна аналізувати незалежно від решти, що веде до більш чітких розрахунків. Однак техніка добре піддається досить детальному коду, не так сильно псевдокоду вищого рівня.

Метод

У принципі це досить просто:

1. Призначте кожному оператору ім'я / номер.
2. $S_i$$C_i$
3. $S_i$$e_i$

4. Обчисліть загальні витрати

   $\qquad\displaystyle C = \sum_{i} e_i \cdot C_i$

Ви можете вставити оцінки та / або символічні величини в будь-яку точку, послаблюючи відповідність. узагальнення результату відповідно.

$e_{77} \in O(n \log n)$

Приклад: Перший глибинний пошук

Розглянемо наступний алгоритм переходу графіків:

dfs(G, s) do
  // assert G.nodes contains s
  visited = new Array[G.nodes.size]     1
  dfs_h(G, s, visited)                  2
end 

dfs_h(G, s, visited) do
  foo(s)                                3
  visited[s] = true                     4

  v = G.neighbours(s)                   5
  while ( v != nil ) do                 6
    if ( !visited[v] ) then             7
      dfs_h(G, v, visited)              8
    end
    v = v.next                          9
  end
end

$\{0,\dots,n-1\}$$m$

$A$$B$$C$$e_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & A & A & B & B & B & B+C & C & B-1 & C \end{array}$

Зокрема, $e_8 = e_3-1$foodfs$e_6 = e_5 + e_7$while

$A=1$foo$B = n$$C = 2m$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline e_i & 1 & 1 & n & n & n & 2m + n & 2m & n-1 & 2m \end{array}$

Це призводить нас до загальних витрат точно

$\qquad\begin{align*} C(n,m) = (C_1 + C_2 - C_8) &+\ n \cdot (C_3 + C_4 + C_5 + C_6 + C_8) \\ &+\ 2m \cdot (C_6 + C_7 + C_9) \;. \end{align*}$

$C_i$

$\qquad\begin{array}{c|ccccccccc} i & 1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\ \hline C_i & n & 0 & 0 & 1 & 1 & 0 & 1 & 0 & 1 \end{array}$

і дістати

$\qquad\displaystyle C_{\text{mem}}(n,m) = 3n + 4m$

Подальше читання

Дивіться внизу моєї іншої відповіді .

Аналіз алгоритмів, як і доказ теореми, є значною мірою мистецтвом (наприклад, є прості програми (наприклад, проблема Колатца ), які ми не знаємо, як проаналізувати). Ми можемо перетворити задачу складності алгоритму в математичну, на яку всебічно відповів Рафаель , але тоді для того, щоб виразити обмеженість вартості алгоритму з точки зору відомих функцій, ми залишаємо:

1. Використовуйте методи, які ми знаємо з існуючих аналізів, таких як пошук меж на основі повторень, які ми розуміємо, або суми / інтегралів, які ми можемо обчислити.
2. Змініть алгоритм на щось, що ми знаємо, як проаналізувати.
3. Придумайте абсолютно новий підхід.