1. Algoritmi

2. Metode Deli in vladaj Požrešna metoda
problem razdelimo na podprobleme, ki jih rešimo in dobljene podrešitve združimo v rešitev
Požrešna metoda
rešitev gradimo kot zaporedje odločitev, kaj spada v rešitev in kaj ne. Poglavitno delo - premislek v kakšnem vrstnem redu dodajamo rešitve

3. Metode Dinamično programiranje Sestopanje Razveji in omeji
zaporedje odločitev, ki vodi k optimalni rešitvi
Sestopanje
gradimo rešitev, odločitev po kateri poti, v primeru "slepe ulice" se vrnemo nazaj.
Razveji in omeji
gradimo rešitev, vodimo seznam možnih poti in odvržemo tiste, ki ne vodijo k pravi rešitvi

4. Deli in vladaj problem razdelimo na podprobleme te rešimo
rešitve združimo
podproblemi so lahko iste narave ali drugačne
Deli in vladaj bomo jemali v "ožjem smislu" - le za podprobleme iste narave

5. Deli in vladaj osnovni algoritem
deli in vladaj(a,dno,vrh, resitev)
/* resimo problem dolocen s podatki adno, …, avrh */
if problem majhen(dno,vrh) resi(a,dno,vrh,resitev)
else
s = deli(dno,vrh);
deli in vladaj(a, dno, s, resitev1);
deli in vladaj(a, s+1, vrh, resitev2);
zdruzi(a,dno,s,vrh,resitev1,resitev2,resitev);

6. Deli in vladaj
pomembno poiskati ravnovesje med deljenjem v globino in preprostostjo rešitve majhnega problema
deli naj razdeli podproblema na čim bolj enaka dela
združi včasih ni potrebna operacija
predstavitev pogosto rekurzivna

7. Hitro urejanje Izberi si delilni element razdeli na dva dela
<=x
>=x
z istim postopkom uredi oba dela

8. procedure qs_r(var t: tabela; l, d: integer) {
(* hitro uredi t od l do d *)
(* urejamo cela stevila *)
var
i, j, x: integer;
el: integer;
i := l; j := d; (* iskalca *)
x = t[l]; (* delilni element *)
while (i <= j) do begin
while (t[i]<x and i<d) do i := i + 1;
(* poisci prvega, ki ni manjsi *)
while (t[j]>x and j>l) do j := j - 1;
(* poisci prvega, ki ni vecji *)
if (i<=j) then begin (* zamenjaj *)
el := t[i];
t[i] := t[j];
t[j] := el;
i := i - 1; j := j - 1;
end;
if (l<j) qs_r(t,l,j); (* uredimo levo polovico *)
if (i<d) qs_r(t,i,d); (* uredimo desno polovico *)

9. Analiza zahtevno pričakovana zahtevnost: O(n log n)
na majhnih zaporedjih običajno nehamo in uporabimo kaj drugega
metoda lahko tudi O(n2) časa - če delilni element vedno največji
ena najbolj uporabljanih metod

10. Urejanje z zlivanjem preprosto deljenje (/2) zlivanje je združevanje
zgled
1, 2, 6, 8, 13, 19 in 2, 4, 6, 7, 11
1, 2, 2, 4, 6, 7, 8, 11, 13, 19

11. Urejanje z zlivanjem algoritem
uredi z zlivanjem(a,dno,vrh) {
if dno < vrh
s = (dno + vrh) / 2;
uredi z zlivanjem(a,dno,s);
uredi z zlivanjem(a,s+1,vrh);
zlij(a,dno,s,vrh); }

12. Zlivanje dokler oba dela nista prazna ko je eden od delov prazen
izberi manjšega
prepiši
premakni se v delu, odkjer je manjši naprej
ko je eden od delov prazen
v preostanku so vsi elementi večji
prepišemo

13. Drugi problemi bisekcija poišči najmanjšega, največjega hitro urejanje
Hanoi
iskanje k-tega elementa po velikosti
Strassenovo množenje matrik
Hitra Fouriejeva transformacija

14. Min/Max Poišči najmanjšega/največjega Neposredni algoritem
Število primerjanj podatkov: 2(n-1)
Deli in vladaj
Število primerjanj podatkov: 3n/2 – 2 (n = 2k)

15. Neposredni algoritem
Min := max := t[1];
For i := 2 to n do
if t[i] > max then max := t[i];
if t[i] < min then min := t[i];
_________________________________________
(N – 1) ponovitev zanke, v kateri sta dve primerjanji
2N - 2

16. Deli in vladaj
Procedure maxmin(t:podatki; od,do:integer, var max,min: podatek);
var s: integer; l_min,Lmax, d_min, d_max: integer;
begin
if od = do then begin max := t[od]; min := max end;
else if od = do – 1 then { dva el. }
if t[od] < t[do] then begin max := t[do]; min := t[od] end
else begin max := t[od]; min := t[do] end
else begin { vec elementov }
s := (od + do) div 2; { sredina }
maxmin(t, od, s, l_max, l_min);
maxmin(t, s + 1, do, d_max, d_min);
if l_max > d_max then max := l_max else max := d_max;
if l_min > d_min then min := l_min else min := d_min
end;

17. Časovna zahtevnost Le primerjave elementov T(1) = 0 T(2) = 1
T(n) = T(n/2) + T(n/2) + 2

18. Časovna zahtevnost T(n) = 2T(n/2) + 2 =
2k-1T(2) + vsota(2i,i,1, k-1) =
2k-1 + 2k – 2 = 2k(1/2 + 1) – 2 =
n(3/2) - 2

19. Poišči k-ti element po velikosti
Deli kot pri hitrem urejanju
Če je v levem delu >= k elementov, ga poiščemo levo
Če je levo > k (recimo j) elementov, poiščemo k – j tega v desnem delu.

20. Primer 70, 75, 80, 85, 60, 55, 50, 45 Deli (okoli 70) Iščemo sedmega
45, 75, 80, 85, 60, 55, 50, 70
45, 50, 80, 85, 60, 55, 75, 70
45, 50, 55, 85, 60, 80, 75, 70
45, 50, 55, 60, 85, 80, 75, 70
Iščemo sedmega

21. Primer V 85, 80, 75, 70 iščemo (7-4).ega Deli (85)
70, 80, 75, 85
V 70, 80, 75 poišči 3.
Deli
70, 80, 75
V 80, 75 poišči drugega