Algoritmusok és adatszerkezetek II. kidolgozott ... · Algoritmusok és adatszerkezetek II. kidolgozott vizsgakérdések (2013/2014 2. félév) Dobreff András 1 Algoritmusok és

Algoritmusok és adatszerkezetek II. kidolgozott vizsgakérdések (2013/2014 2. félév) Dobreff András

1

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


2

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

bcb, cba, aac, bbb, cab, acc, caa

a → cba, caa b → bcb, bbb, cab c → aac, acc

cba, caa, bcb, bbb, cab, aac, acc

a → caa, cab, aac b → cba, bbb c → bcb, acc

caa, cab, aac, cba, bbb, bcb, acc

a → aac, acc b → bbb, bcb c → caa, cab, cba

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 hash-tá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

hi(x) = -i


3

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) + hi(x) mod M

Lineáris próba:

hi(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:

hi(x) = (−1)i ∙ ��i2��

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):

hi(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!


4

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)


5

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. ↑ ↑ ↑ ↑ ↑ ↑ ↑


6

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


7

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 π Rajz 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


8

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. 5 7 9 1 3 2 4 6 8


9

12.) A „MATEKFELELETEMKETTESLETT” szöveget szeretnénk tömöríteni Huffman-

kó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 F - 00001 S - 0001 L - 001

K - 010 M - 011 T - 10 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


10

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 I Nincs egyezés, j = 0 i = 2, next[2] = 0 A B A B A K

2 0 A B A B A K I Egyezés i = 3, j = 1, next[3] = 1 A B A B A



5 3 A B A B A K I Nincs egyezés, j ≠ 0 j = next[3] A B A B A

5 1 A B A B A K I Nincs egyezés, j ≠ 0 j = next[1] A B A

5 0 A B A B A K I Nincs egyezés, j = 0 i = 6, next[6] = 0 A B Tehát az Next tömb:

1 2 3 4 5 6 0 0 1 2 3 0


11

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 A B A B A K I Х, j = 0 i++ A B A B A K I

1 0 B A B A L A B A B A T I B A B A B A K I ✓ i++ j++ A B A B A K I



4 3 B A B A L A B A B A T I B A B A B A K I Х, j ≠ 0 j = next[3] A B A B A K I




















19 6 B A B A L A B A B A T I B A B A B A K I ✓ i++ j++ A B A B A K I Összehasonlítások száma: 25


12

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.


13

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, v1, v2, ... vm, j> (v1...vm ≤ k) (Ha a végén az átlókban nem 0-k vannak, akkor van negatív kör.)


14

Pl:

D0 = �

0 3 ∞ ∞∞ 0 4 2−2 ∞ 0 −54 ∞ ∞ 0

� D1 = �

0 3 ∞ ∞∞ 0 4 2−2 1 0 −54 7 ∞ 0

� D2 = �0 3 7 5∞ 0 4 2−2 1 0 −54 7 11 0

�

D3 = �

0 3 7 22 0 4 −1−2 1 0 −54 7 11 0

� D4 = �

0 3 7 22 0 4 −1−2 1 0 −54 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

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


15

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:


16

Ö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 Mit ad

SZB ✓ ✓

✓ ✓ Legrövidebb

utak feszítőfája

Dijkstra ✓ ✓ ✓ Minimális költségű

utak

BF ✓

✓ ✓ ✓ ✓ Minimális költségű

utak

Floyd ✓

✓ ✓ ✓ Minimális k. út minden csúcspárra

Prim ✓

✓ ✓ ✓ Minimális költségű feszítőfa

MB ✓ ✓ ✓ 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


17

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 (sufix) 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:

1 2 3 4 5 0 0 1 2 3

Ami a következőt jelenti:

Elromlás Tolás után

Next[1] = 0 ... i ... ... i ... A B A B A C A B A B A

Next[2] = 0 ... i ... ... i ... A B A B A C A B A B



Next[5] = 3 ... i ... i A B A B A C A B A B


18

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):


19

É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 si-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 s0-t kiszámolhatjuk Horner módszerrel. Ezek után si+1 a következőképp számítható: 𝑠𝑠𝑖𝑖+1 = (𝑠𝑠𝑖𝑖 − 𝑜𝑜𝑜𝑜𝑜𝑜(𝑠𝑠[𝑖𝑖]) ∙ 𝑜𝑜𝑚𝑚−1) ∙ 𝑜𝑜 + 𝑜𝑜𝑜𝑜𝑜𝑜(𝑠𝑠[𝑖𝑖 + 𝑚𝑚])

Azaz, ha s0= 3020, akkor 𝑠𝑠0+1 = (3020 − 𝑜𝑜𝑜𝑜𝑜𝑜(𝐷𝐷) ∙ 103) ∙ 10 + 𝑜𝑜𝑜𝑜𝑜𝑜(𝐵𝐵) = (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.


20

Vegyük a következő életszerű példát: 4 bájton ábrázoljuk a számainkat ez ≈232 Az abc legyen 32 elemű, a minta 8 hosszú. Ekkor a dm-1 kiszámítása: (25)7 = 235, 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 si =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 si+1-t két lépésben számoljuk:

𝑠𝑠 ≔ (𝑠𝑠𝑖𝑖 + 𝑜𝑜 ∙ 𝑝𝑝 − 𝑜𝑜𝑜𝑜𝑜𝑜(𝑠𝑠[𝑖𝑖]) ∙ 𝑜𝑜𝑚𝑚−1) (𝑚𝑚𝑜𝑜𝑜𝑜 𝑝𝑝)

𝑠𝑠𝑖𝑖+1 ≔ �𝑠𝑠 ∙ 𝑜𝑜 + 𝑜𝑜𝑜𝑜𝑜𝑜(𝑠𝑠[𝑖𝑖 + 𝑚𝑚])� (𝑚𝑚𝑜𝑜𝑜𝑜 𝑝𝑝)


21

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: ℎ(𝑡𝑡𝑅𝑅(𝑛𝑛) ≥ 𝑙𝑙𝑜𝑜𝑙𝑙2(𝑛𝑛!) 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 2h levél helyezkedne el. A levelek az eredmények, tehát 2h ≥ n! ebből: h ≥ log2(n!)

♥ (Ez érvényes a fenti példára is: 8 = 23 ≥ 3! =6)

Tétel: MÖR(n) = Ω(nlog(n)) Bizonyítás:

Az előző lemma alapján: MÖR(n) = h(tR(n)) ≥ log2(n!)

MÖR(n) = h�tR(n)� ≥ log2(n!) = log2(n!) = log2(n(n − 1)(n − 2) … 2 ∙ 1) =

= log2(n) + log2(n− 1) + ⋯+ log22 + log21 = � log2(i)n

i=1

≥ � lognxn

1

dx =1

ln2� lnx

n

1

dx

=1

ln2[xlnx − x]1n =

1ln2

[nln(n) − n − (ln1 − 1)] =1

ln2(nln(n) − n + 1)

= nlog2n−n

ln2+

1ln2

≈ nlogn − 1,44n + 1,44 = θ(nlogn)

⟹ MÖR(n) = Ω(nlogn) ♥


22

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) = 1n!

� ÖR(p)p ∈perm

Azaz, vesszük minden permutációhoz tartozó összehasonlítás számot, és azokat átlagoljuk (összegüket elosztjuk a számukkal) Pl:

AÖR(3) = 13!

(2 ∙ 2 + 4 ∙ 3) =166

= 2, 6̇

Lhsum() - levélmagasságok összege A döntési fa alapján látjuk, hogy:

�ÖR(p)p

= lhsum�tR(n)�

tehát:

AÖR(3) = 1n!

lhsum�tR(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) = 1n!

lhsum�tR(n)� ≥ 1n!

lhsum�topt (n)� ≥1n!

n! (h�topt (n) − 1�

= h �topt (n)� − 1 ≥ log2(n!)− 1 = Ω(nlogn)

♥


23

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: [email protected] https://www.facebook.com/andras.dobreff

Jó tanulást!
http://people.inf.elte.hu/doauaai/algo2mailto:[email protected]://www.facebook.com/andras.dobreff

Documents

Algoritmusok és adatszerkezetek II. kidolgozott ... · Algoritmusok és adatszerkezetek II. kidolgozott vizsgakérdések (2013/2014 2. félév) Dobreff András 1 Algoritmusok és