A félév során előkerülő témakörök

Hasonló dokumentumok
Specifikáció. B logikai formula, a bemeneti feltétel, K logikai formula, a kimeneti feltétel, A az algoritmus, amelyre az állítás vonatkozik.

Specifikáció. B logikai formula, a bemeneti feltétel, K logikai formula, a kimeneti feltétel, A az algoritmus, amelyre az állítás vonatkozik.

1. Alapfogalmak Algoritmus Számítási probléma Specifikáció Algoritmusok futási ideje

Dr. Schuster György február / 32

Algoritmusok Tervezése. 6. Előadás Algoritmusok 101 Dr. Bécsi Tamás

Függvények növekedési korlátainak jellemzése

2. Rekurzió. = 2P2(n,n) 2 < 2P2(n,n) 1

Nagyságrendek. Kiegészítő anyag az Algoritmuselmélet tárgyhoz. Friedl Katalin BME SZIT február 1.

Programozási módszertan. Függvények rekurzív megadása "Oszd meg és uralkodj" elv, helyettesítő módszer, rekurziós fa módszer, mester módszer

Nagyordó, Omega, Theta, Kisordó

Fibonacci számok. Dinamikus programozással

Számláló rendezés. Példa

Rendezések. A rendezési probléma: Bemenet: Kimenet: n számot tartalmazó (a 1,a 2,,a n ) sorozat

Rekurzív algoritmusok

Edényrendezés. Futási idő: Tegyük fel, hogy m = n, ekkor: legjobb eset Θ(n), legrosszabb eset Θ(n 2 ), átlagos eset Θ(n).

Algoritmusok helyességének bizonyítása. A Floyd-módszer

1. ábra. Számláló rendezés

14. Mediánok és rendezett minták

26. MINIMÁLIS KÖLTSÉGŰ UTAK MINDEN CSÚCSPÁRRA

Függvények. Programozás alapjai C nyelv 7. gyakorlat. LNKO függvény. Függvények(2) LNKO függvény (2) LNKO függvény (3)

Programozás alapjai C nyelv 7. gyakorlat. Függvények. Függvények(2)

2018, Diszkrét matematika

Előfeltétel: legalább elégséges jegy Diszkrét matematika II. (GEMAK122B) tárgyból

Számjegyes vagy radix rendezés

Funkcionális és logikai programozás. { Márton Gyöngyvér, 2012} { Sapientia, Erdélyi Magyar Tudományegyetem }

Algoritmizálás. Horváth Gyula Szegedi Tudományegyetem Természettudományi és Informatikai Kar

Bonyolultságelmélet. Monday 26 th September, 2016, 18:28

Programozási módszertan. Mohó algoritmusok

1. előadás: Halmazelmélet, számfogalom, teljes

Példa Hajtsuk végre az 1 pontból a Dijkstra algoritmust az alábbi gráfra. (A mátrixban a c i j érték az (i, j) él hossza, ha nincs él.

Algoritmusokfelülnézetből. 1. ELŐADÁS Sapientia-EMTE

Térinformatikai algoritmusok Elemi algoritmusok

Relációk Függvények. A diákon megjelenő szövegek és képek csak a szerző (Kocsis Imre, DE MFK) engedélyével használhatók fel!

Bonyolultságelmélet. Monday 26 th September, 2016, 18:27. Bonyolultságelmélet

9. előadás. Programozás-elmélet. Programozási tételek Elemi prog. Sorozatszámítás Eldöntés Kiválasztás Lin. keresés Megszámolás Maximum.

Programozás I. 1. előadás: Algoritmusok alapjai. Sergyán Szabolcs

Kupac adatszerkezet. A[i] bal fia A[2i] A[i] jobb fia A[2i + 1]

RE 1. Relációk Függvények. A diákon megjelenő szövegek és képek csak a szerző (Kocsis Imre, DE MFK) engedélyével használhatók fel!

Térinformatikai algoritmusok Elemi algoritmusok

Bánsághi Anna 2014 Bánsághi Anna 1 of 68

Minimális feszítőfák Legyen G = (V,E,c), c : E R + egy súlyozott irányítatlan gráf. Terjesszük ki a súlyfüggvényt a T E élhalmazokra:

1. Egészítsük ki az alábbi Python függvényt úgy, hogy a függvény meghatározza, egy listába, az első n szám faktoriális értékét:

Algoritmuselmélet 1. előadás

Ordó, omega, theta, rekurzió :15 11:45. Megoldás. A nagyságrendi sorra tekintve nyilvánvalóan igaz pl., hogy: 1

Összetett programozási tételek Rendezések Keresések PT egymásra építése. 10. előadás. Programozás-elmélet. Programozás-elmélet 10.

2. Logika gyakorlat Függvények és a teljes indukció

Más szavakkal formálisan:, ahol olyan egész szám, hogy. Más szavakkal formálisan:, ahol olyan egész szám, hogy.

Adatszerkezetek 7a. Dr. IványiPéter


BBTE Matek-Infó verseny mintatételsor Informatika írásbeli vizsga

Felvételi tematika INFORMATIKA

Halmaz: alapfogalom, bizonyos elemek (matematikai objektumok) Egy halmaz akkor adott, ha minden objektumról eldönthető, hogy

Algoritmuselmélet 1. előadás

Elmaradó óra. Az F = (V,T) gráf minimális feszitőfája G-nek, ha. F feszitőfája G-nek, és. C(T) minimális

Nagy Gábor compalg.inf.elte.hu/ nagy

A programozás alapjai 1 Rekurzió

Programozás I. Sergyán Szabolcs Óbudai Egyetem Neumann János Informatikai Kar szeptember 10.

Egyesíthető prioritási sor

RSA algoritmus. P(M) = M e mod n. S(C) = C d mod n. A helyesség igazoláshoz szükséges számelméleti háttér. a φ(n) = 1 mod n, a (a 1,a 2,...

2016, Diszkrét matematika

Programozás alapjai. 6. gyakorlat Futásidő, rekurzió, feladatmegoldás

Hatékonyság 1. előadás

2016, Diszkrét matematika

Erdélyi Magyar TudományEgyetem (EMTE

2018, Diszkre t matematika. 10. elo ada s

Diszkrét matematika I.

Logika és számításelmélet. 7. előadás

Számítógép hálózatok, osztott rendszerek 2009

Információk. Ismétlés II. Ismétlés. Ismétlés III. A PROGRAMOZÁS ALAPJAI 2. Készítette: Vénné Meskó Katalin. Algoritmus. Algoritmus ábrázolása

1: Bevezetés: Internet, rétegmodell Alapok: aszimptótika, gráfok. HálózatokII, 2007

Ugrólisták. RSL Insert Example. insert(22) with 3 flips. Runtime?

Információs Technológia

Algoritmuselmélet. Függvények nagyságrendje, elágazás és korlátozás, dinamikus programozás. Katona Gyula Y.

Adatszerkezetek I. 7. előadás. (Horváth Gyula anyagai felhasználásával)

Adatszerkezetek Adatszerkezet fogalma. Az értékhalmaz struktúrája

HORVÁTH ZSÓFIA 1. Beadandó feladat (HOZSAAI.ELTE) ápr 7. 8-as csoport

Haladó rendezések. PPT 2007/2008 tavasz.

Programozási módszertan. Dinamikus programozás: szerelőszalag ütemezése Mátrixok véges sorozatainak szorzása

Nagy Gábor compalg.inf.elte.hu/ nagy ősz

1. ábra. Egy rekurzív preorder bejárás. Egy másik rekurzív preorder bejárás

15. tétel. Adatszerkezetek és algoritmusok vizsga Frissült: január 30.

Adatszerkezetek 2. Dr. Iványi Péter

Matlab alapok. Baran Ágnes. Baran Ágnes Matlab alapok Elágazások, függvények 1 / 15

BABEŞ-BOLYAI TUDOMÁNYEGYETEM MATEMATIKA-INFORMATIKA KAR Felvételi verseny - minta Informatika írásbeli

Algoritmuselmélet. Függvények nagyságrendje, elágazás és korlátozás, dinamikus programozás. Katona Gyula Y.

Programozás I. Sergyán Szabolcs Óbudai Egyetem Neumann János Informatikai Kar szeptember 10.

1. Mondjon legalább három példát predikátumra. 4. Mikor van egy változó egy kvantor hatáskörében?

2015, Diszkrét matematika

Algoritmusok pszeudókód... 1

Algoritmizálás, adatmodellezés 1. előadás

Megoldás meghatározása Ez a szakasz kitölti a c és S táblázatokat, a kiíratás S alapján egy rekurzív algoritmussal megtehető.

Partíció probléma rekurzíómemorizálással

Gyakorló feladatok ZH-ra

7. előadás. Gyorsrendezés, rendezés lineáris lépésszámmal. Adatszerkezetek és algoritmusok előadás március 6.

Alkalmazott modul: Programozás 4. előadás. Procedurális programozás: iteratív és rekurzív alprogramok. Alprogramok. Alprogramok.

Kiegészítő részelőadás 1. Az algoritmusok hatékonyságának mérése

Kongruenciák. Waldhauser Tamás

Példa Hajtsuk végre az 1 pontból a Dijkstra algoritmust az alábbi gráfra. (A mátrixban a c i j érték az (i, j) él hossza, ha nincs él.

Tartalomjegyzék Algoritmusok - pszeudókód

Algoritmusok és adatszerkezetek gyakorlat 07

Átírás:

A félév során előkerülő témakörök rekurzív algoritmusok rendező algoritmusok alapvető adattípusok, adatszerkezetek, és kapcsolódó algoritmusok dinamikus programozás mohó algoritmusok gráf algoritmusok keresőfák Algoritmus Az algoritmus olyan elemi műveletekből kompozíciós szabályok szerint felépített összetett művelet, amelyet megadott feltételt teljesítő bemeneti adatra végrehajtva, a megkívánt kimeneti adatot eredményezi. Számítási Probléma A számítási probléma bemenet/kimenet feltételpárral meghatározott követelmény. Azt írja elő, hogy a bemeneti feltételt teljesítő adatra a kimeneti feltételt teljesítő adatot kell kiszámítani. Probléma bemenete: egy olyan (esetleg összetett) adat, amely teljesíti a bemeneti feltételt. Például, a rendezési probléma a következőt jelenti. Bemenet: Azonos típusú adatok H = {a 1,...,a n } halmaza, amelyeken értelmezett egy lineáris rendezési reláció. Kimenet: A H halmaz elemeinek egy rendezéstartó felsorolása, tehát olyan {b 1,...,b n } sorozat, amelyre b 1 b 2 b n, és H = {b 1,...,b n }. B logikai formula, a bemeneti feltétel, K logikai formula, a kimeneti feltétel, A az algoritmus, amelyre az állítás vonatkozik. Specifikáció {B}A{K} Az A algoritmus helyes a {B}A{K} specifikációra nézve, ha minden X bemeneti adatra, amelyre teljesül a B bemeneti feltétel, az algoritmus végrehajtása véges sok elemi művelet végrehajtása után befejeződik, és a keletkezett kimeneti adatra teljesül a K kimeneti feltétel. Beszúró Rendezés BESZÚRÓ-RENDEZÉS (A) For j= 2 to hossz(a) {kulcs:=a[j] i:=j-1 while i>0 és A[i]>kulcs {A[i+1]:=A[i] i:=i-1} A[i+1]:=kulcs} 1

Példa (5,2,4,6,1,3) (5,2 j,4,6,1,3) (2,5,4,6,1,3) (2,5,4 j,6,1,3) (2,4,5,6,1,3) (2,4,5,6 j,1,3) (2,4,5,6,1 j,3) (1,2,4,5,6,3) (1,2,4,5,6,3 j ) (1,2,3,4,5,6) További példa: http://www.youtube.com/watch?v=fdgvezzyyrcfeature=related Futási idő elemzése Legyen A az e 1,...,e m elemi műveletekből felépített algoritmus, és jelölje t i az e i művelet futási idejét (konkrét, vagy hipotetikus gépen). A t i futási idő függhet az e i művelet argumentumaitól. A továbbiakban feltételezzük, hogy minden e i elemi művelet futási ideje c i konstans. Adott x bemenetre jelölje T (A,x) az A algoritmus tényleges futási idejét, ami az x bemeneti adatra ténylegesen végrehajtott elemi műveletek futási idejének az összege. Jelölje x az x bemeneti adat méretét. Ez a méret összetett adat (pl. halmaz, vagy sorozat) esetén általában az adatok száma. Nem összetett adat esetén pedig általában az adat értéke. Az e i elemi műveletek t i futási ideje és az x méret függvény együttesen adja a bonyolultsági mértéket. Algoritmusnak más költsége is van, nevezetesen a memóriaigény, és elosztott algoritmusok esetén fontos a kommunikációs költség is. Legjobb eset: T l j (A,n) = min{t (A,x) : x = n} Legrosszabb eset: T lr (A,n) = max{t (A,x) : x = n} Átlagos eset: Jelölje Pr(x) annak valószínűségét, hogy x bemeneti adata lesz az A algoritmusnak. T a (A,n) = x =n Pr(x)T (A,x) Elemzés Legyen t j a for ciklus j-edik végrehajtásában a while ciklus tesztelések száma. BESZÚRÓ-RENDEZÉS (A) költség végrehajtások száma For j= 2 to hossz(a) c1 n {kulcs:=a[j] c2 n-1 i:=j-1 c3 n-1 while i>0 és A[i]>kulcs c4 t2+t3+...+tn {A[i+1]:=A[i] c5 (t2-1)+...+(tn-1) i:=i-1} c6 (t2-1)+...+(tn-1) A[i+1]:=kulcs} c7 n-1 A teljes költség: n n n c 1 n + c 2 (n 1) + c 3 (n 1) + c 4 t j + c 5 (t j 1) + c 6 j 1) + c 7 (n 1) j=2 j=2 j=2(t 2

Legjobb eset: Ha a tömb már rendezett, akkor minden j-re t j = 1, tehát Ez n lineáris függvénye. T l j (A,n) = c 1 n + c 2 (n 1) + c 3 (n 1) + c 4 (n 1) + c 7 (n 1) Legrosszabb eset: Ha a tömb már fordított sorrendben rendezett, akkor minden j-re t j = j, tehát T lr (A,n) = c 1 n + c 2 (n 1) + c 3 (n 1) + c 4 (n(n + 1)/2 1)+ mivel n j=2 j = n(n + 1)/2 1. A legrosszabb eset n négyzetes függvénye. Az f (n) = O(g(n)) jelentése: f (n) O(g(n)). Az f (n) = Ω(g(n)) jelentése: f (n) Ω(g(n)). c 5 ((n 1)n/2 1) + c 6 ((n 1)n/2 1) + c 7 (n 1), Aszimptotikus jelölések O-jelölés O(g(n)) = { f (n) : ( c,n 0 0)( n n 0 )(0 f (n) cg(n))} Ω-jelölés Ω(g(n)) = { f (n) : ( c,n 0 > 0)( n n 0 )(cg(n) f (n))} Θ-jelölés Θ(g(n)) = { f (n) : ( d 1,d 2,n 0 > 0)( n n 0 )(d 1 g(n) f (n) d 2 g(n))} Az f (n) = Θ(g(n)) jelentése: f (n) Θ(g(n)). Aszimptotikus jelölések o-jelölés o(g(n)) = { f (n) : ( c > 0)( n 0 0)( n n 0 )(0 f (n) cg(n))} Az f (n) = o(g(n)) jelentése: f (n) o(g(n)), ekkor f (n)/g(n) 0. ω-jelölés ω(g(n)) = { f (n) : ( c > 0)( n 0 0)( n n 0 )(cg(n) f (n))} Az f (n) = ω(g(n)) jelentése: f (n) ω(g(n)), akkor f (n)/g(n). Példák 2n + 20 = Θ(n) 3

n 2 = ω(nlogn) log 2 (n) = Θ(log 10 n) n 2 + 20n + 10 = Θ(n 2 ) 2 n = ω(n 100000 ) A konstans költségű elemi műveletek mindegyikét számolhatjuk egységnyi költségűnek. Fő tulajdonságok A Θ reláció tranzitív, reflexív és szimmetrikus, így egy osztályozás tartozik hozzá. A Θ, O, Ω, o, ω relációk mindegyike tranzitív. Ha f (n) = O(g(n)), akkor g(n) = Ω( f (n)). Ha f (n) = o(g(n), akkor f (n) = O(g(n)). Ha f (n) = ω(g(n)), akkor f (n) = Ω(g(n)). Rekurzív algoritmusok Egy objektum definícióját rekurzívnak nevezünk, ha a definíció tartalmazza a definiálandó objektumot. Egy P eljárást (vagy függvényt) rekurzívnak nevezünk, ha P utasításrészében előfordul magának a P eljárásnak a hívása. Faktor(n) If n=1 return 1 Else return n*faktor(n-1) Példa: Faktor(5)=5*Faktor(4) Faktor(4)=4*Faktor(3) Faktor(3)=3*Faktor(2) Faktor(2)=2*Faktor(1) Faktor(1)=1 Hatványozás Hatvany(a,n) If n=0 return 1 else return a*hatvany(a,n-1) 4

Hatvany2(a,n) If n=0 return 1 else If odd(n) return a*hatvany2(a,(n-1)/2)*hatvany2(a,(n-1)/2) else return Hatvany2(a,n/2)*Hatvany2(a,n/2) Euklideszi algoritmus Ha b=0, akkor lnko(a, b) = a. Egyébként ha a b, akkor lnko(a, b) = lnko(b, a mod b). Tehát, ha a b, akkor az alábbi algoritmus kiszámolja a legnagyobb közös osztót. Euklidesz(a,b) If b=0 return a Else return Euklidesz(b, a mod b) Euklidesz(64, 28) = Euklidesz(28, 8) = Euklidesz(8, 4) = Euklidesz(4, 0) = 4 Fibonacci számok Fibonacci 1202-ben vetette fel a kérdést: hány nyúlpár születik n év múlva, ha feltételezzük, hogy az első hónapban csak egyetlen újszülött nyúl-pár van; minden nyúlpár, amikor szaporodik egy újabb nyúlpárt hoz létre; a nyulak a születésük után a következő két évben egyszer-egyszer szaporodnak Fibonacci(n) If n=1 or n=2 return 1 Else return Fibonacci(n-1)+Fibonacci(n-2) A hanoi torony probléma Három pálca egyikén n korong van a többi üres. A korongok nagyság szerinti sorrendben helyezkednek el, alul van a legnagyobb. Át akarjuk helyezni a korongokat egy másik pálcára a következő szabályok alapján. Egyszerre csak egy korong mozgatható. A korong vagy üres pálcára vagy egy nála nagyobb korongra helyezhető. Oldjuk meg a feladatot egy rekurzív algoritmussal! Legyen a hanoi eljárás egy olyan algoritmus, amelynek három argumentuma van, az első argumentum azt adja meg, hogy hány korongot helyezünk át, a második megadja, hogy melyik toronyról a harmadik, hogy melyik toronyra. Ekkor az eljárás az (n,1,2) argumentummal megoldja a feladatot. Amennyiben i 1 korongot már át tudunk helyezni, i korongot a következőképpen helyezhetünk át. Elsőként i 1 korongot áthelyezünk az oszlopról egy másik oszlopra. Utána az i-edik korongot rárakjuk a kimaradó üres oszlopra. Végül ezen korong tetejére felrakjuk az i 1 korongot. Ezt a rekurziót írja le a következő eljárás (a megengedett lépést a mozgat függvény írja le). 5

Hanoi(n, rol, ra) If n=1 Then mozgat(rol, ra) Else {hanoi(n-1, rol, 6-rol-ra) mozgat(rol, ra) Hanoi(n-1, 6-rol-ra, ra)} Lépések száma: Az i-edik korong átrakásához kétszer kell i 1 korongot áthelyezni és egy további mozgatás szükséges. Tehát T (i)-vel jelölve az i korong átrakásához szükséges mozgatások számát a T (i) = 2T (i 1) + 1 rekurzív összefüggés áll fenn. T (1) = 1, így T (2) = 3, T (3) = 7. Azt sejthetjük, hogy T (i) = 2 i 1 egyenlőség, amely teljes indukcióval egyszerűen igazolható. 6