Algoritmusok s adatszerkezetek 2

2015/16 tavaszi flv

Elad: Dr. svnyi Tibor
Ksztettk:
Koruhely Gbor (Koru)
Szalay Richrd (Whisperity)
Lektorlta:
Dr. svnyi Tibor
Frisstve: 2016. 06. 18.
 12 EA
els blokk: 10:15 - 11:00
sznet: 11:00 11:15
msodik blokk: 11:15 - 12:00

Rendezs lineris idben

Ednyrendezs (bucket sort)
Ttelezzk fel, hogy a kulcsok: [0,1) intervallumba esnek s egyenletesen oszlanak el.
Plda szmok: 0,32; 0,81; 0,89; 0,17; 0,53 (n = 5) a k kulcsot k n ednybe tesszk

0.edny: 0,17
1.edny: 0,32
2.edny: 0,53
3.edny:
4.edny: 0,81; 0,89
az eredmny: 0,17; 0,32; 0,53; 0,81; 0,89

Bucket_sort(&S; n)

E[0..n-1] ltrehozsa resen

nincs vge S-nek
x:= S kvetkez eleme (n)
i:= x. kulcs n
x-et beszrjuk E[i]-be
i = 0..n 1 mT(n) (n)
E[i] rendezse Pl.: beszr rendezsek
MT(n) (n2 )
S := <>
i = 0..n 1 (n)
S vghez hozzfzzk E[i] tartalmt
azonban hiba mehet n2 -ig a mveletigny, a legtbb esetben (a legtbb inputra) marad az tlagos n-es
mveletigny

1
 Leszmll rendezs (Counting sort)
Most tegyk fel, hogy a kulcsok [0..k]-ba esnek, k (n) (azaz k legfeljebb n-nel lineris)
: kulcsfggvny A[1..n]: T
: T [0;k] C[0..k]: 0..n ngyes szmrendszer-beli szmok
Plda: (k = 3), a szmok: 312, 213, 021, 222, 323, 331
(a 0. lps az init)
C[] adottodik elemkor
h 0. 1. 2. 3. 4. 5. 6. vgn
0 0 1 1
1 0 0 ennyi ilyen kulcs
2 0 1 2 2 elem van szerint
3 0 1 2 3 3

Counting_sort(A[1..n], k, , B[1..n])

C[0..k] ltrehozsa
i:= 0..k (k)
C[i] := 0
i = 1..n
C[(A[i])] := C[(A[i])] + 1 (n)
vgn
i = 1..k
C[i] := C[i] + C[i 1] (k)
utna i = n..1 (-1)
j := (A[i])
(n)
B[C[j]] := A[i]
C[j] := C[j] - 1

most mr a bal szls szmjegy szerint is rendezett a tmb; a tbbi szmjegy szerinti, most mr msodlagos
rendezettsget megtartotta.

2
 Radix (szmjegypozcis) rendezs
Radix(n elem, d szmjegy, (szjegyek 0..k))

i := 1..d
rendezzk az elemeket stabil rendezssel
htulrl i-edik szmjegyk szerint
Stabil rendezs: amely az elemeknek, egyenl kulcsok esetn, az egymshoz viszonytott sorrendjt nem vltoztatja
meg (pl Counting_sort ilyen).
Tradix ( d Tstabil (n)) TRadix rendezs tmbkre (d (n + k)) = (n)
Tcounting (n, k) (n + k)
ha d konstans s () volt

Sztfz sorrendtart mdon

Radix rendezs
lncolt listkra,
stabil edny-
rendezssel, jobbrl
az i.-edik szmjegy
szerint (i:= 1,..,d) Sztfz sorrendtart mdon
sszefzs utn sorban:

sszefzs utn sorban:

T/ (n, k) (d (n + k)) = (n)

ha d konstans s ()

3
 102 EA
trgy kvetelmnyei:
Legalbb elgsges gyakorlati jegy kell a vizsgzshoz,
vizsga
3szor lehet maximum vizsgzni egy vizsgaidszakban,
vizsga ugyanolyan felpts, mint elz flvben az algo 1
tematika:
A trgy honlapjn megtallhat a trgy tematikja: http://aszt.inf.elte.hu/~asvanyi/ad/ad2programok.pdf
8ttel
nem sszehasonlt rendezsekrl lesz sz,
hasttblk
grf algk
o legrvidebb t
o minimlis fesztfa
vesztesgmentes tmrts
mintailleszts

Hasttblk (Hash tables)

Hasonlan a kiegyenslyozott fkhoz cl lenne a 3 alapmvelet (keress, beszrs, trls) optimlisan fusson le.
tlagos esetben (1), legrosszabb esetben (n).
Direkt cmzs (Direct addressing):
a lehetsges kulcsok az U = {0,...,m-1} (m nem tl nagy pozitv egsz) univerzumba esnek
mveletei: beszr; keres; trl
fv.Keres (T[0..m-1], k) Trl (T[0..m-1], p)
Beszr, (T[0..m-1], p)
return(T[k]) T[p->kulcs] :=
T[p->kulcs] := p

A trigny miatt problms a mdszer, pl. ha a szemlyi szm szerint gy trolnnk a magyarokat, akkor a
<10milli embernek 75 milli hely kellene, nagyon sok az res hely.

h: kulcsuniverzumbl rsekre (slotokra) kpez le. (n a trolt adatok szma)

h: U[0..m-1] (|U| >> m /*>> := sokkal nagyobb*/), (m (n))

h hast fggvny
A baj az, hogy hiba tesszk a hash szerinti helyre a kulcsokat, elbb, utbb lesz kt kln kulcs, aminl
h(k) = h(k). Ekkor kulcstkzs kvetkezik be, ez clszeren lncolt listval elkerlhet.
Lncolt lists esetben viszont MTkeres(n) (n); mTkeres (n) (1); ATkeres (n) (1 + ), a trls
mveletignye ugyanaz, mint a keres egyes eseteiben.
a minimlis akkor lehet, ha a rshez tartoz lista els elemt keressk, vagy a lista res.
n
a listk tlagos hossza a hashtbla kitltttsgi hnyadosa, =
m

Ha nem ellenrizzk az esetleges dupliklt kulcsokat, a beszrs ignye (1). Ha nem engedjk meg a dupliklt
kulcsokat, ugyanaz, mint a keress-nl.

Egyszer egyenletes hasts: minden slotra ugyanakkora a h lekpezsi valsznsge.

Ilyen hash-ek megadhatk, de elg komoly matematika van mgtte.

Osztmdszer: h(k) = k mod m, ahol m olyan prm amely messze van a 2-hatvnyoktl
Ha a kulcsok a [0,1) intervallumon egyenletesen oszlanak el, akkor a h(k) = k m is j hashfggvny

Szorzmdszer: 0 < A < 1 konstans

h(k) = {k A} m ({x} a trtrsz fgv.)
(51)
(klnbz vizsglatok szerint A = 0,618 . jl szrja szt a kulcsokat.
2
Ezt a kiszmtst azonban nehz elvgezni a lebegpontos aritmetika miatt.
4
m = 2p a hashtbla mrete
w = 32
k 0 2w 1; legyen, 0 < p < w

bitjnek kivlasztsa

A kulcstkzsek feloldsra a lncolt lista helyett vannak ms mdszerek is.

Nylt cmzs:
h: U [0 m 1] [0 m 1] Most az egyszersg kedvrt nem ellenrizzk a dupliklt kulcsokat.
k kulcshoz m darab hash-rtk fog tartozni: <h(k,0); h(k,1); h(k,m-1)> prbasorozat
A mveletek a prbasorozaton mennek vgig:
szabad
Pl: beszrsnl ha h(k,0)-hoz van foglalt elem akkor h(k,1)-re szr be, feltve ha az mr
res vagy trlt

fv.Beszr(T[0..m-1],p)
fv.Keres(T[0..m-1],k)
fv.Trl(T[0..m-1],k)
i := 0
i<m i :=0
j := h(p.kulcs,i) j := Keres(T,k) l:= igaz
T[j] {, } j l
T[j] := p T[j] := j:= h(k,i)
i := i+1
return (j) return(j) T[j].kulcs = k
return
( a trlt rs) return(j) i := i+1
ahol: : res rs l:= ( i < m T[j] )
: trlt rs
return
\[0. . 1]
Feltesszk, hogy
A prbasorozatnak a <0,1, ,m-1> permutltjnak kell lennie
.kulcs, .kulcs U
A prbasorozatok egyik ellltsi mdja pl. a lineris prbls:
h(k,i) = (h(k) + i) mod m kU

5
 112 EA
Hasttblk
Hasttblk tulajdonsgai:
egy sztrt valstanak meg
kulcs alapjn lehet benne keresni
trlni is lehet benne
tlagos mveleti igny konstans

a tbla (ism.):
egy tmbnek lehet tekinteni; 0..m-1-ig indexelve van
specilisan a nylt cmzsnl az adatokat slot-okban troljuk;
megklnbztetjk a trlt () illetve az res () slotokat
sikertelen a keress, ha res slothoz r, vagy ha tl sokat prblkozik (m db prba utn megll)

valjban nem egy hash fggvny van, hanem m db hash fggvny van Tipikusan foglalt rsek hossz sszefgg
szakaszain alakulnak ki T[0..m-1]-ben
feltehetjk, hogy van m db hash fggvny
elsdleges csomsodsok.
h: ( . , i) : U 0..m-1 ( i 0..m-1)
<h(k,0), , h(k,m-1)> perm <0, , m-1>
lineris prba: h(k,i) = (h(k) + i) mod m
ngyzetes prba: h(k,i) = (h(k) + c1 + c2 2 ) mod m /*ahol h(k) = h(k,0)*/
1
ahol jl bevlt ajnls, hogy m 2-hatvny, c1 , c2 pedig (m = 2 , 0 < )
2
i(i+1) j(j+1)
i j: (h(k,i) h(k,j)) mod m = [ ] (mod m ) 0
2 2
2m i (i + 1) j (j + 1) = i2 + i j2 j = i2 j2 + (i j) = (i j)(i + j + 1)
2p+1 (i j)(i + j + 1) ezek prossga klnbzik
a) 2 | (i j) 2 ( i + j + 1)
de 2m (i j) hiszen i - j < 2m-1
b) 2 | ( i + j + 1) 2 (i j)
de 2m (i + j + 1)-nek, mivel (i + j + 1) < 2m 1
azaz 2-hatvny tbla esetn a ngyzetes prba szpen lefedi az egsz tblt
(i + 1) (i + 2) i (i + 1)
(h(k, i + 1) h(k, i)) mod m = [ ] mod m = (i + 1) mod m
2 2
azaz: h(k, i + 1) = (h(k, i ) + (i + 1)) mod m
s h(k,0) = h(k)

feltesszk: trlt() slot kulcsa s az res() slot kulcsa nem eleme az U-nak
fv.beszr(T[0..m-1], k) fv.keres(T[0..m-1], k)

j:= h(k) j:= h(k); i := 0; b:= true

i := 0 b
i<m T[j].kulcs = k
T[j] {,} return j
T[j] := k i := i + 1
return(j) b := T[j] s i < m
i := i + 1 j:= (j + i) mod m
j := ( j + i) mod m return -1
return -1 Megjegyzs: ha T[j] NIL, akkor T[j].kulcs
olyan extremlis rtk, amely brmilyen
nylt cmzs, ngyzetes prba s .kulcs s .kulcs kulcsuniverzum sszehasonltsra hamisat ad
az ltalnos ngyzetes prbnl (ahol c1 s c2 tetszleges)
ha h(k1 , 0) = h(k 2 , 0), akkor i re h(k1 , i) = h(k 2 , i)

Msodlagos csomsods
Teht csak m klnbz prbasorozat van a lehetsges m! kzl, gy a (msodlagos) csomsods fellp, de ez jobb,
mint a lineris prba elsdleges csomsodsa, ahol a sorozatok menet kzben gabalyodhatnak ssze
6
 Ketts hasts
h(k, i) = [ h1 (k) + i h2 (k)] mod m
a prbasorozatok szma itt mr (n2 ) szemben (n)-nel.
ez tapasztalat alapjn mr majdnem idelis tud lenni
ha lnko(h2 (k), m) = 1 <h(k,0), , h(k,m-1)> perm <0, , m-1>-nak
hiszen i j (h(k,i) h(k,j) mod m 0
0 (h(k,i) h(k,j)) mod m (i j) * h2 (k) mod m 0
m (i j) * h2 (k) mivel |i j| < m, h2 (k) pedig relatv prm (ez felttel volt, hogy lehet biztostani,
hogy a h2 (k) s az m relatv prmek legyenek).
a) m legyen prm, akkor h1 (k) = k mod m
h2 (k)=1 + (k mod m) ahol: m= m- 1 v m= m 2 pldul, azaz m-nl picit kisebb
p
b) m = 2 s 2 h2 (k)

Hashels Idelis esete: Egyenletes hasts

idelis lenne, ha <0..m-1> sszes permutci azonos valsznsggel fordulna el
0 < teltettsgi egytthat < 1 esetn
1
sikertelen keress vrhat hossza
1
1
beszrs vrhat hossza Feltve, hogy nincs a hast tblban trlt rs (slot).
1
1 1
sikeres keress vrhat hossza ln ( )
1
Ha sokat hasznljuk a hashtblt, akkor feltredezik, elfogynak az res slotok, ekkor frisstst kell vgrehajtani:
beszrsokkal j tblt ltrehozni a mostani elemekbl.

Grf algoritmusok
Szomszdosgi mtrix (C)
G= (V,E) E V V
V = 1..n
C[1..n,1..n]
1 (i,j) E
C[i,j] =
0 (i,j) E
ha szmt az l kltsge w: E
w(i,j) (i,j) E (i j)
C[i,j] = 0i=j
+ klnben
Azonban a mtrix trols miatt a mveletigny (n2 ), ami az irnytatlan esetben a szimmetria kihasznlsval
javthat (majdnem felezhet), de (n2 ) marad (csak als hromszg mtrixot troljuk).

Szomszdsgi llists reprezentci:

Memriaigny n cscs s e l esetn: (n + e)

7
 1002 EA
Elemi grf algoritmusok
Szlessgi keress
Meghatrozzuk a start cscsbl a tovbbi cscsokba a legkevesebb let tartalmaz utat.
d hny len keresztl jutunk a cscsba
melyik cscsbl jutunk a cscsba

Q = <b>
1. lps: Q= <c, d, e> /*b szomszdai*/
2. lps: Q= <d, e> /*c rkvetkezje e, de ott mr voltunk*/
3. lps: Q= <e, a> /*a d szomszdjai*/
4. lps: Q= <a> /*e szomszdja csak a d, de ott mr voltunk*/
5. lps: Q=<> /*a sor kirlt, a bejrs vget rt

f-bl indtva, msik szemlltetsi mddal:

d a b c d e f Q a b c d e f
0 <f>
f 1 1 <c, e> f f
c <e>
e 2 <d> e
d 3 <a> d
a 4 <b> a
b 3 4 1 2 1 0 <> d a f e f

Az irnytott grfon a szomszdsgi kapcsolat nem szimmetrikus.

A fenti grfban pl.: a szomszdja b, de b-nek nem szomszdja a.

Jells:
Ha G = (V, E), E V V grf,
G.V a G cscsainak halmaza
G.E a G leinek halmaza
u G.V esetn
G.Adj[u] { . | (, ) . }
Feltesszk, hogy (, ) . , azaz nincs hurokl.
G egyszer grf
Feltesszk, hogy nincsenek prhuzamos lek sem.

8
 BFS(G,s)

u G.V
u.d :=
u. :=
u.szn := fehr
s.d := 0
s.szn := szrke
Q := <s>
Q <>
u:= Q.sorbl()
v G.Adj[u]
v.szn = fehr
v.d := u.d + 1
v. := u
v.szn := szrke
Q.sorba(v)
u.szn := fekete
BFS mveletignye: T(n, e) (n + e), ahol n = |V| s e=|E|
mindent legfeljebb egyszer dolgozunk fel, de elfordulhat, hogy nhny cscs kimarad (a start cscsbl nem
elrhet cscsok s lek maradnak ki.).
DFS (Mlysgi keress)
DFS(G)
DFS_VISIT(&u,G, &ido)
u G.V
u. := ido := ido + 1
u.szn := fehr u.d := ido
ido := 0 u.szn := szrke
u G.V v G.Adj[u]
u.szn = fehr v.szn = fehr
DFS_VISIT(u,G, ido) v. := u v.szn = szrke
DFS_VISIT(v,G, ido) viszael(u,v)
u.d = elrsi id (discovery time) u.szn := fekete
u.f = befejezsi id (finishing time) ido := ido + 1
u.f := ido

Mlysgi bejrs plda:

Ha az l mr fekete cscsba mutat, keresztlet vagy elrelet talltunk.

9
 lek osztlyozsa
Def:
a b fal: ez kerl a mlysgi fba, e mentn jrjuk be a grfot
f g visszal (f a g se egy mlysgi fban.)
b f elrel, az elrel kt leszrmazottat kt ssze, ahol b-bl kett vagy tbb falbl ll t vezet f-be.
g h keresztl, olyan kt cscs, amelyek ms gon vannak vagy msik mlysgi fba mutat t

Plda:
Azaz a keress eredmnye egy mlysgi erd

DFS mveletignye: T(n,e) = (n + e) minden cscsot nhnyszor (3) s minden let egyszer.

Ttel:
Ha a mlysgi bejrs sorn egy (u,v) let tallunk:
(u,v) fal v.szn = fehr
(u,v) visszal v.szn = szrke
(u,v) elrel v.szn = fekete u.d < v.d
(u,v) keresztl v.szn = fekete u.d > v.d

10
 1012 EA
Irnytott grfok cscsainak topologikus rendezse
Topologikus rendezs: A cscsok olyan sorrendje, amelyben minden l egy-egy ksbb jv cscsba
(szemlletesen: balrl jobbra) mutat.

Ttel: Pontosan akkor topologikus rendezs, ha nincs irnytott kr a grfban.

Bizonyts:
a) Ha van irnytott kr a grfban, jellje 1 , 2 , , , 1 !
Ekkor egy tetszleges topologikus rendezsben 1 utn jn valahol 2 , az utn valahol 3 , s gy tovbb,
vgl is 1 utn jn , s utn 1 , ami , teht ekkor nincs topologikus rendezs (a grf cscsain).
b) Ha nincs irnytott kr a grfban, akkor nyilvn van olyan cscs, aminek nincs megelzje.
Ha vesznk egy megelzvel nem rendelkez cscsot s trljk a grfbl, akkor a maradk grfban nem
keletkezik irnytott kr, lesz megint legalbb egy olyan, amelyiknek nincs megelzje.
Sorban a trlt cscsok adjk a topologikus rendezst.

G=(V,Adj[V]) Adj[u] = {v V |(u, v) E} V

fv.TR(G, TR[1..n])

BEFOKOK(G,BE[1..n])
(n + e)
i := 0
H:= {v V | BE[v] = 0} (n)
H {}
u from H from kivesz H-bl egy elemet
i := i+1 a kr cscsai nem kerlnek H-ba, gy az eredmnybe (TR[1..n]) sem.
TR[i] := u
v G.Adj[u] (n+e)
BE[v] := BE[v] - 1
BE[v] = 0
H:=H {v}
return i ha i=n, minden cscsot feldolgoztunk
TTR (n) (n + e).
Mlysgi bejrs:

A sorrend: <ra, ing, nyakkend, alsnadrg, zokni, nadrg, v, kabt, cip>

Tetszleges u cscs, akkor kerl a TR-be, a htulrl els szabad helyre, amikor befejeztk.
Ha a mlysgi bejrs visszalt tall irnytott kr van a grfban nincs topologikus rendezs.

11
 Ersen sszefgg komponensek
/*Minden cscsbl minden cscsba vezet irnytott t a komponensen bell*/
A grf ersen sszefgg komponensei:
a,b,e
f,g
c,d
h

Elllts: mlysgi bejrssal mintha topologikus rendezs lenne, de nem kezeljk a visszaleket.
A sorozat: <a, b, e, f, g, c, d, h> a cscsok befejezs szerinti sorrendben.
Transzponljuk a grfot, ezen mlysgi bejrs a sorrend szerint, az gy tallt mlysgi fk a komponensek.

Minimlis fesztfk

Kssnk ssze minden vrost, hogy minden pontba eljusson az ram,

de a lehet legolcsbban (s mg sok ms megfogalmazs feladat)

A lnyeg minimlis fesztfa keresse.

G=(V,E) EVxV (u,v) E (v,u) E /*u v, a hurokleknek nincs rtelme*/

w: E lslyok
w(u,v) = w(v,u)
GEN_MST(G)

A:={}
s :=0
s < n1
(u,v) legyen olyan l a G.E \ A-bl,
azaz A {(u,v)} minimlis fesztfa rsze marad
ami A-hoz biztonsgosan hozzvehet
A:= A {(u,v)} P invarins = T = (V, TE ) MST, hogy
s := s + 1
Def1: G=(V,E), S V esetben (S, V\S) vgs a G grfban
Def2: A E s (S, V\S) vgs esetn a vgs elkerli az A-t A egyetlen le sem keresztezi a vgst
Def3: (u,v) l keresztezi az (S, V\S) vgst az u S s v V\S (vagy fordtva u V\S s v S )

12
Ttel: G = (V,E) irnytatlan w: E -rel lslyozott grf
(S, V\S) vgs a grfban elkerli A t, ahol = (, ) , TE
(u, v) E egy knny l (legkisebb kltsg) a vgsban
Ekkor (u,v) biztonsgos A-ra nzve
Bizonyts:
a) (u, v) TE
b) (u,v) TE (p, q) TE , ami keresztezi az (S, V\S) vgst, ui: T fesztfa,
teht T-ben el lehet jutni u-bl v-be.
w(p,q) w(u,v)
(p,q) trlsvel az MST sztesik, de ha ehhez (u,v)-t hozzvesszk, akkor
jra fesztfa lesz.
T = T \ {(p,q)} {(u,v)}
w(T) = w(T) w(p,q) + w(u,v) w(T)
viszont mivel T MST volt, w(T) w(T) azaz w(T) = w(T) s T is MST kell, hogy legyen

13
 1102 EA
Minimlis fesztfa ismtlse pldn keresztl

G=(V,E)
w: E
egy vgs:
S V\S
{a,b,d} {c,e,f}

egy vgst keresztez l az E (S (V \ S))

egy eleme, ennek a halmaznak a legkisebb
sly tagja a knny l

A S V\S
{a, b, d} {c, e, f}
d-e {a, b, d, {c}
e, f}
d-e c {a} {b, c, d,
| e, f} Az j vgs a kt lt kerlje el, ne menjen
f keresztl rajtuk, majd mindig vlasztjuk a
a-b {a, b, d, {c, f} knny lt.
e}
de c Az eddig kiszmolt fesztfa-rszlet (A)
| lhalmaza diszjunk kell, hogy legyen a vgs
f leivel.
a-b {a, b} {c, d, e,
f}
de-f
|
c

Kruskal algoritmus

Elsknt sly szerint sorba rendezzk a cscsokat! Minden cscs egy egyelem ft kpezzen!
Majd minden lpsben hozzvesszk a minimlis lt, ha kln komponenseket ktnek ssze (ha nem,
kihagyjuk)

0. lps 1 2 3 4 5 6 7 8 9 vgeredmny:
d1e a2 b e2f b a c b6c
|3 |4 |5
e d f
a2b c a2 b c a2b c a2b6c
a b c a b c 2
a b c 2
a b c |3 |4 |3 |3 |5 |3 |5
1 2
d e f d1 e f d1 e f d1 e2 f d1 e2 f d e f d1 e 2f d1 e2 f
kihagyjuk kihagyjuk

14
 A komponensek nyilvntartshoz menetkzben egy msik ft is kezelnk:
0 1 (d-e) 2 (a-b) 3 (f-d) 4 (b-e) 5 6 7 (c-f) 8 9
a b c
a b c a d c a d c ad c
d f
(kihagyjuk) (kihagyjuk) (kihagyjuk) (kihagyjuk)

d e f b e f b e f b e f
e

MST_Kruskal(G,w) n-1 e = |G.E| < n2

G.E mon. nv. rend. w szerint (e*log e) = (e*log n)

u G.V
Make_Set(u) (n)
A := {} (1)
(e*log n)
(u,v) G.E (w szerint mon. nv.)
x := HOL_VAN(u)
y := HOL_VAN(v) (log n) e-szer
xy
A := A {(u,v)} Uni(x,y) (n) (n-1-szer nhny konstans)
return(A)

A HOL_VAN() megllaptja, a cscs melyik ilyen kztes fban van, ennek megfelelen az uni ksbb a fkat kti
ssze. (Mindegyik ft a gykrcscsa azonostja.)
Az j lt gy vesszk a kztes fhoz, hogy a fk magassga ne vltozzon, de a komponenshez tartozs jelezve
maradjon. (Az alacsonyabb fa gykert a nagyobb fa gykere al ktjk be.)
A fk magassga legfeljebb log 2 n (n = |G. V|)
Kzs magassg esetn az unizott fa magassga h+1 lesz (h kzs magassg volt)

Prim algoritmus

Kiindulva egy cscsbl s a (cscs, maradk) vgs kz vlasztja a

minimlis lt
Ezt hozzveszi az eredmnyhez s az (eddigi eredmny, maradk) vgsban
keresi a knny lt
addig folytatva az elz kt lpst, mg Minimlis fesztft nem kapunk.

meg kell adni, hogy hol kezdi (s), de mindegy, hogy hol kezdi
MST_PRIM(G, s, w)

u G.V
u.kulcs := (n)
u. := Lehet, hogy az u hozzvtele utn v
s.kulcs := 0 (1) kzelebb kerl a rszleges fesztfhoz.
Q : PrSor(G.V, kulcs alapjn) (n)
Q <> (n)
u := Q.MIN_KIVESZ() n*(lg(n) )
v G.Adj[u] (n+e)
vQ
(e)
v.kulcs > w(u,v)
v.kulcs := w(u, v) (e) + ((e)*lg(n)) a kupac
v. := u adminisztrcija, a kulcs vlts miatt
Az egsz algoritmus mveletignye: ((n+e)*lg(n)), de a grf sszefgg (e n-1), azaz (e*lg(n))

15
kezd cscs: a
kulcs
lps
a b c d e f a b c d e f
start 0
a 2 4 a a
b - 6 3 b b
e - 1 2 e e
d - - -
f 5 - f
c nincs mr tbb lehetsges szomszdja
vge: 0 2 5 1 3 2 a f e b e Az MST, amit kaptunk,
-: a szomszd mr korbban belekerlt a fba irnytott faknt
1: j, jobb tvolsg reprezentlt
prim optimalizcija: IRNYTATLAN FA
Fibonacci kupacokkal le lehet cskkenteni a mveleti ignyt: (e+n*lg(n))

16
 1112 EA
Legrvidebb t problma
Adott egy tetszleges hlzat, amiben az utaknak kltsgeik vannak, ezt a hlzatot egyszer grffal brzoljuk.
G=(V,E) w: E

Negatv kltsg is lehetsges. Adott pontbl az sszes tbbi cscsba meg szeretnnk hatrozni a legrvidebb utat a
kltsgekkel, nem biztos, hogy a legkevesebb lbl ll t a legrvidebb.
Mikor rtelmes a krds:
ha ltezik a start cscsbl elrhet negatv kr, nincs legrvidebb t egyetlen a krbl elrhet cscsba
sem.
Ha a startcscsbl csak nem negatv kr rhet el, az az tbl elhagyhat.
Optimlis tnak tetszleges rsztja is optimlis t.

ltalnos algoritmus: (Robert Endre Tarjan: Data Structures and Network Algorithms knyvben: "Breadth-first
Scanning" algoritmus)
,,Queue-based BELLMAN-FORD (Sor alap Bellman-Ford algo)

d a b c d Q a b c d menet
init 0 <a>
a 3 1 <b,c> a a 0.
b 1 <c,d> b
1.
c 0 <d,b> c
d <b>
2.
b -2 <d> b
d <> 3.
0 0 1 -2 c a b

SZLESSGI_BELLMAN_FORD(G,s)
GKI(G,s)
GKI(G,s)
u G.V
Q := <s>
u.d :=
Q <>
u. :=
u := Q.sorbl()
s.d := 0
v: (u,v) G.E
u.d + w(u,v) < v.d
v.d := u.d + w(u,v)
v. := u a sorban levs ellenrizhet pl. egy adattaggal, mindig
vQ bejrni a sort nem lenne hatkony.
Q.sorba(v)

Tulajdonsg:
u G.V, hogy ha az u cscsba vezet k lbl ll s u optimlis t a k. menet elejn mr u.d = w(s u) s
(s, , u.., u., u) egy optimlis t
Lemma: s-bl nem rhet el negatv kr (amely sszkltsge negatv) tetszleges u elrhet cscsra ltezik s
u optimlis t, ami legfeljebb n-1 lbl ll.
T( Lemma s Tulajdonsg kvetkezmnye):
Ha s-bl nem rhet el negatv kr
tetszleges u elrhet (s-bl) cscsra ltezik s u optimlis t, s egy optimlis t az n-1. menet elejn mr
rendelkezsnkre ll (ki van szmolva).
az n-1. menet vgre kirl a sor, az algoritmus (n*e) idben megll.

17
Kvetkezmny: Ha az (n-1). menet vgn van a Q sorban elem van s-bl elrhet negatv kr.
Megjegyzs: vegynk egy ilyen w elemet. Ebbl a pointereken visszafele haladva megtallhat egy ismtld v
elem, amire k 1..n k (v) = v, s (v, k1 (v), k2 (v), , (v), v) egy negatv kr.

Legrvidebb utak egy forrsbl, krmentes irnytott grfokon

felttel: nincs irnytott kr,

ekkor lehet topologikus rendezssel optimlis utakat keresni.

topologikus rendezs:

d
a b c d e f a b c d e f
init 0
a --------------------------------- --------------------------------- nem trtnik semmi, el kell jutni a start cscsba
b 1 -1 2 b b b
e 0 1 e e
f
d
c
vge: 0 1 0 -1 1 b e b e
a nem volt elrhet

Mveletigny: (n+e) mveletigny (topologikus rendezs)

cscs kiterjesztse ((n+e))
Teljes mveletignye: (n+e)

18
 10002 EA
Legyen G=(V,E) akr irnytott, akr irnytatlan,
w: E 0 nem negatv vals szmok

DIJKSTRA algoritmus

d a b c d e kiterjeszts a b c d e
init: 0
2 4 1 a a a a
3 d d
2 b b
c
e
vge: 0 2 2 1 a b a

Dijkstra(G,w,s)

u G.V
u.d := (n)
u. := T(n) (2 )
s.d := 0 (1) ha a Q rendezetlen
Q := G.V (n)
Q <>
u:= Q.MINKIVESZd () d szerint n-szer (n)
v: (u,v) G.E e < 2
v.d > u.d + w(u,v)
v.d := u.d + w(u,v) e*(1)
v. := u
Q.HELYRELLTd(v)

als index d azt jelenti, hogy a minkivesz a d rtkei szerinti Q.MINKIVESZd (): n* (lg n)
szomszdsgi llista + binris kupac esetn T(n,e) ((n+e)*log n) Q. HELYRELLT (v): (e * lg n)

ll: Amikor a cscsot kivesszk a sorbl, oda mr optimlis t vezet.

Bizonyts:
start cscsra , a kltsg optimlis. Tegyk fel, hogy nem igaz az llts! Legyen u az els ilyen cscs, t pedig
az su optimlis t els cscsa amely Q sornak.
u-ra nem igaz, u-t vlasszuk kiterjesztsre, ekkor nincs tallt optimlis
t (de attl mg ltezik)
opt
u.d > w(s u), mivel egybknt megtalltuk volna az optimlis utat.
opt
t.d = w(s t) w(su) < u.d
az s t optimlis t, mivel optimlis t rsztja.
= : hiszen t-t megelz cscs kiterjesztsekor belltottuk, de mivel t.d < u.d, ezrt a kvetkez 1ps t-t
vlasztja kiterjesztsre
Minden cscsbl minden cscsba legrvidebb t minden cscsra futtatott Dijkstrval:
ritka grfra (n*(n+e)*log n) = (n2 *log n)
sr grfra (n3 *log n), nem j vlaszts
o ehelyett a vektorpros Dijkstra stabil (n3 )-t (n * (n2 )) fut.

19
 FloydWarshall - algoritmus

Engedjk meg a negatv lslyt, de ne lehessen negatv kr.

G=(V, E)
G: V = 1..n
cscsmtrixos brzols

Dij := i j optimlis t kltsge (vgtelen, ha nincs optimlis t)

ij := i j optimlis ton j szlje
(k)
Dij = az i j ton az [1..k] index cscsok lehetnek csak kzbens cscsok.
k
|
min{w(i j)}
(k)
ij = egy ilyen [1..k] kzbenss ton a j cscsok szlje
0, ha i = j (kzvetlen t szlje)
(0)
Dij = w(i,j), ha (i,j) G.E i j
, ha i j (i,j) G.E
, ha i = j
(0)
ij = i , ha i j s (i,j) G.E
, klnben
(n)
Dij = Dij
(n)
ij = ij

(k1) (k1) (k1) (k) (k1) (k1)

ha Dij > Dik + Dkj , akkor Dij = Dik + Dkj
(k) (k1)
klnben: Dij = Dij
(k) (k1)
hasonlan ij is ha nem tudtuk az utat javtani = ij
(k1)
ha tudtuk = kj
(k) (k1)
Dik = Dik
(k) (k1)
Dkj = Dkj

Az algoritmus lpsenknt ellltja mtrixprok sorozatt.

(k)
D(k) = (Dij ) k = 0,.., n-ig, n+1 db mtrix.
i,j=1
D s k-adik sora s oszlopa a (k-1) s k. lpsben egyenl:
D i.-edik sora: i. cscsbl optimlis utak hossza.

20
 Floyd-Warshall(G,D[1..n, 1..n], w, [1..n, 1..n])

(i,j) 1..n 1..n

i=j
D[i,j] := 0 (i,j) G.E (n2 )
[i,j] := D[i,j] := w(i,j) D[i,j] :=
[i,j] := i [i,j] :=
k = 1.. n
(i,j) 1..n 1..n
D[i,j] > D[i,k] + D[k,j] (n3 )
D[i,j] := D[i,k] + D[k,j]
[i,j] := [k,j]

TFW (n3 )
Sr grfokon az aszimptotikus mveletigny, mint a Dijkstra, de ritka grfokon a Dijkstra aszimptotikusan jobb
(feltve hogy negatv l, s gy a Dijkstra is alkalmazhat).
Megjegyzs: A negatv krk a D ftljban negatv szmknt jelennek meg.

Tranzitv lezrt algoritmus (Warshall algoritmus)

Tij: van-e t i-bl j-be (megllaptja, hogy van-e a kt cscs kztt t (csak az szmt, hogy van-e, hogy milyen
kltsg az nem szmt))
k
(k) |
Tij i j megint csak legfeljebb az 1..k cscsokat rint t.
, ha i = j (i,j) G.E
(0)
Tij = TRANZ_LEZ(G, T[1..n, 1..n])
, klnben
(i,j) 1..n 1..n
(k) (k1)
Tij = Tij (Tik
(k1)
Tkj
(k1)
) (2 )
T[i,j] := (i = j (i,j) G.E)
(n) k = 1 .. n (3 )
Tij = Tij (i,j) 1..n 1..n (3 )
(k) (k1) T[i,j] := T[i,j] ([, ] [, ])
Tik = Tik
(k) (k1)
Tkj = Tkj
Sr grfokra sokkal jobb, mint n db szlessgi bejrs.
Ritka grfokra (e (n)) viszont n darab szlessgi bejrs mveletignye:[n (n + e)] = (2 )
aszimptotikusan kisebb, mint a (3 ) Warshall algo-nl.
()
Sr grfokra () ( ( + )) = (3 ).

Ez hasonl a Warshall-hoz, (2 )
de annak kisebb a konstans szorzja.

21
 10012 EA

Mintaillesztsi feladat
1 2 3 4 5 6 7 8 9 10 11
T[1..11] = A B A B B A B A B A B P[1..4] = BABA
B AB A piros bet: annl a betnl tallhat az els nem egyez karakter
B AB A zld bet: egyez karakter
B AB A zld sz: a keresett minta megtallhat a szban
B AB A
B AB A s = 4 eltols
B AB A kt tallat
B AB A s = 6 eltols
B AB A

Fa: T[1..n]: ; P[1..m]: 0< m n

S := { s 0..n-m | T[s+1..s+m] = P[1..m]} programozsa

Egyszer_mintailleszt_alg(T[1..n], P[1..m], S) T[s+1..s+m] = P[1..m]

S := {} j := 1 (m)
s := 0..n-m j m s T[s+j] = P[j] MT(m) (m)
T[s+1..s+m] = P[1..m] mT(m) (1)
j := j+1
S := S {s} return (j > m)

Az egsz eljrs mveletignye:

MT(n,m) ((n-m+1)*m) = ((n-m)*m)
mT(n,m) (n-m+1) = (n-m) n > m esetn
Megjegyzs:
Gyakran feltehet: n m
Ekkor: MT(n,m) (n*m)
mT(n) (n)
Elg jnak tnhet, de nagy inputra hamar elszll, kell ennl jobb algoritmus.

22
 QUICK SEARCH
Alapfilozfija pldn illusztrlva:
Pl: = {A, B, C, D}
T = A D A B A D C A D A B C A B A D A C A D AD A P = CADA
C A DA piros bet: a keresett minta nem tallhat
C AD A zld sz: a keresett minta megtallhat a szban
C AD A
C A DA eltoljuk annyival, hogy a szvegnek a mintn tli els karaktere (jel.X)
C A DA illeszkedjen a mintban az (X) karakter jobb szls elfordulsra.
C AD A ha mintnkon nem szerepl input karakter jn, teljes hosszon tugorjuk,
C AD A hiszen gysem illeszkedne
C AD A
C AD A

ABCD
shift: 1 5 4 2 adott bet esetn annyit kell lpni, hogy a minta illeszkedhessen, ezek a minthoz specifikusak

Init(shift[] : 1..n+1, P[1..m] : )

elszr feltesszk, hogy bc sszes betjt t

(d)
shift[] :=m + 1 kell ugrani.
j = 1 .. m
shift[P[j]] := m+1 - j (m)

j shift[P[j]]
1 m
2 m-1
3 m-2


hogy a P[1] kerljn X=T[s+m+1] al, a mintt a teljes hosszval el kell tolni, hogy P[2] kerljn az X al,
csak egyel, kevesebbet kell tolni, stb

QuickSearch(T[1..n]: ; P[1..n]: ; S)
d konstans

Init(shift[], P[1..m]) ) = (m+d) = (m)
(m+ ||
s := 0
(1)
S := {}
s+mn
T[s+1..s+m] = P[1..m] n
S :=S {s} mT(n, m) ( ) pl: T s P diszjunkt
m+1
s+m < n MT(n,m) ((n-m+1)*m) pl: T= AA s p= AA
s := s+shift[T[s+m+1]] s := s + 1

RABIN-KARP
= {1 , , d }
: 0..d-1
(i ) = i-1
0

P[1..m] ~
m
j=1 (P[j])d
mj : d szmrendszerbeli szm, Horner elrendezssel: (m) idben szmthat.

T[s+1..s+m] ~ Ts = m j=1 (T[s + j])d

mj : Horner elrendezssel: (m) idben szmthat.

23
A keresett eltolsokat S = {s 0. . n m | Ts = P0 } alakban oldjuk meg, a d-szmrendszer szmok
egyenlsgt vizsgljuk.
A szmts a Horner mellett tovbb egyszersdik:
m

Ts+1 = (T[s + 1 + j])dm1 = (Ts (T[s + 1])dmj)d + (T[s + m + 1]) : (1) idben, ha 1 -et elre
j=1 kiszmoltuk.
Ts= 1 2 8 25
Ts+1 = 2 8 2514
T0 s P0 szmtsa (m) s (m) idej a rekurzi (1) idej.
A teljes mveletigny gy (m) + (n m) (1), ami (n) igny.
ha a rekurzi tnyleg (1) s a Ti , P0 szmokat a gp tudja hatkonyan brzolni.
Mi lesz a nagy mintkkal?
p := P0 mod q (q nagy prm)
t s := Ts mod q
h:= dm1 mod q

t s+1 = (t s (T[s + 1])h)d + (T[s + m + 1]) mod q

a klnbsg tcsaphat negatvba

s + dq (T[s + 1])h) mod q) d + (T[s + m + 1])) mod q

t s+1 = (((t
<(d+1)q

t s = (((t s1 + dq (T[s])h) mod q) d + (T[s + m])) mod q = :

hogy jl mkdjn (d+1)q legnagyobb brzolhat szm kell legyen (size_t, IntegerLast)
Lehet hamis tallat (fals pozitv), ekkor ellenrizni kell, hogy valdi tallat-e, eredeti karakterekkel.

24
 10102 EA

RABIN-KARP folytatsa
max
q= legnagyobb brzolhat szm, prmszm hasznlatval a mod q szmtsok nem fognak
d+1
tlcsordulni
p t s P0 Ts
p = t s P0 = Ts gy potencilis tallat esetn a valdi tallatot ellenrizni kell.

a modulo szmts miatt

elveszik az informci

RABIN_KARP(T[1..n], P[1..m], S)

t 0 := (T[1])
p := (P[1])
h := 1
j = 2..m (m)
t 0 = ( t 0 d + (T[j])) mod q
p = ( p d + (P[j])) mod q
h = (h d) mod q
p = t 0 T[1..n] = P[1..m]
(1)
S := {0} S := {}
s := 1.. n - m mT(n, m) (n m)
ha t s = p sosem teljesl
t s = p P[1..m] = T[s+1..s+m] MT(n, m) ((n m) m) pl: T = AA A p = A A
S := S {s} ha a minta mindig megtallhat

teljes algoritmus:
mTRK (n)
MTRK ((n m + 1) m)

A gyakorlatban nincs tl sok valdi tallat, nagy q esetn a hamis tallatok szma se tl sok.
gy ATRK ~ mTRK (nem biz)

Mintailleszts lineris idben

Plda:
P[1..8] = BABABBAB
T[1..18]= A B A B A B A B B A B A B A B B A B
B eltoljuk a mintt annyival, hogy a minta
B AB AB B illeszked rsze az eltols utn illeszkedjen
B AB AB B A B rszben a szvegre
B AB AB B
B A B A B B AB
B A B (vge a szvegnek)

Keressk a legnagyobb olyan h-t, hogy P[1..h] suffixe T[1..i] s h < j

T[1. . i]j hossz suffixe = P[1. . j] T[1. . i]h hossz suffixe = P[1. . j]h hossz suffixe = P[1. . h]
ilyen felttelt kielgt h-t keresnk.
25
Ez az informci csak a minta ismeretben megkaphat.
Def: next(j) = max{h [0..j-1] | P[1..h] P[1..j]}
next[1..m] := next(1..m)
Ezt kiszmolva gy toljuk el a mintt, hogy p[1..next(j)] legyen a T[1..i] hossz suffixe alatt, mivel korbban biztos
nem lehet illeszkeds.

KMP(T[1..n], P[1..m], S)

init(next[1..m], P[1..m]) (m) 0 i n 0 j<m ij P[1..j] T[1..i] S

i := 0 = {s 0..i-m | P[1..m] = T[s+1..s+m]}
j := 0 (1)
S := {}
i<n
T[i+1] = P[j+1]
i := i + 1; j := j + 1 j=0
(n) next k(j)= P[1..j] k-adik leghosszabb illeszked
j=m i := i+1 j := next[j] prefixe
S := S {i-m}
j := next[j]

A f ciklus T (n), mivel i nvekedni egyesvel tud, s n-ig n biztos van n lefuts
t(i,j) = 2i j [0..2n] szig mon nv mind a ngy gon, de gy a fciklus legfeljebb 2n-szer fut le T (n)
0jin

Tf (n)

init(next[1..m], P[1..m])
P[1..i] P[1..j]
next[1] := 0; i := 0; j := 1
j<m
P[i+1] = P[j+1]
i := i+1 i=0
j := j+1 j := j + 1 i := next[i]
next[j] := i next[j] := 0
most is a 2j-i [0..2n], az gakon szigoran monoton nv mindig gy legfeljebb 2m, legalbb m-szer fut le (m)

26
 10112 EA
Folytats init stuki: x y xz = y ( z)
Def: next: [1..m] [0..m-1] (m + ) x y zx = y ( z)
x ps-prosa y-nak x y x y x y /*ps: prefix-suffix*/
next(j) = max{h [0..j-1] | P[1..h] P[1..j]}
Tulajdonsgok:
1. P[1. . h] ps prosa P[1. . j] nek 0 h < j P[1. . h] P[1. . j]
2. P[1. . i + 1] P[1. . j + 1] P[1. . i] P[1. . j] P[i + 1] = P[j + 1]
3. 0 next(j) < j Kv: j > next(j) > next2 (j) > > next k(j) = 0
4. 0 next(j+1) next(j) + 1 valamely k > 0-ra
5.
a. next k(j) rtelmezve van a P[1..j]-nek a k. leghosszabb ps-prosa
b. next k(j) rtelmezve van P[1.. next k(j)] a P[1..j] k. leghosszabb ps-prosa
Q: m > 0 /*elfelttel*/
R: next[1..m] = next(1..m) /*utfelttel*/
Inv: 0 i < j m next[1..j] = next(1..j) P[1..i] P[1..j] (a P[1..j] tetszleges i-nl hosszabb P[1..l] ps-
prosra: P[l+1] P[j+1] (0 i < j))

2j-i 2..2m a ciklus legfeljebb (2n-2)-szer hajtdik vgre

2-rl indul, szig. mon. n a ciklus legalbb (n-1)-szer vgrehajtdik

Plda:
j 1 2 3 4 5 6 7 8
P[j] A B A B B A B A
next[j] 0 0 1 2 0 1 2 3
Az algoritmus mkdse lpsrl-lpsre:
12345678
i j next[j] A B A B B AB A
0 1 0 A
0 2 0 A
1 3 1 AB
2 4 2 AB A
0 4 res mez A
0 5 0 A
1 6 1 AB
2 7 2 AB A
3 8 3

Tmrts
Naiv mdszer:
T[1..n]: = {1 , , d } lg d bittel kdolhat a karakter
n * lg d bittel kdolhat a szveg

Huffman kd: egyfajra prefix kd
a szveg: ABRAKADABRA Megjegyzs: A kerekterenknt kdol tmrtsek kztt a
jel elforduls kd Huffman kd hossza minimlis.
A 5 0
B 2 100 Tmrtett kd:
0 100
101
0 110
0 111
0 100
101
0
R 2 101
K 1 110 Kitmrts kdfa :
D 1 111 alapjn

27
LEMPEZ-ZIV-WELCH (LZW) = {a, b, c}
IN: a b ab c ba bab a aa aaa a
OUT 1 2 4 3 5 8 1 10 11 1
sz kd
a 1
sz kd
Rekonstruls: b 2
a 1
IN 1 2 4 3 5 8 1 10 11 1 c 3
b 2
OUT a b ab c ba bab a aa aaa a ab 4
c 3
ba 5
ab 4 8-as kd nincs a sztrban! abc 6
ba 5
generlskor a 8-as kd a ba szvegbl jtt ltre cb 7
abc 6
bab 8
cb 7
ab
a..? baba 9
bab 8
5 8 aa 10
baba 9
(hasonlan jrunk el a 10-es, 11-es esetben is) aaa 11
aa 10
aaaa 12
aaa 11
aaaa 12 az utols sor dekdolskor
legtbbszr felesleges mr

LZW_COMPRESS (In, Out, ) = {1 , , d } bc

s: string
c: char
D := {1 : 1, 2 : 2, , d : d}
D: sztr, string: kd alak rendezett prosok halmaza
kd := d + 1 : az s string s a c char konkatenltja
sc
s := get_char(In) i : a i betbl ll string (egybets string)
eof(In) kd(D,s) = a D sztrban az s string kdja
c := get_char(In) eof(In) az In inputrl karaktert beolvastunk
s:_ olyan rendezett pros, aminek az els komponense s
:_) D
(sc
Az gy jelzett utastsok csak akkor hajtandk vgre,
s := sc
write(Out, kd(D,s))
ha mg kd MAXKD, ahol MAXKD a kdok elre
D := D {sc :kd}
rgztett hossztl fgg.
s := c
Pl: ha ez 12bit, akkor MAXKD = 212 -1 = 4095.
kd := kd + 1
write(Out, kd(D, s))

LZW_DECOMPRESS(In, Out, ) s,t: string

k, kd: kdok
t1 : a t string els betje
D := {1 : 1, 2 : 2, , d : d} string(D,k)= a D sztrban k kdnak megfelel string
kd := d + 1 eof(In) az In inputrl kdot beolvastunk
k := get_code(In) _:k olyan rendezett pros, aminek a 2. komponense k
s := string(D, k) : Itt k = kd teljesl
write(Out, s)
eof(In)
k := get_code(In)
(_:k) D Megjegyzs: Balra, az elgazsban az (_:k) D felttel
helyn k < kd is llhatna (gy egy kicsit gyorsabb
t := string(D, k) t := ss
1 lenne az algoritmus)
write(Out, t) write(Out, t)
D := D {st 1 :kd} D := D {t:kd}
s := t
kd := kd + 1

28
Felhasznlt segdanyagok:
Az eladson ksztett jegyzetem (Koru),
Whisperity elads jegyzete (a jegyzetben tallhat sszes kp s nhny szveges kiegszts).
http://aszt.inf.elte.hu/~asvanyi/ad/sor%20alapu%20Bellman-Ford%20alg.pdf
http://aszt.inf.elte.hu/~asvanyi/ad/Lempel-Ziv-Welch%20alg.pdf

Kln ksznet Dr. svnyi Tibor tanr rnak a jegyzet alapos tolvassrt, a tallt hibk jelzsrt s az anyag
megrtst segt megjegyzseirt.

A jegyzetet tolvastk s a tallt hibkat jeleztk, amirt ksznet:

Bn Rbert
Fekete Anett
Lszl Tams
Nagy Vendel
Szab Gerg
Szcsi Pter
Tks Anna

29