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

(1)

Algoritmuselmélet

Függvények nagyságrendje, elágazás és korlátozás, dinamikus programozás

Katona Gyula Y.

Számítástudományi és Információelméleti Tanszék Budapesti M ˝uszaki és Gazdaságtudományi Egyetem

1. el ˝oadás

(2)

Algoritmus fogalma

Egyel ˝ore nem definiáljuk rendesen az algoritmus fogalmát.

Eljárás, recept, módszer.

Jól meghatározott lépések egymásutánja, amelyek már elég pontosan, egyértelm ˝uen megfogalmazottak ahhoz, hogy gépiesen végrehajthatók legyenek.

Katona Gyula Y. (BME SZIT) Algoritmuselmélet 1. el ˝oadás 2 / 401

(3)

A szó eredete

Al Khvarizmi (Mohamed ibn Músza) bagdadi matematikus a IX.

században könyvet írt az egészekkel való alapm ˝uveletek végzésér ˝ol.

algoritmus ↔ számítógép program

valós probléma =⇒absztrakt modell =⇒algoritmus =⇒program Cél: feladatokra hatékony eljárás kidolgozása

Hatékony =⇒gyors, kevés memória, kevés tárhely

(4)

Milyen hatékony egy algoritmus?

Legtöbbször csak a lépésszám nagyságrendje érdekes.

Hogyan függ a lépésszám az input méretét ˝ol?

Az input méretét legtöbbszörn-nel jelöljük.

A lépésszám ennek egyf függvénye, azaz hanméret ˝u az input, akkor az algoritmusf(n)lépést végez.

Igazából azf függvény az érdekes.

100nvagy 101n, általában mindegy

n²vagyn³már sokszor nagy különbség, de néha mindegy n²vagy 2ⁿmár mindig nagy különbség

(5)

Például

Kérdés

Egy10¹⁰ m ˝uvelet/mp sebesség ˝u számítógép mennyi ideig dolgozik, ha f(n)m ˝uveletet kell végrehajtani n méret ˝u bemenetre?

f(n)

n n n² log₁₀n 2ⁿ n!

10 10⁻⁹ 10⁻⁸ 10⁻¹⁰ 1,02·10⁻⁷ 3,6·10⁻⁴ 10² 10⁻⁸ 10⁻⁶ 2·10⁻¹⁰ 4·10¹²év 2.9,·10¹⁴⁰év 10⁶ 10⁻⁴ 100 6·10⁻¹⁰ 3,1·10^301.012 év 2,6·10^5.565.691év 10⁹ 0,1 3,1 év 9·10⁻⁹mp sok év sok év

(6)

Függvények nagyságrendje

Definíció

Ha f(n)és g(n)azR⁺egy részhalmazán értelmezett, valós értékeket felvev ˝o függvények, akkor f =O(g)jelöli azt a tényt, hogy vannak olyan c,n₀>0állandók, hogy|f(n)| ≤c|g(n)|teljesül, ha n≥n₀.

(7)

Példák

100n+300=O(n)

Biz: 100n+300≤100n+n≤101n≤cn, han≥300, c=101 5n²+3n=O(n²)

Biz: 5n²+3n≤5n²+3n²≤8n²≤cn², han≥100, c =8 n⁴+5n³=O(n⁵)

Biz: n⁴+5n³≤6n⁴≤n⁵≤cn⁵, han≥6, c =1

(8)

Példák

n¹⁰⁰⁰=O(2ⁿ)

Biz: Teljes indukcióval, legyenc =1,n₀=10⁶. n=10⁶-re igaz, mert 10⁶⁰⁰⁰≤(2⁴)⁶⁰⁰⁰≤2¹⁰⁶. Tegyük fel, hogyk-ra igaz.

Felhasználjuk, hogy hak ≥10⁶akkor

1000 i

≤1000ⁱ =1000·1000ⁱ⁻¹≤1000ⁱ⁻¹·1000ⁱ⁻¹=

= (10⁶)ⁱ⁻¹≤kⁱ⁻¹.

(k +1)¹⁰⁰⁰=k¹⁰⁰⁰+· · ·+ ¹⁰⁰⁰_i

k¹⁰⁰⁰⁻ⁱ+· · · ≤k¹⁰⁰⁰+· · ·+ kⁱ⁻¹k¹⁰⁰⁰⁻ⁱ+· · · ≤k¹⁰⁰⁰+1000k⁹⁹⁹≤2·k¹⁰⁰⁰≤2·2^k =2^k+1, hak ≥10⁶.

log¹⁰⁰⁰₂ (n) =O(n)

Biz: Mivel a logaritmus függvény monoton n ˝o, vehetjük a fentiek logaritmusát.

2ⁿ=O(n!) n! =O(nⁿ)

(9)

Példák

Igaz-e, hogyn²=O(n)?

Nem.

Biz: Indirekt, tegyük fel, hogy létezik olyanc,n₀, hogyn²≤cnteljesül mindenn≥n₀esetén.

Ekkorn≤c teljesül mindenn≥n₀esetén, ami nyilván nem igaz, ha n>c.

(10)

Függvények nagyságrendje

Definíció

Ha f(n)és g(n)azR⁺egy részhalmazán értelmezett, valós értékeket felvev ˝o függvények, akkor f = Ω(g)jelöli azt a tényt, hogy vannak olyan c,n₀>0állandók, hogy|f(n)| ≥c|g(n)|teljesül, ha n≥n₀. Például:

100n−300= Ω(n), hiszenn>300, c=99-re teljesülnek a feltételek

5n²−3n= Ω(n²) n⁴−5n³= Ω(n⁴) 2ⁿ= Ω(n¹⁰⁰⁰)

(11)

Függvények nagyságrendje

Definíció

Ha f =O(g)és f = Ω(g)is teljesül, akkor f = Θ(g).

Például:

100n−300= Θ(n) 5n²−3n= Θ(n²) n⁴−5n³= Θ(n⁴) 1000·2ⁿ= Θ(2ⁿ)

(12)

Függvények nagyságrendje

Definíció

Legyenek f(n)és g(n)a pozitív egészeken értelmezett, valós érték ˝u függvények. Ekkor az f =o(g)jelöléssel rövidítjük azt, hogy

f(n)

g(n) →0, ha n→ ∞.

Például:

100n+300=o(n²), hiszen ^100n+300_n₂ →0 han→ ∞ 5n²+3n=o(n³)

n⁴+5n³=o(n⁴log₂n) n¹⁰⁰⁰=o(2ⁿ)

(13)

Algoritmikus problémák megoldása

Algoritmikus probléma −→

^A

modell −→

^B

program

A: pontosítás, egyszer ˝usítés, absztrakció, lényegtelen elemek kisz ˝urése, a lényeg kihámozása

Modell: sokféle lehet, elég tág, de elég egyszer ˝u, formalizált, pontos

B: hatékony algoritmus, bemen ˝o adatok→eredmény, érdemes foglalkozni a kapott algoritmuselemzésével, értékelésével, megvizsgálva, hogy a módszer mennyire hatékony

(14)

Arthur király civilizációs törekvései

Arthur király fényes udvarában 150 lovag és 150 udvarhölgy él. A király, aki közismert civilizációs er ˝ofeszítéseir ˝ol, elhatározza, hogy megházasítja jó lovagjait és szép udvarhöl- gyeit. Mindezt persze emberségesen szeretné tenni. Csak olyan párok egybekelését akarja, amelyek tagjai kölcsönösen vonzalmat éreznek egymás iránt. Hogyan fogjon hozzá?

Természetesen pártfogójához, a nagyhatalmú varázslóhoz, Merlinhez fordul. Merlin rögvest felismeri, hogy itt isbináris szimmetrikus

viszonyokábrázolásáról van szó.

Nagy darab pergament vesz el ˝o, és nekilát egypáros gráfotrajzolni.

A királyi parancs teljesítéséhez Merlinnek élek egy olyan rendszerét kell kiválasztania a gráf éleib ˝ol, hogy a kiválasztott élek közül a gráf minden pontjához pontosan egy csatlakozzon. A kiválasztott élek felelnek meg a tervezett házasságoknak. A gráfelmélet nyelvénteljes párosítástkell keresnie.

(15)

Közlekedési lámpák ütemezése

"

A A

A AA

A A A A A A

3

A A A U

a b

d c e

lámpák: ac,ad,bc,bd,ec ésed állapot: lámpák→ {P,Z}

Feladat: Mennyi a minimális számú állapot, ami biztonságos és nem okoz örök dugót?

@

@ , ,

, ,

,,

!!

ac bc ec

ad bd ed

I. II. III.

(16)

Mobiltelefon-átjátszók frekvencia kiosztása

Egy adott átjátszóhoz egy adott frenkvenciát rendelnek.

Egy telefon a közelben lev ˝o átjátszók közül választ.

„Közel lev ˝o” átjátszók frekvenciája különbözzön.

B A

A

B

A C

C

(17)

Elágazás és korlátozás

Legtöbbször vancⁿ-es algoritmus, de nem mindegy mekkorac.

Bontsunk esetekre, azokat alesetekre, . . . =⇒fa

Értékeljük az eseteket =⇒bizonyos irányokba nem kell továbbmenni.

=⇒(korlátozó heurisztika) Pl. sakkállások

Feladat: Keressünk maximális méret ˝u független ponthalmazt egy adott Ggráfban.

Nyilvánvaló módszer:

Minden részhalmazt végignézünk =⇒O(2ⁿ)lépés

(18)

Jobb algoritmus

Észrevétel: Ha G-ben minden pont foka legfeljebb kett ˝o, akkor a feladat lineáris id ˝oben megoldható: G izolált pontok, utak és körök diszjunkt uniója. =⇒komponensenként minden „második" pontot bevesszük a halmazba.

B B

B

@

@@ r r

r

r r r r r r r r r h h h h h

h h

(izolált pontok)

MF(G)

1. HaG-ben minden pont foka≤2, akkorMF(G)az el ˝obbi eljárás által adott maximális független halmaz, és a munkát befejeztük.

2. Legyenx ∈G,fok(x)≥3.

S₁:=MF(G\ {x})

S₂:={x} ∪MF(G\ {x és szomszédai}).

3. LegyenS azS₁ésS₂közül a nagyobb méret ˝u, illetve akármelyik, ha|S₁|=|S₂|.

4. MF(G) :=S.

(19)

LegyenT(n)az MF(G)-n (|V(G)|≤n) belüli MF hívások maximális száma, beleértve MF(G)-t magát is.

Tétel

Van olyan c állandó, hogy T(n)≤cγⁿ, tetsz ˝oleges n természetes számra, aholγ aγ⁴−γ³−1=0egyenlet pozitív gyöke (γ ≈1,381).

Bizonyítás.

Legyent(n) :=T(n) +1.

T(n)≤T(n−1) +T(n−4) +1, han>4. =⇒ t(n)≤t(n−1) +t(n−4), han>4.

Indukcióval: t(n)≤cγⁿigazn<5-re elég nagyc-vel √

=⇒Ezután, han≥5, indukciós feltevésb ˝ol:

t(n) ≤ t(n−1) +t(n−4)≤cγⁿ⁻¹+cγⁿ⁻⁴=

= cγⁿ⁻⁴(γ³+1) =cγⁿ⁻⁴γ⁴=cγⁿ.

Összköltség: O(n^dT(n)) =O(n^dγⁿ) =O(1,381ⁿ).

(20)

3-színezés keresése

Feladat: AdottG, keressünk egy 3-színezést.

Minden lehetséges színezést végignézünk =⇒O(3ⁿ)lépés

Ötlet: Bizonyos csúcsokat kiszínezünkpirosra, a többir ˝ol polinom id ˝oben el tudjuk dönteni, hogy kiszínezhet ˝ok-ekékkeléssárgával.

Összköltség: O(2ⁿn^c).

(21)

Dinamikus programozás

Optimum meghatározása kisebb részfeladatok optimumainak felhasználásával.

Általában egy táblázat kitöltése, az új elemeket a korábban kitöltött elemekb ˝ol számoljuk.

Binomiális együtthatók kiszámítása

0 0

1 0

₁

1

2 0

₂

1

₂

2

3 0

₃

1

₃

2

₃

3

4 0

₄

1

₄

2

₄

3

₄

4

0 0

1 0

₁

1

2 0

₂

1

₂

2

3 0

₃

1

₃

2

₃

3

4 0

₄

1

₄

2

₄

3

₄

4

Tétel

n k

=

n−1 k −1

+

n−1 k

(22)

Hátizsák probléma

Probléma

Adottak az s₁, . . . ,sm súlyok, a b súlykorlát és a v₁, . . . ,vmértékek.

(Minden érték pozitív egész.) Melyik az az I ⊆ {1, . . . ,m}részhalmaz, melyre teljesül, hogyP

i∈Is_i ≤b ésP

i∈Iv_i maximális?

(23)

El ˝oször kisebb problémára oldjuk meg: v(i,a)a maximális elérhet ˝o érték azs₁, . . . ,s_i súlyokkal,v₁, . . . ,v_i értékekkel ésasúlykorláttal megadott feladatra.

Ekkorv(0,a) =v(i,0) =0∀a,i-re cél→v(m,b)

v(i,a)

0 a b

0 i

m

p p p p p p p p p p```pp

p p

pp pp pp pp p pp p

p

p p p p p p p p p p p p p p p p p p p

keresett érték

?

-

v(i,a) =max{v(i−1,a);v_i+v(i−1,a−s_i)}

=⇒Soronként kitölthet ˝o ⇐=minden érték két felette lev ˝ob ˝ol számolható.

Összköltség: O(bL)

b-t ˝ol függ (nem logb-t ˝ol!), habsokjegy ˝u szám, ez sok id ˝o

(24)

Algoritmuselmélet

Gráfok megadása, szélességi bejárás, összefügg ˝oség, párosítás

Katona Gyula Y.

2. el ˝oadás

(25)

Gráfalgoritmusok

irányított gráfok: G= (V,E)

irányított él, irányított út, irányított kör élsúlyok: c(e)— lehetnek negatívak is

J H

G E

K D

F

I C

B

A L

3

4

8

4 9 6

9 0

17 8 9

3

6

2

7 3

8 6

11

5

(26)

Adjacencia-mátrix

Definíció

A G= (V,E)gráfadjacencia-mátrixa(vagyszomszédossági mátrixa) a következ ˝o – a V elemeivel indexelt – n-szer n-es mátrix:

A[i,j] =

0 ha(i,j)6∈E, 1 ha(i,j)∈E.

Irányítatlan gráfok esetén a szomszédossági mátrix szimmetrikus lesz (azazA[i,j] =A[j,i]teljesül mindeni,jcsúcspárra).

v4

5

1 1

1

−1 v3 3

v1 v5

5 v2

A=







0 1 0 1 0 0 0 0 0 1 0 1 0 0 0 0 0 1 0 1 0 0 1 0 0







(27)

Súlyozott adjacencia-mátrix

Ha költségek is vannak =⇒

C[i,j] =







0 hai=j,

c(i,j) hai6=j és(i,j)éleG-nek,

∗ különben.

v4

5

1 1

1

−1 v3 3

v1 v5

5 v2

C=







0 5 ∗ 1 ∗

∗ 0 ∗ ∗ −1

∗ 1 0 ∗ ∗

∗ ∗ 1 0 5

∗ ∗ 3 ∗ 0







Hátránya: a mérete (n²tömbelem) teljesen független az élek számától.

(28)

Éllistás megadás

G= (V,E)gráf minden csúcsához egy lista tartozik.

Azi∈V csúcs listájában tároljuk azi-b ˝ol kimen ˝o éleket, és ha kell, ezek súlyát is.

Azilistáján egy élnek a lista egy eleme (cellája) felel meg.

- -

jc(i,j)

q q q q

- - ? - 1

i

n ^- ^q ^{q q}

1-b ˝ol kimen ˝o élek cellái

egy tipikus cella -

?

Az (i,j) élnek megfelel ˝o cella tartalmazza a j sorszámot, a c(i,j) súlyt (ha van), egy mu- tatót a következ ˝o cel- lára, és esetleg még egyet az el ˝oz ˝ore is.

Tárigény: n +e cella, Irányítatlan gráfoknál:

n+2ecella

(29)

Szélességi bejárás

BFS:Breadth First Search

Meglátogatjuk az els ˝o csúcsot, majd ennek a csúcsnak az összes szomszédját. Aztán ezen szomszédok összes olyan szomszédját, ahol még nem jártunk, és így tovább.

megvalósítás:sor(FIFO-lista)

Berakjuk az épp meglátogatott csúcsot, hogy majd a megfelel ˝o id ˝oben a szomszédaira is sort keríthessünk.

Általános lépés: vesszük a sor elején lev ˝ox csúcsot, töröljük a sorból, meglátogatjuk azokat azy szomszédait, amelyeket eddig még nem láttunk, majd ezeket azy csúcsokat a sor végére tesszük.

(30)

Szélességi bejárás

procedureszb (v: csúcs)(∗szélességi bejárás egy komponensre∗) var

Q: csúcsokból álló sor;

x,y: csúcsok;

begin

bejárva[v] :=igaz;

sorba(v,Q);

whileQnem üresdo begin

x :=els ˝o(Q);(ez egyben törli isx-et a sorból) formindenx →y ∈E élredo

ifbejárva[y] =hamisthen begin bejárva[y] :=igaz;

(∗) sorba(y,Q)

end end

end

(31)

Szélességi bejárás

procedurebejár(∗szélességi bejárás minden komponensre∗) begin

forv :=1tondo bejárva[v] :=hamis;

forv :=1tondo

ifbejárva[v] =hamisthen szb(v)

end

Összköltség:O(n+e)

(32)

Faél: megvizsgálásuk- kor még be nem járt pontba mutatnak

2

1

4

7 3

6 9 10

8 5

faél ilyen nincs visszaél keresztél keresztél

Irányítatlan esetben csak faél és keresztél lehet.

fa´el 1

4 3

7 6

9 10 8

5

2 ilyen nincs

ilyen nincs kereszt´el kereszt´el

(33)

Összefügg ˝oség eldöntése

Kérdés

Adott G gráf összefügg ˝o-e?

procedureÖsszefügg ˝o begin

öf:=igaz;

tetsz ˝olegesv-reszb(v);

foru:=1tondo

ifbejárva[u] =hamisthenöf:=hamis;

return(öf);

end

Összköltség: O(n+e)

(34)

Maximális párosítás keresése páros gráfban

BSZ-b ˝ol tudjuk, hogy javító utakat kell keresnünk.

Tétel

Egy párosítás akkor és csak akkor maximális, ha nincs hozzá tartozó javítóút.

Kérdés

Hogyan döntjük el, hogy van-e javítóút?

Hogyan keresünk javítóutat?

Módosítjuk a szélességi keresést:

Egy párosítatlan pontból indulunk

Minden páratlan szinten a BFS lépéseit használjuk.

Minden páros szinten a párosítás éleit használjuk.

Ha olyan pontba érünk, aminek nincs párja, találtunk javítóutat

(35)

Maximális párosítás keresése páros gráfban

Költség:

Ha minden párosítatlan pontból építünk egy ilyen fát

=⇒alternáló erd ˝o=⇒O(e)

Ezután eggyel növelhetjük a párok számát =⇒O(n)-szer kell ismételni

Összköltség: O(ne)

(36)

Legrövidebb utak súlyozatlan gráfokban

Ha minden él hossza egy =⇒út hossza = élek száma

Szélességi kereséssel: JelentseD[v]av csúcsnak azs-t ˝ol való távolságát azs-gyöker ˝u szélességi fában.

Legyen kezdetbenD[s] :=0

azszbeljárásba tegyük be aD[y] :=D[x] +1;utasítást, miután elértük y-t.

Lépésszám: O(n+e) Tétel

Az el ˝oz ˝oek szerint módosított szélességi bejárás végeztével teljesülnek a következ ˝ok:

1. Legyen s =x₁,x₂, . . . ,xna csúcsoknak a szélességi bejárás szerinti sorrendje. Ekkor D[x₁]≤D[x₂]≤. . .≤D[x_n].

2. Ha x →y éle G-nek, akkor D[y]≤D[x] +1.

3. D[v] =d(s,v)teljesül minden v ∈V csúcsra.

(37)

Tétel

1. D[x₁]≤D[x₂]≤. . .≤D[xn].

Bizonyítás.

A csúcsok azs=x₁,x₂, . . . ,x_nsorrendben kerülnek bele aQsorba

=⇒ebben a sorrendben is kerülnek ki a sorból.

Hax 6=scsúcs el ˝obb van, minty =⇒apa(x)nem lehet kés ˝obb, mint apa(y), hiszen ha el ˝obb lenne,y-hoz el ˝obb eljutottunk volna.

Indukció =⇒GyökérreD[s] =0, fiaira mind nagyobb. √ D[x_i] =D[apa(x_i)] +1 ésD[x_i+1] =D[apa(x_i+1)] +1 =⇒ Ha a két apa különböz ˝o

=⇒D[apa(x_i)]≤D[apa(x_i+1)] =⇒D[x_i]≤D[x_i+1].

Ha pedig az apák megegyeznek =⇒D[x_i] =D[x_i+1].

(38)

Tétel

2. Ha x →y éle G-nek, akkor D[y]≤D[x] +1 Bizonyítás.

Nézzük, hogy mi történik, amikorx kikerül aQsorból, és éppen az (x,y)élet vizsgáljuk.

Ha bejárva[y] =hamis =⇒y apjax, vagyisD[y] =D[x] +1.

Különbeny-t már korábban láttuk =⇒y apja el ˝obb van, mintx

=⇒D[apa(y)]≤D[x] =⇒D[y] =D[apa(y)] +1≤D[x] +1.

(39)

Tétel

3. D[v] =d(s,v)teljesül minden v ∈V csúcsra.

Bizonyítás.

d(s,v)≤D[v] √

Legyens=y₀,y₁, . . .y_k =v egy minimális hosszúságúG-beli irányított úts-b ˝olv-be.

=⇒az út éleire:D[y₁]≤D[s] +1=1, majdD[y₂]≤D[y₁] +1≤2. . . D[v] =D[y_k]≤k =d(s,v) =⇒ √

(40)

Algoritmuselmélet

Legrövidebb utak, Bellmann-Ford, Dijkstra

Katona Gyula Y.

3. el ˝oadás

(41)

A legrövidebb utak problémája

Legyen adott egyG= (V,E)irányított gráf ac(f),f ∈E élsúlyokkal.

Feladat

Mekkora a legrövidebb útegy adott pontból egy másik adott pontba?

Feladat

Mekkora a legrövidebb útegy adott pontból az összes többibe?

Feladat

Mekkora a legrövidebb útbármely két pont között?

(42)

A legrövidebb utak problémája

AGgráf egyu-tv-vel összeköt ˝o (nem feltétlenül egyszer ˝u)u v irányított útjának ahosszaaz úton szerepl ˝o élek súlyainak összege.

Legrövidebbu v út: egy olyanu v út, melynek a hossza minimális aG-beliu v utak között.

u ésv csúcsok (G-beli)d(u,v)távolsága:

—0, hau=v;

—∞, ha nincsu v út

—egyébként pedig a legrövidebbu v út hossza.

Vigyázat, ittu ésv nem felcserélhet ˝o: ha az egyik csúcs valamilyen távol van a másiktól, akkor nem biztos, hogy a másik is ugyanolyan távol van az egyikt ˝ol!

(43)

A Bellman—Ford-módszer

Feladat

Egy pontból induló legrövidebb utak (hosszának) meghatározására, ha bizonyos élsúlyok negatívak. De feltesszük, hogy Gnem tartalmaz negatív összhosszúságú irányított kört.

Ha van negatív összhosszúságú irányított kör =⇒nincs legrövidebb út.

1 1

− 1

− 1 − 1

Legyen aG= (V,E)súlyozott él ˝u irányított gráf aCszomszédossági mátrixával adott (azi,jhelyzet ˝u elem ac(i,j)élsúly, hai→j éle G-nek, a többi elem pedig∞).

LegyenV ={1,2, . . . ,n}éss=1 ⇐=s-b ˝ol induló utakat keressük

(44)

Módszer:egyT[1:n−1,1:n]táblázat sorról sorra haladó kitöltése=⇒Dinamikus programozás

(∗) T[i,j] = a legrövidebb olyan 1 j irányított utak hossza, melyek legfeljebbiélb ˝ol állnak.

=⇒T[n−1,j]a legrövidebb 1 jutak hossza AT[1,j]sor kitöltése: T[1,j] =C[1,j]

Tegyük fel ezután, hogy azi-edik sort már kitöltöttük

=⇒T[i,1],T[i,2], . . . ,T[i,n]értékekre(∗)igaz. =⇒ (∗∗) T[i+1,j] :=min{T[i,j],min

k6=j{T[i,k] +C[k,j]}}

⇐=Ugyanis egy legfeljebbi+1 élb ˝ol állóπ =1 jút kétféle lehet:

(a)Az útnak kevesebb, minti+1 éle van. Ekkor ennek a hossza szerepelT[i,j]-ben.

(b)Az út éppeni+1 élb ˝ol áll. Legyenlaπ út utolsó el ˝otti pontja.

Ekkor aπút 1 l szakaszai élb ˝ol áll, és minimális hosszúságú a legfeljebbi él ˝u 1 lutak között =⇒π hosszaT[i,l] +C[l,j].

Lépésszám: Egy érték(∗∗)szerinti számításan−1 összeadás és ugyanennyi összehasonlítás (minimumkeresésnelem közül)

=⇒O(n³)m ˝uvelet.

(45)

Példa

v1

v2

v3

v4

2

5 3

4

3 2

3 7

C[i,j] =







0 7 4 ∞

∞ 0 3 ∞

2 2 0 5

∞ 3 3 0







T[i,j] 1 2 3 4

1 0 7 4 ∞

2 0 6 4 9

3 0 6 4 9

T[2,2] =min(7,0+7,4+2,∞+3) =6 T[2,4] =min(∞,0+∞,7+∞,4+5) =9

(46)

Floyd módszere

Feladat

Miként lehet egy irányított gráfban az összes pontpár távolságát meghatározni?

≥0 élsúlyok =⇒ha a Bellmann-Ford algoritmust minden csúcsra mint forrásra lefuttatjuk =⇒nO(n³) =O(n⁴)

Van gyorsabb.

Feladat

Adott egy G = (V,E)irányított gráf és egy c:E →Rsúlyfüggvény úgy, hogy a gráfban nincs negatív összsúlyú irányított kör. Határozzuk meg az összes v,w ∈V rendezett pontpárra a d(v,w)távolságot.

(47)

AGgráf aCszomszédossági mátrixával adott.

Egy szinténn×n-esF mátrixot fogunk használni a számításhoz.

KezdetbenF₀[i,j] :=C[i,j].

ciklus =⇒k-adik lefutása utánF_k[i,j]azoni jutak

legrövidebbjeinek a hosszát tartalmazza, amelyek közbüls ˝o pontjai k-nál nem nagyobb sorszámúak.

Az újF_k[i,j]értékeket kiszámíthatjuk, ha ismerjükFk−1[i,j]-t∀i,j-re.

Egy legrövidebbi j út, melyen a közbüls ˝o pontok sorszáma legfeljebbk, vagy tartalmazza ak csúcsot vagy nem.

— igen =⇒F_k[i,j] :=Fk−1[i,k]+Fk−1[k,j]

k

i

j

— nem =⇒F [i,j] =F [i,j]

(48)

Floyd algoritmusa

(1)fori:=1tondo forj:=1tondo

F[i,j] :=C[i,j]

(2)fork :=1tondo fori:=1tondo

forj:=1tondo

F[i,j] :=min{F[i,j],F[i,k] +F[k,j]}

Tétel

F[i,j]a (2)-beli iteráció k -adik menete után azon legrövidebb i j utak hosszát tartalmazza, amelyek bels ˝o csúcsai1,2, . . . ,k közül valók.

k =n =⇒F_n[i,j] =d(i,j)

Lépésszám: n-szer megyünk végig a táblázaton, minden helyenO(1) lépés =⇒O(n³)

(49)

A legrövidebb utak nyomon-követése

Menet közben karbantartunk egyn×n-esPtömböt.

KezdetbenP[i,j] :=0.

Ha egyF[i,j]értéket megváltoztatunk, mert találtunk egyk-n átmen ˝o rövidebb utat, akkorP[i,j] :=k.

=⇒VégülP[i,j]egy legrövidebbi jút „középs ˝o" csúcsát fogja tartalmazni.

i jút összeállítása rekurzív =⇒ procedurelegrövidebb út(i,j:csúcs);

vark:csúcs;

begin

k :=P[i,j];

ifk =0then return;

legrövidebb út(i,k);

kiír(k);

legrövidebb út(k,j) end;

(50)

Tranzitív lezárás

Bemenet: G= (V,E)irányított gráf.

Csak arra vagyunk kíváncsiak, hogy mely pontok között vezet irányított út.

Floyd =⇒ha a végénF[i,j]6=∞, akkor van út, különben nincs.

Kicsit egyszer ˝ubb, korábbi algoritmus: S. Warshall Definíció

[tranzitív lezárt]Legyen G= (V,E)egy irányított gráf, A a

szomszédossági mátrixa. Legyen továbbá T a következ ˝o n×n-es mátrix:

T[i,j] =

1 ha i-b ˝ol j elérhet ˝o irányított úttal;

0 különben.

Ekkor a T mátrixot – illetve az általa meghatározott gráfot – az A mátrix – illetve az általa meghatározott G gráf –tranzitív lezártjánakhívjuk.

Feladat

Adott a (Boole-mátrixként értelmezett) A szomszédossági mátrixával a G= (V,E)irányított gráf. Adjuk meg a G tranzitív lezártját.

(51)

Warshall algoritmus

(1) ciklusban a kezd ˝oértékek beállítása helyett T₀[i,j] :=

1 hai =j vagyA[i,j] =1, 0 különben.

A (2) ciklusbanF értékeinek változtatása helyett (ugyanazt megfogalmazva logikai m ˝uveletekkel)

(+) T_k[i,j] :=T_k−1[i,j]∨(T_k−1[i,k]∧T_k−1[k,j]).

Bizonyítás ugyanúgy.

Lépésszám: O(n³)

(52)

Dijkstra módszere

Feladat

A legrövidebb utak problémája (egy forrásból):

Adott egy G = (V,E)irányított gráf, a c:E →R⁺nemnegatívérték ˝u súlyfüggvény és egy s∈V csúcs (a forrás). Határozzuk meg minden v ∈V -re a d(s,v)távolságot.

D[ ]:

Egy aGcsúcsaival indexelt tömb

az eljárás során addig megismert legrövidebbs v utak hossza Fels ˝o közelítése a keresettd(s,v)távolságnak

A közelítést lépésr ˝ol lépésre finomítjuk, végüld(s,v)-t érjük el.

(53)

Dijkstra módszere

Tegyük fel, hogy aGgráf az alábbi alakúCszomszédossági mátrixával adott:

C[v,w] =







0 hav =w,

c(v,w) hav 6=w és(v,w)éleG-nek,

∞ különben.

KezdetbenD[v] :=C[s,v]mindenv ∈V csúcsra.

Válasszuk ki ezután azscsúcs szomszédai közül a hozzá legközelebbit, vagyis egy olyanx ∈V \ {s}csúcsot, melyreD[x] minimális.

Biztos, hogy az egyetlen(s,x)élb ˝ol álló út egy legrövidebbs x út (az élsúlyok nemnegatívak!).

AKÉSZhalmaz azokat a csúcsokat tartalmazza, amelyekneks-t ˝ol való távolságát már tudjuk.

=⇒x-et betehetjük (smellé) a KÉSZ halmazba.

(54)

Dijkstra módszere

Ezek után módosítsuk a többi csúcsD[w]értékét,ha az eddig ismertnél rövidebb útonel lehet érni odax-en keresztül, azaz ha D[x] +C[x,w]<D[w].

s

x

w C [x , w ]

Újra válasszunk ki av ∈V \KÉSZ csúcsok közül egy olyat, amelyre D[v]minimális.

Ezen csúcsD[ ]-értéke már azs-t ˝ol való távolságát tartalmazza.

Majd megint aD[ ]-értékeket módosítjuk, és így tovább, míg minden csúcs be nem kerül a KÉSZ halmazba.

(55)

Dijkstra algoritmusa szomszédossági mátrixszal

(1)KÉSZ:={s}

formindenv ∈V csúcsrado

D[v] :=C[s,v](∗ad(s,v)távolság els ˝o közelítése∗) (2)fori:=1ton−1do begin

Válasszunk olyanx ∈V \KÉSZ csúcsot, melyreD[x]minimális.

Tegyükx-et a KÉSZ-be.

(3) formindenw ∈V \KÉSZ csúcsrado

D[w] :=min{D[w],D[x] +C[x,w]}(∗d(s,w)új közelítése∗) end

Definíció

különleges út: egy s z irányított út különleges, ha a z végpontot kivéve minden pontja a KÉSZ halmazban van. A különleges úttal elérhet ˝o pontok éppen a KÉSZ-b ˝ol egyetlen éllel elérhet ˝o pontok.

(56)

Tétel

A (2) ciklus minden iterációs lépése után érvényesek a következ ˝ok:

(a) KÉSZ pontjaira D[v]a legrövidebb s v utak hossza.

(b) Ha v ∈KÉSZ, akkor van olyan d(s,v)hosszúságú (más szóval legrövidebb) s v út is, amelynek minden pontja a KÉSZ halmazban van.

(c) Küls ˝o (vagyis w ∈V \KÉSZ) pontokra D[w]a legrövidebb különleges s w utak hossza.

Bizonyítás.

Indukcióval (2) el ˝ott √

Tegyük fel, hogy igaz aj-edik iteráció után.

Belátjuk, hogy igaz aj+1-edik iteráció után is.

Tegyük fel, hogy az algoritmus aj+1. iterációs lépésben azx csúcsot választja a KÉSZ-be.

(57)

x s

y

(a) Indirekt: mi van, haD[x]

nem ad(s,x) távolságot je- löli, azaz van ennél rövidebb s x út?

Ezen út „eleje" különleges, (c) miatt =⇒

D[y]≤d(x,s)<D[x] (b)Elégx-re ⇐=KÉSZ korábbi pontjaira az indukciós feltevésb ˝ol Láttuk, hogyd(s,x) =D[x], ez egy különlegess x út hossza volt a j+1. iteráció el ˝ott (itt a (c)-re vonatkozó indukciós feltevést használtuk) annak végeztével az út minden pontja KÉSZ-beli lesz.

(58)

x

w s

(c)Aj+1. iteráció el ˝ott

D[w] = min

v∈KÉSZ\{x}

{d(s,v) +C[v,w]}.

Utána D[w] = min

v∈KÉSZ

{d(s,v) +C[v,w]}.

=⇒Elég megnézni, hogyD[w]vagyd(s,x) +C[x,w]nagyobb Lépészám: (2) ciklusO(n), ez lefutn−1-szer =⇒O(n²)

(59)

Példa

5

2 3

1

1 1 3

s f

a b

c e

1

2

D a b c e f KÉSZ

1. 1 ∞ 2 ∞ ∞ {s,a}

2. 6 2 ∞ ∞ {s,a,c}

3. 5 3 ∞ {s,a,c,e}

4. 5 4 {s,a,c,e,f}

5. 5 {s,a,c,e,f,b}

(60)

Algoritmuselmélet

Kupac, Dijkstra kupaccal

Katona Gyula Y.

4. el ˝oadás

(61)

Adatszerkezetek

Definíció

Egyadatszerkezetelemek egy halmazának tárolása, az elemek közötti kapcsolat módja és az elemek kezeléséhez tartozó m ˝uveletek összessége.

Példák:

Tömb–M ˝uveletek:szelekciós függvény

Láncolt lista–M ˝uveletek:els ˝o, következ ˝o, keres, beszúr, beszúrMögé, töröl

Sor–M ˝uveletek:els ˝o, sorba, sorból

(62)

Bináris fa adatszerkezet

Láncolt lista

x

Bináris fa

bal fiú jobb fiú

x

x x x x x x x x

x x

M ˝uveletek: gyökér, bal-fiú, jobb-fiú, keres, beszúr, töröl

(63)

Kupac adatszerkezet

Egész számok egySvéges részhalmazát szeretnénk tárolni, hogy a beszúrás és aminimális elem törlése (mintör)hatékony legyen.

Alkalmazások:

Jobok indítása

Több rendezett halmaz összefésülése Gyors rendezési algoritmus

Teljes bináris fa:

gyökér

levelek

(64)

Bináris fa ábrázolása tömbbel

A fa csúcsai azA[1:n]tömb elemei.

AzA[i]csúcs bal fiaA[2i], a jobb fia pedigA[2i+1].

=⇒A[j]csúcs apjaA[bj/2c]

4

5 9

8

2 6

7

2 4 6 8 5 9 7

Kupac tulajdonság: apa<fia

(65)

Kupacépítés

f₁ f₂

a

c b

f₁ésf₂kupacok

kupacol(f)

{Ha min{a,b}<c, akkor min{a,b}ésc helyet cserél

Ha a c elem a-val cserélt helyet, akkor kupacol(f₁), hab-vel, akkorkupacol(f₂)}

c addig megy lefelé, amíg sérti a kupac tulajdonságot.

Lépésszám: Hal a fa szintjeinek száma, akkor≤l−1 csere és ≤2(l−1) össze- hasonlítás

kupacépítés(f)

{Azf fav csúcsaira lentr ˝ol felfelé, jobbról balrakupacol(v).}

(66)

Kupacépítés költsége

n-csúcsú bináris fában:

1. szint: 1 csúcs 2. szint: 2 csúcs 3. szint: 2²csúcs

...

l−1. szint: 2^l−2csúcs

l-edik szint: ≥1 és≤2^l−1csúcs

=⇒n≥1+Pl−2

i=02ⁱ =2^l−1 =⇒l ≤1+log₂n

Azi-edik szinten lev ˝ov csúcsrakupacol(v)költsége legfeljebbl−i csere és legfeljebb 2(l−i)összehasonlítás.

A cserék száma ezért összesen legfeljebbPl

i=1(l−i)2ⁱ⁻¹. j =l−i (azazi =l−j) helyettesítéssel

l−1

X

j=0

j2^l−j−1=2^l−1

l−1

X

j=1

j/2^j

(67)

Kupacépítés költsége

1/2

1/4 1/4

1/8 1/8 1/8

...

1 2^l−1

1

2^l−1 . . . ₂l−1¹

<1 <1/2 <1/4 · · · ≤ ¹

2^l−1

l−1

X

j=1

j/2^j <2^l ≤2n.

Tétel

Kupacépítés költsége: O(n)

(68)

MINTÖR

A minimális elem azf gyökérben van, ezt töröljük.

Af-be tesszük a fa utolsó szintjének jobb széls ˝o elemét, majd kupacol(f).

5 9

4 2

8

6

2 4

5 9

8

6

2 5

8 9

4

6

Költség: O(l) =O(log₂n)

(69)

BESZÚR

Új levelet adunk a fához (ügyelve a teljességre), ide tesszük azs elemet. Ezutáns-et mozgatjuk felfelé, mindig összehasonlítjuk az apjával.

5 9

4 2

8 1

6

5 9

4 2

8 6

1

5 9

4

8 6

1

2

Költség: O(l) =O(log₂n)

(70)

Dijkstra algoritmusa éllistával

Ha kevés él van =⇒gráfot éllistával tároljuk.

V\KÉSZ csúcsaitkupacba rendezvetartjuk aD[ ]érték szerint.

A kupacépítésO(n)költség, a (2) ciklusban minimumkereséstO(logn) költség ˝u MINTÖR végrehajtásával számoljuk.

AD[ ]értékek újraszámolását és a kupac-tulajdonság helyreállítását csak a választott csúcs szomszédaira kell elvégezni.

Minden csúcsot pontosan egyszer választunk ki, és a szomszédok számának összegee. =⇒Összid ˝oigényO((n+e)logn).

S ˝ur ˝u gráfokra: d-kupac.

=⇒O(n+ndlog_dn+elog_dn)

Han^1,5≤e≤n²és legyend =de/ne =⇒d ≥√

n =⇒log_dn≤2.

=⇒

O(n+ndlog_dn+elog_dn) =O(n+nd+e) =O(n+n·e/n+e) =O(e).

Dijkstra irányítatlan gráfokra is m ˝uködik.

(71)

A legrövidebb utak nyomon követése

Minden pontra tárolunk és karbantartunk egyP[x]csúcsot is, ami megadja egy az eddig ismert hozzá vezet ˝o legrövidebb úton az utolsó el ˝otti csúcsot.

KezdetbenP[v] :=smindenv ∈V-re.

A (3) ciklus belsejében, ha egy küls ˝ow csúcsD[w]értékét megváltoztatjuk, akkorP[w] :=x.

Lépésszám: O(n²)

(72)

Algoritmuselmélet

Keresés, minimumkeresés

Katona Gyula Y.

5. el ˝oadás

(73)

Rendezési reláció

LegyenU egy halmaz, és<egy kétváltozós relációU-n. Haa,b∈U ésa<b, akkor azt mondjuk, hogyakisebb, mintb.

A<reláció egyrendezés, ha teljesülnek a következ ˝ok:

1. a6<amindena∈Uelemre (<irreflexív);

2. Haa,b,c ∈U,a<b, ésb<c, akkora<c(<tranzitív);

3. Tetsz ˝olegesa6=b∈Uelemekre vagya<b, vagyb<afennáll (<

teljes).

Ha<egy rendezésU-n, akkor az(U, <)pártrendezett halmaznak nevezzük.

(74)

Rendezési reláció

Példák:

Zaz egész számok halmaza. A<rendezés a nagyság szerinti rendezés.

Azabcbet ˝uinekΣhalmaza; a<rendezést azabc-sorrendadja.

Azx bet ˝u kisebb, mint azy bet ˝u, hax el ˝obb szerepel az abc-sorrendben, minty.

AΣbet ˝uib ˝ol alkotott szavakΣ^∗ halmaza a szótárszer ˝u vagy lexikografikusrendezéssel.⇒legyenX =x₁x₂· · ·x_k és Y =y₁y₂· · ·y_l két szó.

AzX kisebb mintY, ha vagyl >k ésx_i =y_i ha minden i =1,2, . . . ,k esetén;

vagy pedigx_j <y_j teljesül a legkisebb olyanjindexre, melyre x_j 6=y_j.Tehát példáulkar <karikaésbor <bot.

(75)

Keresés rendezetlen halmazban

Feladat

Adott az U halmaz véges S={s₁,s₂, . . . ,s_n−1,s_n}részhalmaza és s∈U.

El akarjuk eldönteni, hogy igaz-e s∈S, és ha igen, akkor melyik i-re teljesül s_i =s.

Hány összehasonlítás kell?

Itt összehasonlítás: Igaz-e, hogys_i =s?

Válasz: Igenvagynem.

Legrosszabb esetben minden elemet végig kell nézni =⇒ nösszehasonlítás kell legrosszabb esetben.

n/2 összehasonlítás kell átlagosan.

(76)

Keresés rendezett halmazban

Barkochba játék: gondolok egy számot 1 és 100 között, hány eldöntend ˝o kérdésb ˝ol lehet kitalálni?

Feladat

Adott az(U, <)rendezett halmaz véges

S={s₁<s₂< . . . <sn−1<s_n}részhalmaza és s ∈U.

Összehasonlításokkal akarjuk eldönteni, hogy igaz-e s∈S, és ha igen, akkor melyik i-re teljesül s_i =s.

Hány összehasonlítás kell?

Itt összehasonlítás: Mi a viszonyas-nek éss_i-nek?

Válasz: s_i =svagys_i <svagys_i >s.

Lineáris keresés

Sorban mindegyik elemmel összehasonlítjuk.

Költség a legrosszabb esetben: n, mert lehet, hogy pont az utolsó volt.

Költség átlagos esetben esetben: (n/2) +1.

(77)

Bináris keresés

Oszd meg és uralkodj: el ˝oször a középs ˝os_i-vel hasonlítunk.

Hasonló feladatot kapunk egyS₁halmazra, amire viszont|S₁| ≤ |S|/2.

És így tovább:

|S₂| ≤ |S|

4 ,|S₃| ≤ |S|

2³, . . .|S_k| ≤ |S|

2^k Pl. keressük meg, benne van-e 21 az alábbi sorozatban!

15,22,25,37, 48,56,70,82 (1) 15,22, 25,37,48,56,70,82 (2) 15, 22,25,37,48,56,70,82 (3) 15,22,25,37,48,56,70,82 (4)

(78)

Bináris keresés

Addig kell csinálni, amíg|S_k|=1 lesz. Innen 1=|S_k| ≤ ⁿ

2^k.

=⇒2^k ≤n =⇒k ≤ blog₂nc

Ezk+1 összehasonlítás volt. =⇒k+1≤ blog₂nc+1=dlog₂(n+1)e Tétel

Ez optimális, nincs olyan keres ˝o algoritmus, ami minden esetben kevesebb mintdlog₂(n+1)ekérdést használ.

(79)

Bináris keresés

Tétel

Ez optimális, nincs olyan keres ˝o algoritmus, ami minden esetben kevesebb mintdlog₂(n+1)ekérdést használ.

Bizonyítás.

Az ellenség nem is gondol egy számra, csak mindig úgy válaszol, hogy minél többet kelljen kérdezni. Ha egy kérdést felteszek, és azigen válasz után mondjuk szóba jönx lehet ˝oség, akkor anemesetén szóba jön mégn−x −1 lehet ˝oség. (A „−1” azs=s_i válasz miatt van).

Az ellenség úgy válaszol, hogy minél több lehet ˝oség maradjon, így el tudja érni, hogy legalább ⁿ⁻¹₂ marad.

=⇒2 kérdés után legalább

n−1

2 −1

2 = ₂ⁿ2 −¹₂− ¹

2² marad.

=⇒k kérdés után is marad még ₂ⁿ_k −¹₂− · · · − ¹

2^k lehet ˝oség.

Tehát teljesülnie kell ₂ⁿ_k −¹₂− · · · −₂¹_k ≤1-nek.

Vagyisn≤2^k +2^k−1+. . .+1=2^k+1−1.=⇒ dlog₂(n+1)e −1≤k.

(80)

Minimumkeresés

Feladat

Adott az(U, <)rendezett halmaz véges S={s₁,s₂, . . . ,s_n−1,s_n} részhalmaza.

Összehasonlításokkal keressük meg az S minimális elemét, azaz egy olyan s_i elemet, hogy minden i 6=j esetén s_i <s_j.

Hány összehasonlítás kell a legrosszabb esetben?

(81)

Minimumkeresés

Tétel

n elem közül a minimális kiválasztásához legrosszabb esetben n−1 összehasonlítás kell.

Bizonyítás.

n−1 összehasonlítás mindig elég: Rendezzünk kiesés versenyt, mindig a kisebb elemet megtartva egy-egy összehasonlítás után. Mivel

„mindenki pontosan egyszer kap ki a gy ˝oztest kivéve”, ezn−1 összehasonlítást igényel.

n−1 összehasonlításnál kevesebb nem mindig elég:Legyenek az elemek egy gráf pontjai, ha kett ˝ot összehasonlítottunk, húzzunk közöttük élet. Amíg a gráf nem összefügg ˝o, bármely komponensében lehet a minimális elem.

Ha a gráf már összefügg ˝o, akkor legalábbn−1 éle van, tehát kell ennyi összehasonlítás.

(82)

Algoritmuselmélet

Rendezés, buborék, beszúrásos, összefésüléses, kupacos, láda, radix

Katona Gyula Y.

6. el ˝oadás

(83)

Rendezés

Feladat

Adott az(U, <)rendezett halmaz véges S={s₁,s₂, . . . ,sn−1,sn} részhalmaza.

Összehasonlításokkal rendezzük az S elemeit a rendezés szerint növekv ˝o sorrendbe, azaz keressünk olyanσ permutációt, hogy s_σ(1)<s_σ(2)<· · ·<s_σ(n).

Input: tömb, láncolt lista, (vagy bármi) Output: általában, mint az input

Lépések: elemek mozgatása, cseréje, összehasonlítása

A rendezés önmagában is el ˝oforduló feladat, de el ˝ojön, mint hasznos adatstruktúra is. Rendezett halmazban könnyebb keresni (pl.

telefonkönyv).

Hány összehasonlítás kell a legrosszabb esetben?

Hány összehasonlítás kell átlagos esetben?

Hány csere kell a legrosszabb esetben?

(84)

Buborék-rendezés

Input: A[1:n](rendezetlen) tömb

Ha valamelyi-reA[i]>A[i+1], akkor a két cella tartalmát kicseréljük.

A tömb elejér ˝ol indulva, közben cserélgetve eljutunk a tömb végéig.

Ekkor a legnagyobb elemA[n]-ben van. Ismételjük ezt azA[1:n−1]

tömbre, majd azA[1:n−2]tömbre, stb.

procedurebuborék

(* az A[1:n]tömböt növekv ˝oen (nem csökken ˝oen) rendezi *) for(j=n−1,j >0,j :=j−1)do

for(i=1,i≤j,i :=i+1)do

{haA[i+1]<A[i], akkor cseréljük ki ˝oket.}

összehasonlítások száma: n−1+n−2+. . .+1= ⁿ⁽ⁿ⁻¹⁾₂ cserék száma: ≤ ⁿ⁽ⁿ⁻¹⁾₂

(85)

Beszúrásos rendezés

Ha azA[1:k]résztömb már rendezett, akkor szúrjuk be a következ ˝o elemet,A[k+1]-et,lineárisvagybináriskereséssel, majd a következ ˝ot ebbe, stb.

lineáris bináris

összehasonlítás n(n−1)

2

n−1

X

k=1

dlog₂(k+1)e

mozgatás (n+2)(n−1)

2

(n+2)(n−1) 2 átlagos összehasonlítás n(n−1)

4

n−1

X

k=1

dlog₂(n+1)e

átlagos mozgatás n²

4

n² 4

(86)

Bináris beszúrásos rendezés lépésszáma

K :=dlog₂2e+dlog₂3e+· · ·+dlog₂ne ≤ndlog₂ne Jobb becslés: használjuk fel, hogydlog₂ke ≤1+log₂k

K <n−1+log₂2+· · ·+log₂n=n−1+log₂(n!)

Felhasználva a Stirling formulát: n!∼(n/e)ⁿ√

2πnkapjuk, hogy log₂n!∼n(log₂n−log₂e) +1

2log₂n+log₂

√

2π∼n(log₂n−1,442)

EzértK ≤n(log₂n−0,442)elég nagyn-re.

(87)

Alsó becslés összehasonlítás alapú rendezésre

Ugyanaz, mintha barochba-ban kellene kitalálni, hogy az elemek melyik sorrendje (permutációja) az igazi sorrend.

Kezdetbenn!lehetséges sorrend jön szóba.

Két elemet összehasonlítva a válasz két részre osztja a sorrendeket.

Ha pl. azt kapjuk, hogyx <y, akkor az olyan sorrendek, amelyekben x hátrébb vany-nál, már nem jönnek szóba.

Ha az ellenség megint úgy válaszol, hogy minél több sorrend maradjon meg, akkork kérdés után még szóba jön ₂^n!_k sorrend.

Ha ^n!₂k >1, nem tudjuk megadni a rendezést. =⇒ Tétel

Minden összehasonlítás alapú rendez ˝o módszer n elem rendezésekor legalábblog₂(n!)összehasonlítást használ.

(88)

Összefésüléses rendezés

Összefésülés (MERGE):

Két már rendezett sorozat (tömb, lista, stb.) tartalmának egy sorozatba való rendezése:

A[1:k]ésB[1:l]rendezett tömbök−→C[1:k+l]rendezett tömb NyilvánC[1] =min{A[1],B[1]}, pl. A[1],

ezt rakjuk átC-be és töröljükA-ból.

C[2] =min{A[2],B[1]}, stb.

(89)

Példa

A B C

12, 15, 20, 31 13, 16, 18 15, 20, 31 13, 16, 18 12, 15, 20, 31 16, 18 12, 13 20, 31 16, 18 12, 13, 15 20, 31 18 12, 13, 15, 16

20, 31 12, 13, 15, 16, 18

31 12, 13, 15, 16, 18, 20 12, 13, 15, 16, 18, 20, 31

összehasonlítások száma: k+l−1, aholk,l a két tömb hossza

(90)

Összefésüléses rendezés

Alapötlet: Rendezzük külön a tömb els ˝o felét, majd a második felét, végül fésüljük össze.

Ezt csináljuk rekurzívan.

MSORT(A[1:n]) :=

MERGE(MSORT(A[1:dn/2e]),MSORT(A[dn/2e+1:n])).

Hogy elvarrjuk a rekurzió alját, legyen MSORT(A[i,i])az üres utasítás.