Изворни код странице Алгоритми/Математичке основе

Пре него што почнемо да се бавимо алгоритамским техникама, морамо да изучимо неопходне математичке основе (математички апарат). Прво ћемо да покријемо математичке дефиниције термина који се користе у књизи. Проширењем математичког вокабулара, бићете много прецизнији и у стању да много једноставније формулишете проблем. Затим ћемо обрадити технике анализе времена извршења алгоритма. После сваког битног алгоритма који је обрађен у књизи, следи анализа времена извршења и доказ исправности.

==Асимптотска нотација==

Уз исправност, важна одлика корисног алгоритма је време извршења и утрошени меморијски простор. Време и меморија су важни ресурси и међу њима постоји битна разлика у начину коришћења, чак и ако их има у изобиљу.
Како се може измерити потрошња ресурса? Један начин је да направите функцију која одражава њихово употребу у односу на неке карактеристике улаза. Једна од уобичајених карактеристика улаза је величина скупа података. На пример, претпоставимо да је улаз неког алгоритма вектор од <math>n</math> целих бројева. Време извршења алгортма можемо да опишемо функцијом <math>f</math> која зависи од <math>n</math>.

:<math>f(n) = n^2 + 3n + 14</math>

где је вредност функције <math>f(n)</math> изражена у некој јединици времена. (У овом разматрању главни фокус је на времену, али исто може да се примени и на утрошак меморије). Ретко се као  јединица времена користи секунда, јер време извршења зависи од машине, њеног оперативног система и тренутног оптерећења. Уместо у секундама, време се најчешће изражава као потребан број неких основних операција рачунара. На пример, неке од основних операција које се користе су: потребан број сабирања или множења; број поређења (компарација); изведени број замена меморијских локација; или број извршених машинских инструкција. Генерално, могли бисмо се реферисати само на извршење наведених основних операција.

Да ли је ово добар приступ за одређивање утрошка ресурс једног алгоритма? И да и не. Када су два алгоритма слична по утрошку времена, може да помогне прецизна функција која би одредила који је алгоритам бржи у датим условима. Али у многим случајевима је тешко или немогуће дати тачан аналитички опис потребног броја операција, нарочито када алгоритам извршава операције условно - у зависности од вредности улаза. Уместо тога, оно што је заиста важно није тачно време потребно да се изврши одређена функција, већ степен промене утрошка ресурса у зависности од улаза. Конкретно, размотрићемо две приказане функције које дају потребно време извршења у односу на величину улазног скупа података:

:<math>f(n) = n^3-12n^2+20n+110</math>
:<math>g(n) = n^3+n^2+5n+5</math>

Оне изгледају прилично различито, али како се понашају? Погледајмо неколико графика ових функција (<math>f(n)</math> у црвеној, <math>g(n)</math>  у плавој боји):

{| border = 0
| [[Датотека:Algorithms-Asymptotic-ExamplePlot1.png|оквир|Графикони f и g, за опсег 0 до 5]] || [[Датотека:Algorithms-Asymptotic-ExamplePlot2.png|оквир|Графикони f и g, за опсег 0 до 15]]
|-
| [[Датотека:Algorithms-Asymptotic-ExamplePlot3.png|оквир|Графикони f и g, за опсег 0 до 100]] || [[Датотека:Algorithms-Asymptotic-ExamplePlot4.png|оквир|Графикони f и g, за опсег 0 до 1000]] <br>
|}


У првом, јако ограниченом графику криве изгледају различито. У другом криве крећу у сличном правцу, у трећем постоји само мала разлика и у последњем су скоро идентичне. У ствари оне се приближавају доминантном члану. Што је n веће, остали чланови постају мање значајни у односу на <math>n^3</math>.
Као што се може видети, промена коефицијената чланова нижег реда алгоритма полиномијалног времена не помаже много. Оно што је стварно важно је коефицијент члана највишег реда. Зато смо усвојили посебну нотацију за ову врсту анализе. Тако је:

:<math>f(n) = n^3-12n^2+20n+110 = O(n^3)</math>

Занемарујемо чланове нижег реда. Можемо да кажемо да је:

:<math>O(\log {n}) \le O(\sqrt{n}) \le O(n) \le O(n \log {n}) \le O(n^2) \le O(n^3) \le O(2^n)</math>

Ово нам пружа начин да лакше поредимо различите алгоритме. За сортирање <math>n</math> елемената уметањем (insertion sort), потребно је реда величине <math>O(n^2)</math> корака. За сортирање спајањем (merge sort) потребно је <math>O(n \log {n})</math> корака. Тако, ако је скуп улазних података довољно велик, сортирање спајањем је брже од сортирања уметањем.

Генерално пишемо да важи:

:<math>f(n) = O(g(n))</math>

када је задовољено:

:<math>\exists c>0, \exists n_0> 0, \forall n\ge n_{0}: 0\le f(n)\le c\cdot g(n).</math>

Ово значи да <math>f(n) = O(g(n))</math> важи ако и само ако постоје константе <math>c</math> и <math>n_0</math> веће од нуле, тако да за сваки <math>n>n_0</math>, <math>f(n)</math> функција је позитивна и мања или једнака <math>c g(n)</math>.
Приметимо да знак једнакости који се користи у горњем запису, описује релацију између <math>f(n)</math> и <math>g(n)</math> , а не истинску еквивалентност. У светлу тога, неки дефинишу велико О у терминима скупова, тако да је:

:<math>f(n)\in O(g(n))</math>

када је:

:<math>f(n)\in \{f(n) : \exists c>0, \exists n_0> 0, \forall n\ge n_0: 0\le f(n)\le c\cdot g(n)\}.</math>

Велико O нотација је само горња граница – супремум; оба следећа исказа су тачна:

:<math>n^3 = O(n^4)</math>
:<math>n^4 = O(n^4)</math>

Ако узмемо да знак једнакости означава еквиваленцију, добићемо јако чудан резултат, тј. да је:

:<math>n^3 = n^4</math>

што је очигледна бесмислица. Зато је дефиниција на бази теорије скупова згодна. Забуна може да се избегне тиме што ћете знак једнакости интерпретирати као једносмеран тј.:

:<math>n^3 = O(n^4)</math>

не имплицира да важи и:

:<math>O(n^4) = n^3</math>

Увек држите О на десној страни знака једнакости.

==Велико омега==
Понекад нам није довољно да одредимо само горњу границу времена извршења неке функције. Велико омега нам даје доњу границу – инфинум. Генерално, кажемо да је:

:<math>f(n) = \Omega(g(n))</math>

када важи:

:<math>\exists c>0, \exists n_0> 0, \forall n\ge n_{0}: 0\le c\cdot g(n)\le f(n).</math>

тј. <math>f(n) = \Omega(g(n))</math> ако и само ако постоје константе c и n<sub>0</sub> такве да је за свако n>n<sub>0</sub>, f(n) позитивна и '''већа''' или једнака cg(n).
Тако, на пример, можемо да тврдимо да је:

:<math>n^2-2n = \Omega(n^2)</math>,  (c=1/2, n<sub>0</sub>=4) или
:<math>n^2-2n = \Omega(n)</math>, (c=1, n<sub>0</sub>=3),

али не можемо да је

:<math>n^2-2n = \Omega(n^3).</math>

==Велико тета==

Када је дата функција истовремено и O(g(n)) и &Omega;(g(n)), кажемо да је &Theta;(g(n)), и тада имамо тесне границе функције. Функција f(n) је &Theta;(g(n)) када важи:

:<math>\exists c_1>0, \exists c_2>0, \exists n_0> 0, \forall n\ge n_0 : 0\le c_1\cdot g(n)\le f(n)\le c_2\cdot g(n),</math>

Али у већини случајева када покушавамо да утврдимо да је задата функција <math>f(n) = \Theta(g(n))</math>, уместо да користимо горњу дефиницију, показујемо да је она истовремено и O(g(n)) и &Omega;(g(n)).

==Мало о и омега==

Када асимптотске границе нису тесне, то можемо да изразимо тако што кажемо да је <math>f(n) = o(g(n))</math> или <math>f(n) = \omega(g(n)).</math>. 
Дефинише се:

:f(n) је o(g(n)) акко <math>\forall c>0, \exists n_0> 0, \forall n\ge n_0: 0\le f(n) < c\cdot g(n)</math> и
:f(n) је &omega;(g(n)) акко <math>\forall c>0, \exists n_0> 0, \forall n\ge n_0: 0\le c\cdot g(n) < f(n).</math>

Приметимо да је функција f у o(g(n)) када за сваки коефицијент g, g на крају постаје већа од f, док је за O(g(n)) потребно да постоји један коефицијент за који g постаје најмање једнак f.

==Анализа алгоритама: решавање диференцних једначина==

За сортирање n елемената спајањем: <math>T(n) = 2*T(n/2) + c(n)</math>. Ово описује једну итерацију сортирања: простор проблема <math>n</math> се своди на две половине (<math>2*T(n/2)</math>), које се спајају по окончању свих рекурзивних позива (<math>c(n)</math>). Овај систем обележавања (нотација) је основа за анализу алгоритама, тако да треба што пре да се на њега навикнете.
Постоје теореме које можете да користите да би проценили време великог О за функцију чија се диференцна (рекурентна) једначина уклапа и одређени шаблон.

==Главна теорема==

Razmotrimo diferencnu jednačinu koja se uklapa u formulu:

:<math>T(n) = a T\left({\frac{n}{b}}\right) + O(n^k)</math>

зa ''a'' &ge; 1, ''b'' > 1 и ''k'' &ge; 0. Овде је a број рекурзивних позива за један позив функције, ''n'' је величина улаза, ''b'' је фактор за који се улаз смањује и ''k'' је полиномијални ред операције која се појављује сваки пут када се позове функција (осим за базне случајеве). На пример, код алгоритма сортирања спајањем, који ћемо покрити касније, имамо да је

:<math>T(n) = 2 T\left({\frac{n}{2}}\right) + O(n)</math>

зато што се два потпроблема позивају (решавају) за сваку итерацију случаја који није базни и величина вектора се сваки пут дели на пола. <math>O(n)</math> је на крају „победнички“ део ове поделе и победнички алгоритам: он троши линеарно време за спајање резултата два рекурзивна позива у један коначни резултат.

Ако замислимо рекурзивне позиве ''T'' као формирање стабла, постоје три могућа случаја у којима може да се утврди где се већина времена извршења алгоритма троши („већина“ у смислу који се односи на његово асимптотско понашање): 

# стабло може да буде '''разгранато при врху''' и тада се већина времена се троши за време позива близу корена;
# стабло може да буде '''уравнотежено''', када је утрошак времена равномерно распоређен;
# стабло може да буде '''разгранато при дну''', када се већина времена троши на позиве близу листова. 

У зависности од тога у ком се од три наведена статуса стабло налази, ''T'' ће имати другачију сложеност:

<div style="background-color: #FFFFEE; border: solid 1px #FFC92E; padding: 1em; width: 80%;" valign=top>'''Главна теорема'''<br>

Дато <math>T(n) = a T\left({\frac{n}{b}}\right) + O(n^k)</math> for ''a'' &ge; 1, ''b'' > 1 and ''k'' &ge; 0:
* Ако је <math>a < b^k</math>, онда <math>T(n) = O(n^k)\ </math> (разгранато при врху)
* Ако је <math>a = b^k</math>, онда <math>T(n) = O(n^k\cdot \log n)</math> (уравнотежено)
* Ако је <math>a > b^k</math>, онда <math>T(n) = O(n^{\log_b a})</math> (разгранато при дну)
</div>

За горњи случај сортирања спајањем

:<math>T(n) = 2 T\left({\frac{n}{2}}\right) + O(n)</math>

имамо да је

:<math>a=2, b=2, k=1\implies b^k = 2</math>

из чега следи да је <math>a = b^k</math>, што чини да је стабло уравнотежено. Према главној теореми сложеност сортирања спајањем је 

:<math>T(n) = O(n^1\log n) = O(n \log n)</math>.