Algoritmusok és adatszerkezetek II. kidolgozott vizsgakérdések

Algoritmusok és adatszerkezetek II. kidolgozott vizsgakérdések 2013/2014-es tanév 2. félév 1.) a. Adott a háromjegyű bináris számok következő sorozata: 010, 101, 011, 110, 000, 001, 100. Rendezzük a számokat az egy tömbben dolgozó RADIX előre edényrendezéssel! Adjuk meg a tömb tartalmát az egyes pozíciók feldolgozása után! Elv: Felírjuk az inputot egymás alá. Majd bitenként elölről hátrafelé haladunk. Minden lépésben alulról felfelé, illetve fentről lefelé indulunk. Fentről lefelé ha 1-est találunk, megállunk. Alulról felfelé ha 0-t találunk megállunk. Ha mind két irányban megálltunk, cserélünk, majd haladunk tovább. Amikor a két haladás átlépi egymást, akkor vége az adott iterációnak. Ekkor a 0-k felül, a 1-esek alul helyezkednek el. Ezek alapján 2 blokkra osztjuk az elemeket, majd a következő iterációban a blokkokon külön megyünk végig. b. Adott a háromjegyű bináris számok következő sorozata: 110, 011, 010, 101, 000, 100, 001. Rendezzük a számokat a felváltva két tömbben dolgozó RADIX vissza edényrendezéssel! Adjuk meg rendre az 1., 2. és 3. pozíció szerinti hasítás eredményét tartalmazó megfelelő (A vagy B) tömböt, végül pedig a rendezettséget mutató A tömböt! Elv: Vegyünk fel két tömböt (A,B). Felírjuk az inputot egymás alá, az A tömbbe. Majd bitenként haladjunk hátulról előrefelé. Minden lépésben a tömb két részre van osztva. (A legelső lépés kicsit rendhagyó, tekintsük ekkor a második részt üresnek). Az első részen felülről lefelé, majd a második részben alulról felfelé haladjunk. Az egyeseket a másik tömb aljára (végére) helyezzük, a 0-kat a tetejére (elejére). Addig menjünk, míg el nem érjük a határvonalat. Ekkor húzzuk meg a határvonalat a második (B) tömbben Folytassuk az eljárást a másik tömbbön (B), írjunk az iménti tömbbe (A) A végén tegyünk egy utolsó lépést, melyben a megszokott haladási sorrendben olvassuk ki az adatokat 1

c. Adott a három karakteres értékek következő sorozata: bcb, cba, aac, bbb, cab, acc, caa. Rendezzük a számokat a visszafelé haladó edényrendezés listás változatával! Adjuk meg a listák (absztrakt szinten sorozatok) tartalmát a szét-, ill. összefűzések után! Elv: Vegyünk fel egy listát, melyben az inputot tároljuk. Karakterenként hátulról előre vizsgálódunk. Minden lépésben szétfűzzük a listát a karakterek alapján, majd sorendben visszafűzzük őket. Végezzük a műveletet addig, míg el nem érjük az első karaktereket a cba, caa b bcb, bbb, cab c aac, acc a caa, cab, aac b cba, bbb c bcb, acc a aac, acc b bbb, bcb c caa, cab, cba bcb, cba, aac, bbb, cab, acc, caa cba, caa, bcb, bbb, cab, aac, acc caa, cab, aac, cba, bbb, bcb, acc aac, acc, bbb, bcb, caa, cab, cba 2.) Írja meg a lineáris hasítás algoritmusát, vagyis azt a h: K H [0..m-1] függvényt, amely O(M) műveletigénnyel beszúr egy kulcsot a H [0..m-1] vektorral ábrázolt hashtáblába! A hasító-táblában megengedett az azonos kulcsok többszöri előfordulása. Két extremális kulcsértéket használunk az üres ill. a törölt pozíció jelzésére (ÜRES, TÖRÖLT). A kulcsütközések feloldására (balra lépő) lineáris próbálást alkalmazzon. A függvény visszatérési értéke legyen a beszúrt kulcs vektorbeli pozíciója, ha sikerült a kulcsot beszúrni a táblába, különben pedig 1. ahol: H = (t[0..m-1], n): hasítótábla q: beszúrandó elem n: táblában lévő elemek száma M: tábla kapacitása (vektor mérete) h(x) = x mod M h i (x) = -i 2

3.) Nyílt címzéssel, a h(k) = k (mod 11) hasítófüggvénnyel helyezzük az A [0..10] tömbben a 29, 61, 49, 50, 13, 39, 60, 76 sorozatot. Adjuk meg a keletkezett táblát az alábbi esetekben: a. lineáris próbálás (balra lép) b. négyzetes próbálás (felváltva jobbra-balra lép) c. kettős hash-elés, ahol h (k) = k (mod 7) + 1 (balra lép) Vektorbeli pozíció kiszámítása: h(x) + h i (x) mod M Lineáris próba: h i (x) = -i 0 1 2 3 4 5 6 7 8 9 10 60 13 39 50 49 61 29 76 Négyzetes próba: h i (x) = ( 1) i i 2 2 0 1 2 3 4 5 6 7 8 9 10 13 50 60 49 61 29 76 39 Kettős hash-elés, ahol h (k) = k (mod 7) + 1 (balra lép): h i (x) = -i * h (k) 0 1 2 3 4 5 6 7 8 9 10 60 39 13 50 49 61 29 76 4.) Éllistás ábrázolással adott egy egyszerű, irányított, élsúlyozott gráf. Adjon algoritmust, amely az Adj[1..n] tömb elemeihez fűzött (csúcs, élsúly, pointer) mezőket tartalmazó elemekből álló listák feldolgozásával előállítja a gráf csúcsmátrixos ábrázolását a G [1..n, 1..n] szomszédsági mátrixban, annak tanult, szokásos kitöltési konvenciója szerint! 3

5.) Adjon olyan algoritmust, amely meghatározza egy irányított gráf éllistás ábrázolása esetén a gráf csúcsainak kimeneti fokát és bemeneti fokát. A program a kifok és befok értékeket a kifok [1..n] és befok [1..n] tömbökbe írja be, amelyek a csúcsok sorszámával (címkéjével) vannak indexelve! 6.) Adott egy egyszerű irányított G gráf éllistás ábrázolása az Adj [1..n] tömbbel. Írjunk olyan algoritmust, lineáris időben eldönti, hogy a G gráf speciálisan fa struktúrájú-e! (Az ellenőrzéshez új adatszerkezetet fel lehet venni, ha szükséges.) Irányított Fa: Egy olyan irányított körmentes irányított gráf, aminek van egy db csúcsa, melynek a befoka 0 és a többi csúcsnak a befoka 1 Tehát, ha vizsgáljuk a befokokat, megkapjuk, hogy fa-e az irányított gráf. Az algoritmus műveletigénye: n+e+n = O(e) 4

7.) Szemléltesse a Dijkstra algoritmus működését az alábbi gráfon! Adja meg menetenként a d és P tömbök tartalmát! A kiinduló csúcs legyen az 1-es címkéjű csúcs. d Π k 1 2 3 4 5 6 7 1 2 3 4 5 6 7 1 2 3 4 5 6 7 0. 0 0 0 0 0 0 0 0 1. 5 8 10 6 4 1 0 1 1 1 1 1 1 2. 3 7 3. 4 6 4. 5 9 5 5. 7 2 6. 8 3 7. 5

8.) Szemléltesse a Prim algoritmus működését az alábbi gráfon! A startcsúcs legyen az 1- es címkéjű csúcs. Írja fel a minq és a π tömb tartalmát menetenként (minden minimum kivételnél), rajzolja le a kialakult feszítőfát! minq d π 1 2 3 4 5 6 1 2 3 4 5 6 1. (0,1), (,2), (,3), (,4), (,5), (,6) 0 0 0 0 0 0 0 2. (2,2), (3,3), (4,4), (,5), (,6) 2 3 4 1 1 1 3. (1,3), (4,5), (4,4), (,6) 1 4 2 2 4. (1,5), (3,6), (4,4) 1 3 3 3 5. (2,6), (4,4) 2 5 6. (2,4) 2 6 7. - 0 2 1 2 1 2 0 1 2 6 3 5 6

9.) Szemléltesse a Bellman-Ford algoritmus működését az alábbi gráfon. Startcsúcs az 5- ös címkéjű csúcs! A gráfban nincs negatív kör, ezt már nem kell ellenőrizni. Adja meg menetenként a d és Pi tömbök tartalmát, és rajzolja le minden menet után a gráfot, egyértelműen jelölve az addig talált legjobb utakat az 5-ös csúcsból a többihez! Az éleket minden menetben a csúcsok címkéi szerinti alfabetikus sorrendben dolgozzuk fel: (1,2), (1,3),, (5,2). d π 1 2 3 4 5 1 2 3 4 5 0 0 0 0 0 0 1.1 1.2 1.3 1.4 1.5 6 7 5 5 6 7 0 5 0 5 0 0 2.1 11 2 1 1 2.2 2.3 4 3 2.4 2.5 6 4 7 2 0 5 3 5 1 0 3.1 3.2 2 2 3.3 3.4 3.5 2 4 7 2 0 2 3 5 1 0 4.1-2 1 4.1 4.1 4.1 4.1 2 4 7-2 0 2 3 5 1 0 5.1 5.1 5.1 5.1 5.1 2 4 7-2 0 2 3 5 1 0 Rajz 7

10.) Az alábbi gráfon az 1-es címkéjű csúcsból indulva lefuttatunk egy mélységi bejárást. A csúcsok szomszédjainak a feldolgozási sorrendje legyen a szomszéd csúcsok címkéi szerint növekvően rendezett. Jelölje a gráfon, a bejárás során kapott mélységi és befejezési számokat, illetve az éltípusokat! Élek meghatározása (u v): Faél: msz[v] =0 Visszaél: msz[v] > 0 és bsz[v]=0 Keresztél: msz[v] > 0 és bsz[v] >0 és msz[u] > msz[v] Előreél: msz[v] > 0 és bsz[v] >0 és msz[u] < msz[v] 11.) Adja meg az alábbi gráf egy topologikus rendezését (ha létezik) a tanult eljárással, annak követhető leírásával! A gráf mélységi bejárása során helyezzük egy verembe azon csúcsokat, melyekből visszalépünk. 8 5 7 9 1 3 2 4 6 8

12.) A MATEKFELELETEMKETTESLETT szöveget szeretnénk tömöríteni Huffmankódolással. Írja le a kódfa építés elvét, adja meg a kódfát, a szöveg betűinek a kódját, valamint azt is, hogy minimálisan hány bittel tudjuk kódolni az eredeti, illetve a tömörített szöveget! Szimbólumok gyakoriságának megállapítása (M, 2), (A,1), (T, 6), (E, 8), (K, 2), (F, 1), (L, 3) (S,1) Gyakoriság szerinti rendezés (A, 1), (F,1), (S,1), (M, 2), (K, 2), (L, 3), (T, 6), (E, 8) Huffman-fa építése Gyakoriságok szerint megyünk, és alulról kezdjük építeni a fát. Kiválasztunk 2 csúcsot, berakjuk a fa aljára. Összevonjuk a két csúcsot, és visszarakjuk a rendezett sorba. (A, 1), (F,1), (S,1), (M, 2), (K, 2), (L, 3), (T, 6), (E, 8) (AF,2), (S,1), (M, 2), (K, 2), (L, 3), (T, 6), (E, 8) (M, 2), (K, 2), (AFS,3), (L, 3), (T, 6), (E, 8) (AFS,3), (L, 3), (KM, 4), (T, 6), (E, 8) (KM, 4), (AFSL,6), (T, 6), (E, 8) (T, 6), (E, 8), (AFSLKM,10) (AFSLKM,10), (TE, 14) (AFSLKMTE,24) A fa elkészültével az egyik irányba mutató éleket 0-val, míg a másik irányba mutatókat 1-el címkézzük fel. A gyökérből a levelekig leolvasva az élek címkéit, megkapjuk az adott betű kódját. A - 00000 K - 010 F - 00001 M - 011 S - 0001 T - 10 L - 001 E- 11 Output: 011000001011010000011100111001111011011010111010110001001111010 Eredeti szöveg kódolásának mérete: 8 különböző karakter van. Így egy karaktert 3 biten tudunk ábrázolni. Az eredeti szöveg 24 karakter hosszú, így a szöveg kódolása 24*3=72 bit lett volna. Huffman-kód mérete: A: 5 bit, F: 5 bit, S: 4 bit, L: 3 bit, K: 3 bit, M: 3 bit, M: 3 bit, T: 2 bit, E: 2 bit. Így a huffman kód mérete: 5+5+4+3*3+2*3+2*3+6*2+8*2 = 63 9

13.) Lempel-Ziv-Welch tömörítő eljárással kódoltunk egy szöveget. A szöveg A, B és C betűket tartalmazott, melyeket rendre az 1, 2 és 3-as számokkal kódoltunk. A szótár felépítése során, a szótárba kerülő új szó kódjának a legkisebb még nem használt pozitív egész számot választottuk. Így a következő kódolt szöveget kaptuk: 1 2 4 3 5 6 9 7 1. Adja meg az eredeti szöveget és a felépített szótárat! In X Tábla Out 1 A 4: A A 2 B 4: A = AB 5: B B 4 AB 5: B = BA 6: AB AB 3 C 6: AB = ABC 7: C C 5 BA 7: C = CB 8: BA BA 6 ABC 8: BA = BAA 9: ABC ABC 9 ABC 9: ABC = ABCA 10: ABCA ABCA 7 CB 10: ABCA = ABCAC 11: CB CB 1 A 11: CB = CBA 12: A A A szöveg: ABABCBAABCABCACBA A kódtábla: 1: A, 2: B, 3: C, 4: AB, 5: BA, 6: ABC, 7: CB, 8: BAA, 9: ABCA, 10: ABCAC, 11: CBA, 12: A 14.) Adott az alábbi S szöveg és M minta. Szemléltesse a Knuth-Morris-Pratt algoritmus működését! Adja meg a next vektor értékét! Rajzolja le a szöveg alá a minta eltolásait és adja meg, hogy pontosan hány összehasonlítást végez az algoritmus! Összehasonlításnak tekintse a minta és szöveg egy-egy karakterének az összehasonlítását. S= BABALABABATIBABABAKI és M= ABABAKI A next vektor kiszámítása az InitNext() eljárással: i j minta esemény Akció 1 0 A B A B A K Nincs egyezés, j = 0 i = 2, next[2] = 0 2 0 A B A B A Egyezés i = 3, j = 1, next[3] = 1 3 1 A B A B A Egyezés i = 4, j = 2, next[4] = 2 4 2 A B A B A Egyezés i = 5, j = 3, next[5] = 3 5 3 A B A B A Nincs egyezés, j 0 j = next[3] 5 1 A B A Nincs egyezés, j 0 j = next[1] 5 0 A B Nincs egyezés, j = 0 i = 6, next[6] = 0 Tehát az Next tömb: 1 2 3 4 5 6 0 0 1 2 3 0 10

A KMP algoritmus: I j Szöveg és minta esemény Akció 0 0 B A B A L A B A B A T I B Х, j = 0 1 0 B A B A L A B A B A T I B 2 1 B A B A L A B A B A T I B 3 2 B A B A L A B A B A T I B 4 3 B A B A L A B A B A T I B j = Х, j 0 next[3] 4 1 B A B A L A B A B A T I B j = Х, j 0 next[1] 4 0 B A B A L A B A B A T I B Х, j = 0 5 0 B A B A L A B A B A T I B 6 1 B A B A L A B A B A T I B 7 2 B A B A L A B A B A T I B 8 3 B A B A L A B A B A T I B 9 4 B A B A L A B A B A T I B 10 5 B A B A L A B A B A T I B j = Х, j 0 next[5] 10 3 B A B A L A B A B A T I B j = Х, j 0 next[3] 10 1 B A B A L A B A B A T I B j = Х, j 0 next[1] 10 0 B A B A L A B A B A T I B Х, j = 0 11 0 B A B A L A B A B A T I B Х, j = 0 12 0 B A B A L A B A B A T I B Х, j = 0 13 0 B A B A L A B A B A T I B 14 1 B A B A L A B A B A T I B 15 2 B A B A L A B A B A T I B 16 3 B A B A L A B A B A T I B 17 4 B A B A L A B A B A T I B 18 5 B A B A L A B A B A T I B 19 6 B A B A L A B A B A T I B Összehasonlítások száma: 25 11

15.) Gráfok szélességi bejárása G gráf (ir. vagy ir. nélküli) Élsúlyok nem szerepelnek s startcsúcsból érjük el a gráf csúcsait, az s-től való távolságuk sorrendjében. Legrövidebb utak feszítőfáját adja meg (d - távolságok, π - szülők) Algoritmus: nem determinisztikus, mohó Sor adatszerkezetet használunk Pl: Q d π 1 2 3 4 5 6 1 2 3 4 5 6 0 1 0 0 0 0 0 0 0 1 1,2,3 1 1 1 1 2 2,3,4,5 2 2 2 2 3 3,4,5 4 4,5 5 5,6 3 5 6 6-0 1 1 2 2 3 0 1 1 2 2 5 16.) Minimális költségű utak keresése I. (Dijkstra algoritmus) G gráf (ir.) Élsúlyozott (nincs negatív él) s startcsúcsból keressünk minden csúcsba minimális költségű utat. Minimális költségű utakat keres. Algoritmus a SZB átváltoztatása. (Csúcsoknak 3 állapotuk van: nemelért, elért, kész) Algoritmus mohó, de a d és π tömbök értékei változhatnak az eljárás során Prioritási sor adatszerkezetet, vagy folyamatos MinKer-t alkalmazunk a még nem kész csúcsokon. 12

Pl: d π 1 2 3 4 5 6 1 2 3 4 5 6 0 0 0 0 0 0 0 0 1 2 3 1 1 2 6 4 3 2 2 3 5 4 9 5 5 4 5 5 9 0 2 5 4 3 9 0 1 5 2 1 5 17.) Minimális költségű utak keresése II. (Bellman-Ford algoritmus) G gráf (ir.) Élsúlyozott (összefüggő, negatív élek) s startcsúcsból keressünk minimális költségű utakat Minimális költségű utakat keres. Algoritmus nem mohó. n-1 iterációval, minden iterációban az összes csúcs összes szomszédját vizsgálja. (Ha n. iterációban van módosítás, akkor van negatív kör) 18.) Minimális költségű utak minden csúcspárra (Floyd algoritmusa) G gráf (ir.) Élsúlyozott (összefüggő, negatív élek) Minimális költségű út keresése minden csúcspárra Algoritmus nem mohó, n iterációval, minden iterációban +1 csúcs hozzá vételével keres kedvezőbb utakat. Minden k. iterációban egy i j utak mátrixát állítja elő, ahol i j = < i, v 1, v 2,... v m, j> (v 1...v m k) (Ha a végén az átlókban nem 0-k vannak, akkor van negatív kör.) 13

Pl: 0 3 D 0 0 4 2 = 2 0 5 4 0 0 3 7 2 D 3 2 0 4 1 = 2 1 0 5 4 7 11 0 0 3 D 1 0 4 2 = 2 1 0 5 4 7 0 0 3 7 2 D 4 2 0 4 1 = 2 1 0 5 4 7 11 0 0 3 7 5 D 2 0 4 2 = 2 1 0 5 4 7 11 0 19.) Minimális költségű feszítőfa keresés (Prim algoritmus) G gráf (ir nélküli) Élsúlyozott (összefüggő, negatívat engedélyez) s startcsúcsból keressük meg a minimális költségű élekből alkotott feszítőfát Minimális költségű feszítőfát adja meg (d - élköltségek, π - szülők) Prioritásos sor adatszerkezet használ. (Először feltöltjük az In művelettel. A kezdőcsúcs távolságát 0-ra állítjuk (Replace). Majd minden iterációban kivesszük (Out) a legkisebb távolságú elemet. Csak azon szomszédjait vesszük figyelembe, amik benne vannak a sorban (Contains)) Pl: minq d π 1 2 3 4 5 6 1 2 3 4 5 6 0 (0, 1), (, 2)... 0 0 0 0 0 0 0 1 (1, 2), (5, 4)... 1 5 1 1 2 (2, 3), (2, 4), (2, 5)... 2 2 2 2 2 2 3 (1, 5), (2, 4), (5, 6) 1 5 3 3 4 (2, 4), (5, 6) 2 5 5 (5, 6) 6-0 1 2 2 1 2 0 1 2 2 3 5 14

20.) Gráfok mélységi bejárása G gráf (ir.) Élsúlyok nem szerepelnek (nem öf. is) Nincs startcsúcs, a csúcsokat mohón választjuk. Addig haladunk előre míg tudunk, majd visszalépünk. Mélységi fát (erdőt) adja meg. A csúcsokat színezés helyett most "mélységi szám", ill. "befejezési szám"-okal jellemezzük Pl: 15

Összefoglalva Irányított Irányítatlan Nem öf Élsúlyos Élsúly nélküli Negatív élek Kiszűri a negatív kört Startcsúcs SZB Dijkstra BF Floyd Prim MB Mit ad Legrövidebb utak feszítőfája Minimális költségű utak Minimális költségű utak Minimális k. út minden csúcspárra Minimális költségű feszítőfa Mélységi fa (erdő) 21.) DAG topologikus rendezése DAG (directed acyclic graph): Írányított körmentes gráf Felhasználás: Munkafolyamatok ill., függősége (ételrecept, autógyártás) pl: Elmélet: 1. Ha G gráfra a MB talál visszaélt G nem DAG 2. HA G nem DAG (van benne kör) bármely MB talál benne visszaélt 3. Ha G-nek van topologikus rendezése D DAG 4. Egy DAG mindig topologikusan rendezhető Topologikus rendezés: Egy G(V, E) gráf topologikus rendezése a csúcsok olyan sorrendje, hogy U V E élre U előbb van, mint V. Topologikus rendezés algoritmusa: G gráf MB-a során helyezzük verembe azon csúcsokat, melyekből visszalépünk. A verem tartalmát kiírva megkapjuk a gráf topologikus rendezését. Egy topologikus rendezése:acbedf 16

22.) Mintaillesztés: Knuth-Morris-Pratt algoritmus A Knuth-Morris-Pratt eljárásnak a Brute-Force (hasonlítsuk össze, toljunk egyet, stb..) módszerrel szemben az az előnye, hogy egyes esetekben, ha a mintában vannak ismétlődő elemek, akkor egy tolásnál akár több karakternyit is ugorhatunk. Az ugrás megállapítását a következőképp tesszük: Az eddig megvizsgált egyező mintarész elején (prefix) és végén (suffix) olyan kartersorozatot keresünk, melyek megegyeznek. Ha találunk ilyet, akkor a mintát annyival tolhatjuk, hogy az elején lévő része ráilleszkedjen a végén levőre. A B A B A B A C A B A B A C A B A B A C Azt, hogy ez egyes esetekben mekkorát tolhatunk nem kell minden elromlás alkalmával vizsgálni. Ha a mintára önmagával lefuttatjuk az algoritmus egy módosított változatát, kitölthetünk egy tömböt, mely alapján a tolásokat végezni fogjuk. Ezután a tömb tartalma: Ami a következőt jelenti: Next[1] = 0 Next[2] = 0 Next[3] = 1 Next[4] = 2 Next[5] = 3 1 2 3 4 5 0 0 1 2 3 Elromlás Tolás után... i...... i... A B A B A C A B A B A... i...... i... A B A B A C A B A B... i...... i... A B A B A C A B A B... i...... i... A B A B A C A B A B... i... i A B A B A C A B A B 17

Ezek után a KMP algoritmus a következőképp néz ki: Tehát: Addig megyünk, míg a minta vagy a szöveg végére nem érünk. Ha egyezik a két (köv.) karakter akkor lépünk mind a kettővel tovább Ha nem egyeznek, akkor vagy tolunk annyit, amennyit szabad, vagy ha a minta első betűjét vizsgáltuk, akkor egyet tolunk a mintán 23.) Mintaillesztés: Boyer-Moore algoritmus egy változata: Quick search Míg a KMP algoritmus az elromlás helye előtti rész alapján döntött a tolásról, addig a QS a minta utáni karakter alapján. Eltolás: Ha a minta utáni karakter benne van a mintában, akkor jobbról az első előfordulására illesztjük: A B A A C B C D A A C B C D A A C B C D Ha a minta utáni karakter nincs benne a mintában, akkor a mintát ezen karakter után illesztjük A B A A C B X D A A C B C D A A C B C D Az eltolás kiszámítását megint elő lehet segíteni egy tömbbel, most azonban, mivel nem a minta az érdekes, és nem tudjuk pontosan mely karakterek szerepelnek a szövegben, így a tömbbe az egész abc-t fel kell vennünk Az eltolást elősegítő tömb konstruálása (Shift['a'...'z'], ahol 'a'...'z' H elemei): 18

És a QS struktogramja: 24.) Mintaillesztés: Rabin-Karp algoritmus A Rabin-Karp algoritmus lényege, hogy minden betűhöz az abc-ből egy számjegyet rendelünk, és a keresést számok összehasonlításával végezzük. Világos, hogy ehhez egy abc méretnek megfelelő számrendszerre lesz szükségünk. A szöveget a minta hosszúságával egyező részenként vesszük és úgy végezzük az összehasonlítást. Pl: M = BBAC 1102 S = DACABBAC 30201102, amiből a következő számokat állítjuk elő: 3020, 0201, 2011, 0110, 1102 Ezek lesznek az s i -k Ehhez azonban számos apró ötletet kell alkalmaznunk 1. Horner módszer A mintát számmá Horner módszerrel alakítjuk át az ord() a karakter abc-ben elfoglalt helyét adja meg. (d a számrendszer alapszáma) 2. Szöveg számokká alakítása s 0 -t kiszámolhatjuk Horner módszerrel. Ezek után s i+1 a következőképp számítható: ss ii+1 = (ss ii oooooo(ss[ii]) dd mm 1 ) dd + oooooo(ss[ii + mm]) Azaz, ha s 0 = 3020, akkor ss 0+1 = (3020 oooooo(dd) 10 3 ) 10 + oooooo(bb) = (3020 3000) 10 + 1 = 201 (Ha a minta 4 hosszú, és az abc 10 elemű) 3. Túlcsordulás Felmerülhet a kérdés, hogy az ilyen magas alapszámú számrendszerek nem okoznak-e gondot az ábrázolásnál? A kérdés jogos. 19

Vegyük a következő életszerű példát: 4 bájton ábrázoljuk a számainkat ez 2 32 Az abc legyen 32 elemű, a minta 8 hosszú. Ekkor a d m-1 kiszámítása: (2 5 ) 7 = 2 35, ami már nem ábrázolható 4 bájton. A Rabin-Karp algoritmus ehhez vesz egy p nagy prímet. Melyre még d*p még ábrázolható. És mod p számolja a műveleteket. Ettől azonban lesz olyan, hogy a számítás egyezést talál, de a minta mégsem egyezik a szöveggel. Ez nem baj, mert ekkor karakterszinten ezt lehet ellenőrizni. Viszont, ha nincs egyezés akkor karakteres szinten sincs. (Ha p nagy, akkor ez a jelenség azonban ritka) 4. "óvatos számolás" Mivel mod p számolunk így előfordulhat, hogy a kivonás után negatív számot kapunk. Például, ha p=7 és és ord(s[i]) = 9, akkor s i =2..., ekkor ha kivonjuk a 9000-et, akkor negatív számot kapunk. (Ez a probléma valószínűleg csak gyakorlatban jön elő) Megoldásként s i+1 -t két lépésben számoljuk: ss (ss ii + dd pp oooooo(ss[ii]) dd mm 1 ) (mmmmmm pp) ss ii+1 ss dd + oooooo(ss[ii + mm]) (mmmmmm pp) 20

25.) Rendezések alsó korlát elemzése, legrosszabb eset (a matematikai számítás nélkül) Algoritmusok hatékonyságát a műveletigény kiszámításával fejezzük ki. A műveletigény a lépésszámban nyilvánul meg. Ezek után a műveletigény kiszámításához elég a domináns műveleteket figyelembe venni. Minden algoritmusra alsó korlát elemzést adunk. Ezzel határozzuk meg a minimális műveletigényét. Ehhez ú.n. döntési fában ábrázoljuk az absztrakt elemzést. Például rendező algoritmusok összehasonlítás számát tudjuk így elemezni. Vegyünk n=3 db inputot. Ezeknek bármilyen permutációja előfordulhat, így 3! = 6 féle input lehetséges. Ezek sorrendjének megállapítását ábrázoljuk a döntési fában: Láthatjuk, hogy a fa magassága 2 és 3 között van. Ez azt jelenti, hogy 3 input ra, legalább 2, legfeljebb 3 összehasonlítással, meg lehet állapítani a sorrendet. Erre a famagasságra általánosan is tudunk alsó korlátot adni. Lemma: h(tt RR (nn) llllll 2 (nn!) Bizonyítás: h(t) : famagasság, azaz a gyökértől legtávolabb lévő levél távolsága Ha teljes fa lenne, akkor ezen a szinten 2 h levél helyezkedne el. A levelek az eredmények, tehát 2 h n! ebből: h log 2 (n!) (Ez érvényes a fenti példára is: 8 = 2 3 3! =6) Tétel: MÖ R (n) = Ω(nlog(n)) Bizonyítás: Az előző lemma alapján: MÖ R (n) = h(t R (n)) log 2 (n!) MÖ R (n) = h t R (n) log 2 (n!) = log 2 (n!) = log 2 (n(n 1)(n 2) 2 1) = = log 2 (n) + log 2 (n 1) + + log 2 2 + log 2 1 = log 2 (i) log n x dx = 1 lnx dx ln2 i=1 1 1 = 1 ln2 [xlnx x] 1 n = 1 1 [nln(n) n (ln1 1)] = (nln(n) n + 1) ln2 ln2 = nlog 2 n n ln2 + 1 nlogn 1,44n + 1,44 = θ(nlogn) ln2 MÖ R (n) = Ω(nlogn) n n n 21

26.) Rendezések alsókorlát elemzése, átlagos eset (a matematikai számítás nélkül) Átlagos esetben az összehasonlítások számának átlagát vesszük. Ez a következőképp alakul: AÖ R (n) = 1 n! p perm Ö R (p) Azaz, vesszük minden permutációhoz tartozó összehasonlítás számot, és azokat átlagoljuk (összegüket elosztjuk a számukkal) Pl: Lhsum() - levélmagasságok összege A döntési fa alapján látjuk, hogy: AÖ R (3) = 1 16 (2 2 + 4 3) = = 2, 6 3! 6 tehát: Ö R (p) = lhsum t R (n) p AÖ R (3) = 1 n! lhsum t R(n) Lemma: Az n! levelet tartalmazó tökéletes fák közül azokra a legkiseb az lhsum(t(n)) érték, melyek majdnem teljesek Bizonyítás: h(a) h(d) 2 h(c) h(d) 1 lhsum(t) lhsum(t ) = 17 16 = 1 Általában 1, ill véges áthelyezéssel majdnem teljes fát kapunk Tétel: AÖ R (n) = Ω(nlogn) Bizonyítás: AÖ R (n) = 1 n! lhsum t R(n) 1 n! lhsum t opt (n) 1 n! n! (h t opt (n) 1 = h t opt (n) 1 log 2 (n!) 1 = Ω(nlogn) 22

Remélem sokat segít ez a kidolgozott anyag a felkészülésben. Használjátok egészséggel, de tartsátok észben, hogy ez nem egy hivatalos jegyzet, az esetleges hibákért nem áll módomban felelősséget vállalni. Ellenben az észrevételeket szívesen fogadom, és igyekszem javítani. A frissítések ezen a címen találhatóak majd meg: http://people.inf.elte.hu/doauaai/algo2 Ha lenne bármilyen kérdés, óhaj-sóhaj, akkor keressetek meg e-mailben vagy facebookon: dobreffandras@gmail.com https://www.facebook.com/andras.dobreff Jó tanulást! 23