133
Adatstruktúrák és Algoritmusok

Adatstruktúrák és Algoritmusok

  • Upload
    others

  • View
    11

  • Download
    0

Embed Size (px)

Citation preview

Page 1: Adatstruktúrák és Algoritmusok

Adatstruktúrák ésAlgoritmusok

Page 2: Adatstruktúrák és Algoritmusok

3. gyakorlat

Rekurzív módon adott sorozatok,A mester tétel és alkalmazásai,Számelméleti algoritmusok I,

Page 3: Adatstruktúrák és Algoritmusok

Rekurzív módon adott sorozatok

Page 4: Adatstruktúrák és Algoritmusok

A Fibonacci sorozat

Leonardo Pisano (a pisai Leonardo), ismertebb nevén Fibonacci(Bonacci fia) (1170(?)-1240), olasz származású matematikus, tőleszármazik az úgynevezett Fibonacci sorozat.

A nyulak szaporodásának axiomatikus elméleteI. Az első hónapban 1 pár nyulunk van.II. Minden nyúlpár 2 hónapos korától havonta egy új nyúlpárnak adéletet.III. A nyulak örök életűek.

Fibonacci kérdése: 1 év elteltével hány pár nyulunk lesz?

Page 5: Adatstruktúrák és Algoritmusok

A Fibonacci sorozat

Leonardo Pisano (a pisai Leonardo), ismertebb nevén Fibonacci(Bonacci fia) (1170(?)-1240), olasz származású matematikus, tőleszármazik az úgynevezett Fibonacci sorozat.

A nyulak szaporodásának axiomatikus elméleteI. Az első hónapban 1 pár nyulunk van.II. Minden nyúlpár 2 hónapos korától havonta egy új nyúlpárnak adéletet.III. A nyulak örök életűek.

Fibonacci kérdése: 1 év elteltével hány pár nyulunk lesz?

Page 6: Adatstruktúrák és Algoritmusok

A Fibonacci sorozat

Leonardo Pisano (a pisai Leonardo), ismertebb nevén Fibonacci(Bonacci fia) (1170(?)-1240), olasz származású matematikus, tőleszármazik az úgynevezett Fibonacci sorozat.

A nyulak szaporodásának axiomatikus elmélete

I. Az első hónapban 1 pár nyulunk van.II. Minden nyúlpár 2 hónapos korától havonta egy új nyúlpárnak adéletet.III. A nyulak örök életűek.

Fibonacci kérdése: 1 év elteltével hány pár nyulunk lesz?

Page 7: Adatstruktúrák és Algoritmusok

A Fibonacci sorozat

Leonardo Pisano (a pisai Leonardo), ismertebb nevén Fibonacci(Bonacci fia) (1170(?)-1240), olasz származású matematikus, tőleszármazik az úgynevezett Fibonacci sorozat.

A nyulak szaporodásának axiomatikus elméleteI. Az első hónapban 1 pár nyulunk van.

II. Minden nyúlpár 2 hónapos korától havonta egy új nyúlpárnak adéletet.III. A nyulak örök életűek.

Fibonacci kérdése: 1 év elteltével hány pár nyulunk lesz?

Page 8: Adatstruktúrák és Algoritmusok

A Fibonacci sorozat

Leonardo Pisano (a pisai Leonardo), ismertebb nevén Fibonacci(Bonacci fia) (1170(?)-1240), olasz származású matematikus, tőleszármazik az úgynevezett Fibonacci sorozat.

A nyulak szaporodásának axiomatikus elméleteI. Az első hónapban 1 pár nyulunk van.II. Minden nyúlpár 2 hónapos korától havonta egy új nyúlpárnak adéletet.

III. A nyulak örök életűek.

Fibonacci kérdése: 1 év elteltével hány pár nyulunk lesz?

Page 9: Adatstruktúrák és Algoritmusok

A Fibonacci sorozat

Leonardo Pisano (a pisai Leonardo), ismertebb nevén Fibonacci(Bonacci fia) (1170(?)-1240), olasz származású matematikus, tőleszármazik az úgynevezett Fibonacci sorozat.

A nyulak szaporodásának axiomatikus elméleteI. Az első hónapban 1 pár nyulunk van.II. Minden nyúlpár 2 hónapos korától havonta egy új nyúlpárnak adéletet.III. A nyulak örök életűek.

Fibonacci kérdése: 1 év elteltével hány pár nyulunk lesz?

Page 10: Adatstruktúrák és Algoritmusok

A Fibonacci sorozat

Leonardo Pisano (a pisai Leonardo), ismertebb nevén Fibonacci(Bonacci fia) (1170(?)-1240), olasz származású matematikus, tőleszármazik az úgynevezett Fibonacci sorozat.

A nyulak szaporodásának axiomatikus elméleteI. Az első hónapban 1 pár nyulunk van.II. Minden nyúlpár 2 hónapos korától havonta egy új nyúlpárnak adéletet.III. A nyulak örök életűek.

Fibonacci kérdése: 1 év elteltével hány pár nyulunk lesz?

Page 11: Adatstruktúrák és Algoritmusok

Megoldás

Jelölje F (n) az n-edik hónapban a nyúlpárok számát. Ekkor aFibonacci sorozat eleget tesz az

F (1) = 1, F (2) = 1F (n + 2) = F (n) + F (n + 1) (n > 1)

kezdeti érték és rekurzió feltételeknek.A rekurzíó alapján könnyű kiszámolni a sorozat alábbi tagjait.

n 0 1 2 3 4 5 6 7 8 9 10 11 12F (n) 0 1 1 2 3 5 8 13 21 34 55 89 144

Tehát válaszolva Fibonacci kérdésére 144 pár nyulunk lesz.A rekurzív definíció felhasználásával az F100 kézzel történőkiszámolása már egy kicsit nehezebb.

Page 12: Adatstruktúrák és Algoritmusok

Megoldás

Jelölje F (n) az n-edik hónapban a nyúlpárok számát. Ekkor aFibonacci sorozat eleget tesz az

F (1) = 1, F (2) = 1F (n + 2) = F (n) + F (n + 1) (n > 1)

kezdeti érték és rekurzió feltételeknek.A rekurzíó alapján könnyű kiszámolni a sorozat alábbi tagjait.

n 0 1 2 3 4 5 6 7 8 9 10 11 12F (n) 0 1 1 2 3 5 8 13 21 34 55 89 144

Tehát válaszolva Fibonacci kérdésére 144 pár nyulunk lesz.A rekurzív definíció felhasználásával az F100 kézzel történőkiszámolása már egy kicsit nehezebb.

Page 13: Adatstruktúrák és Algoritmusok

Megoldás

Jelölje F (n) az n-edik hónapban a nyúlpárok számát. Ekkor aFibonacci sorozat eleget tesz az

F (1) = 1, F (2) = 1F (n + 2) = F (n) + F (n + 1) (n > 1)

kezdeti érték és rekurzió feltételeknek.

A rekurzíó alapján könnyű kiszámolni a sorozat alábbi tagjait.

n 0 1 2 3 4 5 6 7 8 9 10 11 12F (n) 0 1 1 2 3 5 8 13 21 34 55 89 144

Tehát válaszolva Fibonacci kérdésére 144 pár nyulunk lesz.A rekurzív definíció felhasználásával az F100 kézzel történőkiszámolása már egy kicsit nehezebb.

Page 14: Adatstruktúrák és Algoritmusok

Megoldás

Jelölje F (n) az n-edik hónapban a nyúlpárok számát. Ekkor aFibonacci sorozat eleget tesz az

F (1) = 1, F (2) = 1F (n + 2) = F (n) + F (n + 1) (n > 1)

kezdeti érték és rekurzió feltételeknek.A rekurzíó alapján könnyű kiszámolni a sorozat alábbi tagjait.

n 0 1 2 3 4 5 6 7 8 9 10 11 12F (n) 0 1 1 2 3 5 8 13 21 34 55 89 144

Tehát válaszolva Fibonacci kérdésére 144 pár nyulunk lesz.A rekurzív definíció felhasználásával az F100 kézzel történőkiszámolása már egy kicsit nehezebb.

Page 15: Adatstruktúrák és Algoritmusok

Megoldás

Jelölje F (n) az n-edik hónapban a nyúlpárok számát. Ekkor aFibonacci sorozat eleget tesz az

F (1) = 1, F (2) = 1F (n + 2) = F (n) + F (n + 1) (n > 1)

kezdeti érték és rekurzió feltételeknek.A rekurzíó alapján könnyű kiszámolni a sorozat alábbi tagjait.

n 0 1 2 3 4 5 6 7 8 9 10 11 12F (n) 0 1 1 2 3 5 8 13 21 34 55 89 144

Tehát válaszolva Fibonacci kérdésére 144 pár nyulunk lesz.

A rekurzív definíció felhasználásával az F100 kézzel történőkiszámolása már egy kicsit nehezebb.

Page 16: Adatstruktúrák és Algoritmusok

Megoldás

Jelölje F (n) az n-edik hónapban a nyúlpárok számát. Ekkor aFibonacci sorozat eleget tesz az

F (1) = 1, F (2) = 1F (n + 2) = F (n) + F (n + 1) (n > 1)

kezdeti érték és rekurzió feltételeknek.A rekurzíó alapján könnyű kiszámolni a sorozat alábbi tagjait.

n 0 1 2 3 4 5 6 7 8 9 10 11 12F (n) 0 1 1 2 3 5 8 13 21 34 55 89 144

Tehát válaszolva Fibonacci kérdésére 144 pár nyulunk lesz.A rekurzív definíció felhasználásával az F100 kézzel történőkiszámolása már egy kicsit nehezebb.

Page 17: Adatstruktúrák és Algoritmusok

A Binet formula

Az alábbi Binet formula mutatja a rekurzió feloldását, azaz azexplicit alakot.

Binet formula

Fn =1√5

(Φn − Φ

n), ahol Φ =

1 +√5

2, Φ =

1−√5

2

A rekurzív definíció és az explicit forma között az a különbség, hogya rekurzív forma esetén, ha F100 kiszámítása lenne a cél, akkorszépen el kellene lépegetnünk egyesével 100-ig, az explicitösszefüggés viszont "kapásból" megadja az eredményt.A Binet formula alapján látható, hogy

F (100) = 3.5422 · 1020,

azaz ha a nyulak valóban úgy szaporodnának, ahogyan azt aFibonacci féle rekurzív formula előírja, akkor 100 hónap elteltévelmindent elborítanának a nyulak.

Page 18: Adatstruktúrák és Algoritmusok

A Binet formulaAz alábbi Binet formula mutatja a rekurzió feloldását, azaz azexplicit alakot.

Binet formula

Fn =1√5

(Φn − Φ

n), ahol Φ =

1 +√5

2, Φ =

1−√5

2

A rekurzív definíció és az explicit forma között az a különbség, hogya rekurzív forma esetén, ha F100 kiszámítása lenne a cél, akkorszépen el kellene lépegetnünk egyesével 100-ig, az explicitösszefüggés viszont "kapásból" megadja az eredményt.A Binet formula alapján látható, hogy

F (100) = 3.5422 · 1020,

azaz ha a nyulak valóban úgy szaporodnának, ahogyan azt aFibonacci féle rekurzív formula előírja, akkor 100 hónap elteltévelmindent elborítanának a nyulak.

Page 19: Adatstruktúrák és Algoritmusok

A Binet formulaAz alábbi Binet formula mutatja a rekurzió feloldását, azaz azexplicit alakot.

Binet formula

Fn =1√5

(Φn − Φ

n), ahol Φ =

1 +√5

2, Φ =

1−√5

2

A rekurzív definíció és az explicit forma között az a különbség, hogya rekurzív forma esetén, ha F100 kiszámítása lenne a cél, akkorszépen el kellene lépegetnünk egyesével 100-ig, az explicitösszefüggés viszont "kapásból" megadja az eredményt.

A Binet formula alapján látható, hogy

F (100) = 3.5422 · 1020,

azaz ha a nyulak valóban úgy szaporodnának, ahogyan azt aFibonacci féle rekurzív formula előírja, akkor 100 hónap elteltévelmindent elborítanának a nyulak.

Page 20: Adatstruktúrák és Algoritmusok

A Binet formulaAz alábbi Binet formula mutatja a rekurzió feloldását, azaz azexplicit alakot.

Binet formula

Fn =1√5

(Φn − Φ

n), ahol Φ =

1 +√5

2, Φ =

1−√5

2

A rekurzív definíció és az explicit forma között az a különbség, hogya rekurzív forma esetén, ha F100 kiszámítása lenne a cél, akkorszépen el kellene lépegetnünk egyesével 100-ig, az explicitösszefüggés viszont "kapásból" megadja az eredményt.A Binet formula alapján látható, hogy

F (100) = 3.5422 · 1020,

azaz ha a nyulak valóban úgy szaporodnának, ahogyan azt aFibonacci féle rekurzív formula előírja, akkor 100 hónap elteltévelmindent elborítanának a nyulak.

Page 21: Adatstruktúrák és Algoritmusok

Fn előállítása kerekítéssel

F (n) = Round(

1√5

Φn

)

Page 22: Adatstruktúrák és Algoritmusok

Fn előállítása kerekítéssel

F (n) = Round(

1√5

Φn

)

Page 23: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −T (6) = T (3) + 1 = −T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 24: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −T (6) = T (3) + 1 = −T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 25: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1

T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −T (6) = T (3) + 1 = −T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 26: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2

T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −T (6) = T (3) + 1 = −T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 27: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −

T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −T (6) = T (3) + 1 = −T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 28: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3

T (5) = −T (6) = T (3) + 1 = −T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 29: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −

T (6) = T (3) + 1 = −T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 30: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −T (6) = T (3) + 1 = −

T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 31: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −T (6) = T (3) + 1 = −T (7) = −

T (8) = T (4) + 1 = 3 + 1 = 4Sejtés: ?

Page 32: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −T (6) = T (3) + 1 = −T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 33: Adatstruktúrák és Algoritmusok

Feladat

Oldjuk fel az alábbi rekurziót: F (1) = 1, T (n) = T(n2

)+ 1

T (1) = 1T (2) = T (1) + 1 = 1 + 1 = 2T (3) = −T (4) = T (2) + 1 = 2 + 1 = 3T (5) = −T (6) = T (3) + 1 = −T (7) = −T (8) = T (4) + 1 = 3 + 1 = 4

Sejtés: ?

Page 34: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (n) csak akkor számolható, ha n = 2k .Definiáljuk az U(k) sorozatot U(k) := T (2k) módon. A rekurzió:

U(k) = T (2k) = T (2k−1) + 1 = U(k − 1) + 1 (k = 1, 2, . . . )

U(0) = 1, U(1) = 2. Így U(k) egy számtani sorozat U(1) = 2,d = 1 paraméterekkel.Ekkor

U(k) = U(1) + (k − 1) · 1 = 2 + (k − 1)1 = k + 1.

A kapott összefüggés k = 1 esetén is érvényes.Ekkor T (2k) = k + 1. Írjunk k helyére log(n)-et, amiből kapjuk,hogy

T (n) = log(n) + 1

n = 1, 2, . . . , azaz T (n) = Θ(log(n)).

Page 35: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (n) csak akkor számolható, ha n = 2k .

Definiáljuk az U(k) sorozatot U(k) := T (2k) módon. A rekurzió:

U(k) = T (2k) = T (2k−1) + 1 = U(k − 1) + 1 (k = 1, 2, . . . )

U(0) = 1, U(1) = 2. Így U(k) egy számtani sorozat U(1) = 2,d = 1 paraméterekkel.Ekkor

U(k) = U(1) + (k − 1) · 1 = 2 + (k − 1)1 = k + 1.

A kapott összefüggés k = 1 esetén is érvényes.Ekkor T (2k) = k + 1. Írjunk k helyére log(n)-et, amiből kapjuk,hogy

T (n) = log(n) + 1

n = 1, 2, . . . , azaz T (n) = Θ(log(n)).

Page 36: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (n) csak akkor számolható, ha n = 2k .Definiáljuk az U(k) sorozatot U(k) := T (2k) módon. A rekurzió:

U(k) = T (2k) = T (2k−1) + 1 = U(k − 1) + 1 (k = 1, 2, . . . )

U(0) = 1, U(1) = 2. Így U(k) egy számtani sorozat U(1) = 2,d = 1 paraméterekkel.Ekkor

U(k) = U(1) + (k − 1) · 1 = 2 + (k − 1)1 = k + 1.

A kapott összefüggés k = 1 esetén is érvényes.Ekkor T (2k) = k + 1. Írjunk k helyére log(n)-et, amiből kapjuk,hogy

T (n) = log(n) + 1

n = 1, 2, . . . , azaz T (n) = Θ(log(n)).

Page 37: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (n) csak akkor számolható, ha n = 2k .Definiáljuk az U(k) sorozatot U(k) := T (2k) módon. A rekurzió:

U(k) = T (2k) = T (2k−1) + 1 = U(k − 1) + 1 (k = 1, 2, . . . )

U(0) = 1, U(1) = 2. Így U(k) egy számtani sorozat U(1) = 2,d = 1 paraméterekkel.

Ekkor

U(k) = U(1) + (k − 1) · 1 = 2 + (k − 1)1 = k + 1.

A kapott összefüggés k = 1 esetén is érvényes.Ekkor T (2k) = k + 1. Írjunk k helyére log(n)-et, amiből kapjuk,hogy

T (n) = log(n) + 1

n = 1, 2, . . . , azaz T (n) = Θ(log(n)).

Page 38: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (n) csak akkor számolható, ha n = 2k .Definiáljuk az U(k) sorozatot U(k) := T (2k) módon. A rekurzió:

U(k) = T (2k) = T (2k−1) + 1 = U(k − 1) + 1 (k = 1, 2, . . . )

U(0) = 1, U(1) = 2. Így U(k) egy számtani sorozat U(1) = 2,d = 1 paraméterekkel.Ekkor

U(k) = U(1) + (k − 1) · 1 = 2 + (k − 1)1 = k + 1.

A kapott összefüggés k = 1 esetén is érvényes.

Ekkor T (2k) = k + 1. Írjunk k helyére log(n)-et, amiből kapjuk,hogy

T (n) = log(n) + 1

n = 1, 2, . . . , azaz T (n) = Θ(log(n)).

Page 39: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (n) csak akkor számolható, ha n = 2k .Definiáljuk az U(k) sorozatot U(k) := T (2k) módon. A rekurzió:

U(k) = T (2k) = T (2k−1) + 1 = U(k − 1) + 1 (k = 1, 2, . . . )

U(0) = 1, U(1) = 2. Így U(k) egy számtani sorozat U(1) = 2,d = 1 paraméterekkel.Ekkor

U(k) = U(1) + (k − 1) · 1 = 2 + (k − 1)1 = k + 1.

A kapott összefüggés k = 1 esetén is érvényes.Ekkor T (2k) = k + 1. Írjunk k helyére log(n)-et, amiből kapjuk,hogy

T (n) = log(n) + 1

n = 1, 2, . . . , azaz T (n) = Θ(log(n)).

Page 40: Adatstruktúrák és Algoritmusok

A mester tétel és alkalmazása

Page 41: Adatstruktúrák és Algoritmusok

Polinomiálisan lassabb és gyorsabb növekedésadott tesztfüggvénytől

Definíció Legyen p > 0 és f (n) egy növekedési függvény. Aztmondjuk, hogy

az f (n) polinomiálisan lassabban nő, mint a np

tesztpolinom, ha ∃ε > 0 : f (n) = O(np−ε)

az f (n) polinomiálisan gyorsabban nő, mint a np

tesztpolinom, ha ∃ε > 0 : f (n) = Ω(np+ε)

Page 42: Adatstruktúrák és Algoritmusok

Polinomiálisan lassabb és gyorsabb növekedésadott tesztfüggvénytől

Definíció Legyen p > 0 és f (n) egy növekedési függvény. Aztmondjuk, hogy

az f (n) polinomiálisan lassabban nő, mint a np

tesztpolinom, ha ∃ε > 0 : f (n) = O(np−ε)

az f (n) polinomiálisan gyorsabban nő, mint a np

tesztpolinom, ha ∃ε > 0 : f (n) = Ω(np+ε)

Page 43: Adatstruktúrák és Algoritmusok

Polinomiálisan lassabb és gyorsabb növekedésadott tesztfüggvénytől

Definíció Legyen p > 0 és f (n) egy növekedési függvény. Aztmondjuk, hogy

az f (n) polinomiálisan lassabban nő, mint a np

tesztpolinom, ha ∃ε > 0 : f (n) = O(np−ε)

az f (n) polinomiálisan gyorsabban nő, mint a np

tesztpolinom, ha ∃ε > 0 : f (n) = Ω(np+ε)

Page 44: Adatstruktúrák és Algoritmusok

Polinomiálisan lassabb és gyorsabb növekedésadott tesztfüggvénytől

Definíció Legyen p > 0 és f (n) egy növekedési függvény. Aztmondjuk, hogy

az f (n) polinomiálisan lassabban nő, mint a np

tesztpolinom, ha ∃ε > 0 : f (n) = O(np−ε)

az f (n) polinomiálisan gyorsabban nő, mint a np

tesztpolinom, ha ∃ε > 0 : f (n) = Ω(np+ε)

Page 45: Adatstruktúrák és Algoritmusok

Feladat

Bizonyítsuk be, hogy ha ε > 0, akkor

log(n) = O(nε),

így log(n) polinomiálisan lassabban nő, mint az nε tesztpolinom.

Page 46: Adatstruktúrák és Algoritmusok

Feladat

Bizonyítsuk be, hogy ha ε > 0, akkor

log(n) = O(nε),

így log(n) polinomiálisan lassabban nő, mint az nε tesztpolinom.

Page 47: Adatstruktúrák és Algoritmusok

Feladat

Bizonyítsuk be, hogy ha ε > 0, akkor

log(n) = O(nε),

így log(n) polinomiálisan lassabban nő, mint az nε tesztpolinom.

Page 48: Adatstruktúrák és Algoritmusok

Feladat

Bizonyítsuk be, hogy ha ε > 0, akkor

log(n) = O(nε),

így log(n) polinomiálisan lassabban nő, mint az nε tesztpolinom.

Page 49: Adatstruktúrák és Algoritmusok

Megoldás

A L’Hospital szabály alkalmazásával kapjuk, hogy

limx→∞

log(n)

xε= lim

x→∞

1ln(2)

1x

εxε−1 =1

ln(2)limx→∞

1εxε

= 0,

azaz log(n) = o(nε), amiből kapjuk, hogy log(n) = O(nε).

Page 50: Adatstruktúrák és Algoritmusok

Megoldás

A L’Hospital szabály alkalmazásával kapjuk, hogy

limx→∞

log(n)

xε= lim

x→∞

1ln(2)

1x

εxε−1 =1

ln(2)limx→∞

1εxε

= 0,

azaz log(n) = o(nε), amiből kapjuk, hogy log(n) = O(nε).

Page 51: Adatstruktúrák és Algoritmusok

Feladat

Legyenek f (n) = n log(n), g(n) = np valamely p > 0 esetén.Ekkor

a. Ha p > 1, akkor f (n) = n log(n) polinomiálisanlassabban nő, mint a g(n) = np tesztpolinom.

b. Ha p = 1, akkor f (n) = n log(n) gyorsabban nő, minta g(n) = np tesztpolinom, de nem polinomiálisan.

c. Ha 0 6 p < 1, akkor f (n) = n log(n) polinomiálisangyorsabban nő, mint a g(n) = np tesztpolinom.

Page 52: Adatstruktúrák és Algoritmusok

Feladat

Legyenek f (n) = n log(n), g(n) = np valamely p > 0 esetén.Ekkor

a. Ha p > 1, akkor f (n) = n log(n) polinomiálisanlassabban nő, mint a g(n) = np tesztpolinom.

b. Ha p = 1, akkor f (n) = n log(n) gyorsabban nő, minta g(n) = np tesztpolinom, de nem polinomiálisan.

c. Ha 0 6 p < 1, akkor f (n) = n log(n) polinomiálisangyorsabban nő, mint a g(n) = np tesztpolinom.

Page 53: Adatstruktúrák és Algoritmusok

Feladat

Legyenek f (n) = n log(n), g(n) = np valamely p > 0 esetén.Ekkor

a. Ha p > 1, akkor f (n) = n log(n) polinomiálisanlassabban nő, mint a g(n) = np tesztpolinom.

b. Ha p = 1, akkor f (n) = n log(n) gyorsabban nő, minta g(n) = np tesztpolinom, de nem polinomiálisan.

c. Ha 0 6 p < 1, akkor f (n) = n log(n) polinomiálisangyorsabban nő, mint a g(n) = np tesztpolinom.

Page 54: Adatstruktúrák és Algoritmusok

Feladat

Legyenek f (n) = n log(n), g(n) = np valamely p > 0 esetén.Ekkor

a. Ha p > 1, akkor f (n) = n log(n) polinomiálisanlassabban nő, mint a g(n) = np tesztpolinom.

b. Ha p = 1, akkor f (n) = n log(n) gyorsabban nő, minta g(n) = np tesztpolinom, de nem polinomiálisan.

c. Ha 0 6 p < 1, akkor f (n) = n log(n) polinomiálisangyorsabban nő, mint a g(n) = np tesztpolinom.

Page 55: Adatstruktúrák és Algoritmusok

Feladat

Legyenek f (n) = n log(n), g(n) = np valamely p > 0 esetén.Ekkor

a. Ha p > 1, akkor f (n) = n log(n) polinomiálisanlassabban nő, mint a g(n) = np tesztpolinom.

b. Ha p = 1, akkor f (n) = n log(n) gyorsabban nő, minta g(n) = np tesztpolinom, de nem polinomiálisan.

c. Ha 0 6 p < 1, akkor f (n) = n log(n) polinomiálisangyorsabban nő, mint a g(n) = np tesztpolinom.

Page 56: Adatstruktúrák és Algoritmusok

A Mester tétel arra használható, hogy bizonyos speciális alakúrekurzív módon adott növekedési függvényről a rekurzió feloldásanélkül meg tudjuk mondani, hogy milyen növekedési rendű.

Page 57: Adatstruktúrák és Algoritmusok

A mester tétel

Legyenek a > 1, b > 1, p = logb(a), a, b ∈ R, f : Z+ → R+ egynövekedési függvény, g(n) = np a tesztpolinom.Rekurziós összefüggés:

T (n) = aT(nb

)+ f (n)

M1 Ha f (n) polinomiálisan lassabb növekedésű, mint ag(n) = np tesztpolinom, akkor T (n) = Θ(g(n)).

M2 Ha f (n) = Θ(g(n)), akkor T (n) = Θ(g(n) log(n)).M3 Ha f (n) polinomiálisan gyorsabb növekedésű, mint a

g(n) = np tesztpolinom és teljesül az úgynevezettregularitási feltétel, azaz

∃(c < 1)∃(n0 ∈ Z+)∀(n > n0) : af(nb

)6 cf (n)

akkor T (n) = Θ(f (n)).

Page 58: Adatstruktúrák és Algoritmusok

A mester tétel

Legyenek a > 1, b > 1, p = logb(a), a, b ∈ R, f : Z+ → R+ egynövekedési függvény, g(n) = np a tesztpolinom.

Rekurziós összefüggés:

T (n) = aT(nb

)+ f (n)

M1 Ha f (n) polinomiálisan lassabb növekedésű, mint ag(n) = np tesztpolinom, akkor T (n) = Θ(g(n)).

M2 Ha f (n) = Θ(g(n)), akkor T (n) = Θ(g(n) log(n)).M3 Ha f (n) polinomiálisan gyorsabb növekedésű, mint a

g(n) = np tesztpolinom és teljesül az úgynevezettregularitási feltétel, azaz

∃(c < 1)∃(n0 ∈ Z+)∀(n > n0) : af(nb

)6 cf (n)

akkor T (n) = Θ(f (n)).

Page 59: Adatstruktúrák és Algoritmusok

A mester tétel

Legyenek a > 1, b > 1, p = logb(a), a, b ∈ R, f : Z+ → R+ egynövekedési függvény, g(n) = np a tesztpolinom.Rekurziós összefüggés:

T (n) = aT(nb

)+ f (n)

M1 Ha f (n) polinomiálisan lassabb növekedésű, mint ag(n) = np tesztpolinom, akkor T (n) = Θ(g(n)).

M2 Ha f (n) = Θ(g(n)), akkor T (n) = Θ(g(n) log(n)).M3 Ha f (n) polinomiálisan gyorsabb növekedésű, mint a

g(n) = np tesztpolinom és teljesül az úgynevezettregularitási feltétel, azaz

∃(c < 1)∃(n0 ∈ Z+)∀(n > n0) : af(nb

)6 cf (n)

akkor T (n) = Θ(f (n)).

Page 60: Adatstruktúrák és Algoritmusok

A mester tétel

Legyenek a > 1, b > 1, p = logb(a), a, b ∈ R, f : Z+ → R+ egynövekedési függvény, g(n) = np a tesztpolinom.Rekurziós összefüggés:

T (n) = aT(nb

)+ f (n)

M1 Ha f (n) polinomiálisan lassabb növekedésű, mint ag(n) = np tesztpolinom, akkor T (n) = Θ(g(n)).

M2 Ha f (n) = Θ(g(n)), akkor T (n) = Θ(g(n) log(n)).M3 Ha f (n) polinomiálisan gyorsabb növekedésű, mint a

g(n) = np tesztpolinom és teljesül az úgynevezettregularitási feltétel, azaz

∃(c < 1)∃(n0 ∈ Z+)∀(n > n0) : af(nb

)6 cf (n)

akkor T (n) = Θ(f (n)).

Page 61: Adatstruktúrák és Algoritmusok

A mester tétel

Legyenek a > 1, b > 1, p = logb(a), a, b ∈ R, f : Z+ → R+ egynövekedési függvény, g(n) = np a tesztpolinom.Rekurziós összefüggés:

T (n) = aT(nb

)+ f (n)

M1 Ha f (n) polinomiálisan lassabb növekedésű, mint ag(n) = np tesztpolinom, akkor T (n) = Θ(g(n)).

M2 Ha f (n) = Θ(g(n)), akkor T (n) = Θ(g(n) log(n)).

M3 Ha f (n) polinomiálisan gyorsabb növekedésű, mint ag(n) = np tesztpolinom és teljesül az úgynevezettregularitási feltétel, azaz

∃(c < 1)∃(n0 ∈ Z+)∀(n > n0) : af(nb

)6 cf (n)

akkor T (n) = Θ(f (n)).

Page 62: Adatstruktúrák és Algoritmusok

A mester tétel

Legyenek a > 1, b > 1, p = logb(a), a, b ∈ R, f : Z+ → R+ egynövekedési függvény, g(n) = np a tesztpolinom.Rekurziós összefüggés:

T (n) = aT(nb

)+ f (n)

M1 Ha f (n) polinomiálisan lassabb növekedésű, mint ag(n) = np tesztpolinom, akkor T (n) = Θ(g(n)).

M2 Ha f (n) = Θ(g(n)), akkor T (n) = Θ(g(n) log(n)).M3 Ha f (n) polinomiálisan gyorsabb növekedésű, mint a

g(n) = np tesztpolinom és teljesül az úgynevezettregularitási feltétel, azaz

∃(c < 1)∃(n0 ∈ Z+)∀(n > n0) : af(nb

)6 cf (n)

akkor T (n) = Θ(f (n)).

Page 63: Adatstruktúrák és Algoritmusok

Feladatok

1. T (n) = T (n2 ) + 1.a = 1, b = 2, p = log2(1) = 0, f (n) = n0 = 1, g(n) = n0 = 1.Ekkor f (n) = Θ(g(n)). Így a M2 alapján T (n) = Θ(1. log(n)).

2. T (n) = 4T (n2 ) + n.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n1,g(n) = n2. Az f (n) = n1 polinomiálisan lassabban nő, mintg(n) = n2 tesztpolinom, így a M1 alapjánT (n) = Θ(g(n)) = Θ(n2).

3. T (n) = 4T (n2 ) + n2.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n2,g(n) = n2. f (n) = Θ(g(n)), M2 alapjánT (n) = Θ(g(n) log(n)) = Θ(n2 log(n)).

Page 64: Adatstruktúrák és Algoritmusok

Feladatok

1. T (n) = T (n2 ) + 1.

a = 1, b = 2, p = log2(1) = 0, f (n) = n0 = 1, g(n) = n0 = 1.Ekkor f (n) = Θ(g(n)). Így a M2 alapján T (n) = Θ(1. log(n)).

2. T (n) = 4T (n2 ) + n.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n1,g(n) = n2. Az f (n) = n1 polinomiálisan lassabban nő, mintg(n) = n2 tesztpolinom, így a M1 alapjánT (n) = Θ(g(n)) = Θ(n2).

3. T (n) = 4T (n2 ) + n2.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n2,g(n) = n2. f (n) = Θ(g(n)), M2 alapjánT (n) = Θ(g(n) log(n)) = Θ(n2 log(n)).

Page 65: Adatstruktúrák és Algoritmusok

Feladatok

1. T (n) = T (n2 ) + 1.a = 1, b = 2, p = log2(1) = 0, f (n) = n0 = 1, g(n) = n0 = 1.Ekkor f (n) = Θ(g(n)). Így a M2 alapján T (n) = Θ(1. log(n)).

2. T (n) = 4T (n2 ) + n.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n1,g(n) = n2. Az f (n) = n1 polinomiálisan lassabban nő, mintg(n) = n2 tesztpolinom, így a M1 alapjánT (n) = Θ(g(n)) = Θ(n2).

3. T (n) = 4T (n2 ) + n2.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n2,g(n) = n2. f (n) = Θ(g(n)), M2 alapjánT (n) = Θ(g(n) log(n)) = Θ(n2 log(n)).

Page 66: Adatstruktúrák és Algoritmusok

Feladatok

1. T (n) = T (n2 ) + 1.a = 1, b = 2, p = log2(1) = 0, f (n) = n0 = 1, g(n) = n0 = 1.Ekkor f (n) = Θ(g(n)). Így a M2 alapján T (n) = Θ(1. log(n)).

2. T (n) = 4T (n2 ) + n.

a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n1,g(n) = n2. Az f (n) = n1 polinomiálisan lassabban nő, mintg(n) = n2 tesztpolinom, így a M1 alapjánT (n) = Θ(g(n)) = Θ(n2).

3. T (n) = 4T (n2 ) + n2.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n2,g(n) = n2. f (n) = Θ(g(n)), M2 alapjánT (n) = Θ(g(n) log(n)) = Θ(n2 log(n)).

Page 67: Adatstruktúrák és Algoritmusok

Feladatok

1. T (n) = T (n2 ) + 1.a = 1, b = 2, p = log2(1) = 0, f (n) = n0 = 1, g(n) = n0 = 1.Ekkor f (n) = Θ(g(n)). Így a M2 alapján T (n) = Θ(1. log(n)).

2. T (n) = 4T (n2 ) + n.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n1,g(n) = n2. Az f (n) = n1 polinomiálisan lassabban nő, mintg(n) = n2 tesztpolinom, így a M1 alapjánT (n) = Θ(g(n)) = Θ(n2).

3. T (n) = 4T (n2 ) + n2.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n2,g(n) = n2. f (n) = Θ(g(n)), M2 alapjánT (n) = Θ(g(n) log(n)) = Θ(n2 log(n)).

Page 68: Adatstruktúrák és Algoritmusok

Feladatok

1. T (n) = T (n2 ) + 1.a = 1, b = 2, p = log2(1) = 0, f (n) = n0 = 1, g(n) = n0 = 1.Ekkor f (n) = Θ(g(n)). Így a M2 alapján T (n) = Θ(1. log(n)).

2. T (n) = 4T (n2 ) + n.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n1,g(n) = n2. Az f (n) = n1 polinomiálisan lassabban nő, mintg(n) = n2 tesztpolinom, így a M1 alapjánT (n) = Θ(g(n)) = Θ(n2).

3. T (n) = 4T (n2 ) + n2.

a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n2,g(n) = n2. f (n) = Θ(g(n)), M2 alapjánT (n) = Θ(g(n) log(n)) = Θ(n2 log(n)).

Page 69: Adatstruktúrák és Algoritmusok

Feladatok

1. T (n) = T (n2 ) + 1.a = 1, b = 2, p = log2(1) = 0, f (n) = n0 = 1, g(n) = n0 = 1.Ekkor f (n) = Θ(g(n)). Így a M2 alapján T (n) = Θ(1. log(n)).

2. T (n) = 4T (n2 ) + n.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n1,g(n) = n2. Az f (n) = n1 polinomiálisan lassabban nő, mintg(n) = n2 tesztpolinom, így a M1 alapjánT (n) = Θ(g(n)) = Θ(n2).

3. T (n) = 4T (n2 ) + n2.a = 4, b = 2, p = logb(a) = log2(4) = 2, f (n) = n2,g(n) = n2. f (n) = Θ(g(n)), M2 alapjánT (n) = Θ(g(n) log(n)) = Θ(n2 log(n)).

Page 70: Adatstruktúrák és Algoritmusok

4. T (n) = 4T (n3 ) + n3.

a = 4, b = 3, p = logb(a) = log3(4), f (n) = n3, g(n) = np.

p = log3(4) < log3(27) = 3

(itt használtunk egy kis becslést, de elég lett volna log3(4)-etbeütni a számológépbe ahhoz, hogy megkapjuk, hogylog3(4) < 3).f (n) = n3 polinomiálisan gyorsabban nő, mint a g(n)tesztpolinom. Az M3-hoz még ellenőrizni kell még arelgulatitási feltételt:

af(nb

)= 4 ·

(n3

)3=

427· n3 =

427· f (n), c =

427

< 1.

Így kapjuk, hogy T (n) = Θ(f (n)) = Θ(n3).

Page 71: Adatstruktúrák és Algoritmusok

4. T (n) = 4T (n3 ) + n3.a = 4, b = 3, p = logb(a) = log3(4), f (n) = n3, g(n) = np.

p = log3(4) < log3(27) = 3

(itt használtunk egy kis becslést, de elég lett volna log3(4)-etbeütni a számológépbe ahhoz, hogy megkapjuk, hogylog3(4) < 3).f (n) = n3 polinomiálisan gyorsabban nő, mint a g(n)tesztpolinom. Az M3-hoz még ellenőrizni kell még arelgulatitási feltételt:

af(nb

)= 4 ·

(n3

)3=

427· n3 =

427· f (n), c =

427

< 1.

Így kapjuk, hogy T (n) = Θ(f (n)) = Θ(n3).

Page 72: Adatstruktúrák és Algoritmusok

4. T (n) = 4T (n3 ) + n3.a = 4, b = 3, p = logb(a) = log3(4), f (n) = n3, g(n) = np.

p = log3(4) < log3(27) = 3

(itt használtunk egy kis becslést, de elég lett volna log3(4)-etbeütni a számológépbe ahhoz, hogy megkapjuk, hogylog3(4) < 3).

f (n) = n3 polinomiálisan gyorsabban nő, mint a g(n)tesztpolinom. Az M3-hoz még ellenőrizni kell még arelgulatitási feltételt:

af(nb

)= 4 ·

(n3

)3=

427· n3 =

427· f (n), c =

427

< 1.

Így kapjuk, hogy T (n) = Θ(f (n)) = Θ(n3).

Page 73: Adatstruktúrák és Algoritmusok

4. T (n) = 4T (n3 ) + n3.a = 4, b = 3, p = logb(a) = log3(4), f (n) = n3, g(n) = np.

p = log3(4) < log3(27) = 3

(itt használtunk egy kis becslést, de elég lett volna log3(4)-etbeütni a számológépbe ahhoz, hogy megkapjuk, hogylog3(4) < 3).f (n) = n3 polinomiálisan gyorsabban nő, mint a g(n)tesztpolinom. Az M3-hoz még ellenőrizni kell még arelgulatitási feltételt:

af(nb

)= 4 ·

(n3

)3=

427· n3 =

427· f (n), c =

427

< 1.

Így kapjuk, hogy T (n) = Θ(f (n)) = Θ(n3).

Page 74: Adatstruktúrák és Algoritmusok

4. T (n) = 4T (n3 ) + n3.a = 4, b = 3, p = logb(a) = log3(4), f (n) = n3, g(n) = np.

p = log3(4) < log3(27) = 3

(itt használtunk egy kis becslést, de elég lett volna log3(4)-etbeütni a számológépbe ahhoz, hogy megkapjuk, hogylog3(4) < 3).f (n) = n3 polinomiálisan gyorsabban nő, mint a g(n)tesztpolinom. Az M3-hoz még ellenőrizni kell még arelgulatitási feltételt:

af(nb

)= 4 ·

(n3

)3=

427· n3 =

427· f (n), c =

427

< 1.

Így kapjuk, hogy T (n) = Θ(f (n)) = Θ(n3).

Page 75: Adatstruktúrák és Algoritmusok

5. T (n) = 3T (n4 ) + n log(n).

a = 3, b = 4, p = logb(a) = log4(3), f (n) = n log(n),g(n) = np

p = log4(3) < log4(4) = 1

Ekkor f (n) = n log(n) polinomiálisan gyorsabban nő, mint ag(n) = nlog4(3).Az M3-hoz ellenőrizni kell még a regularitási feltételt.

af(nb

)= 3

n

4log(n4

)<

34n log(n) =

34f (n), c =

34< 1

Így T (n) = Θ(f (n)) = Θ(n log(n)).

Page 76: Adatstruktúrák és Algoritmusok

5. T (n) = 3T (n4 ) + n log(n).a = 3, b = 4, p = logb(a) = log4(3), f (n) = n log(n),g(n) = np

p = log4(3) < log4(4) = 1

Ekkor f (n) = n log(n) polinomiálisan gyorsabban nő, mint ag(n) = nlog4(3).Az M3-hoz ellenőrizni kell még a regularitási feltételt.

af(nb

)= 3

n

4log(n4

)<

34n log(n) =

34f (n), c =

34< 1

Így T (n) = Θ(f (n)) = Θ(n log(n)).

Page 77: Adatstruktúrák és Algoritmusok

5. T (n) = 3T (n4 ) + n log(n).a = 3, b = 4, p = logb(a) = log4(3), f (n) = n log(n),g(n) = np

p = log4(3) < log4(4) = 1

Ekkor f (n) = n log(n) polinomiálisan gyorsabban nő, mint ag(n) = nlog4(3).Az M3-hoz ellenőrizni kell még a regularitási feltételt.

af(nb

)= 3

n

4log(n4

)<

34n log(n) =

34f (n), c =

34< 1

Így T (n) = Θ(f (n)) = Θ(n log(n)).

Page 78: Adatstruktúrák és Algoritmusok

5. T (n) = 3T (n4 ) + n log(n).a = 3, b = 4, p = logb(a) = log4(3), f (n) = n log(n),g(n) = np

p = log4(3) < log4(4) = 1

Ekkor f (n) = n log(n) polinomiálisan gyorsabban nő, mint ag(n) = nlog4(3).

Az M3-hoz ellenőrizni kell még a regularitási feltételt.

af(nb

)= 3

n

4log(n4

)<

34n log(n) =

34f (n), c =

34< 1

Így T (n) = Θ(f (n)) = Θ(n log(n)).

Page 79: Adatstruktúrák és Algoritmusok

5. T (n) = 3T (n4 ) + n log(n).a = 3, b = 4, p = logb(a) = log4(3), f (n) = n log(n),g(n) = np

p = log4(3) < log4(4) = 1

Ekkor f (n) = n log(n) polinomiálisan gyorsabban nő, mint ag(n) = nlog4(3).Az M3-hoz ellenőrizni kell még a regularitási feltételt.

af(nb

)= 3

n

4log(n4

)<

34n log(n) =

34f (n), c =

34< 1

Így T (n) = Θ(f (n)) = Θ(n log(n)).

Page 80: Adatstruktúrák és Algoritmusok

5. T (n) = 3T (n4 ) + n log(n).a = 3, b = 4, p = logb(a) = log4(3), f (n) = n log(n),g(n) = np

p = log4(3) < log4(4) = 1

Ekkor f (n) = n log(n) polinomiálisan gyorsabban nő, mint ag(n) = nlog4(3).Az M3-hoz ellenőrizni kell még a regularitási feltételt.

af(nb

)= 3

n

4log(n4

)<

34n log(n) =

34f (n), c =

34< 1

Így T (n) = Θ(f (n)) = Θ(n log(n)).

Page 81: Adatstruktúrák és Algoritmusok

5. T (n) = 3T (n4 ) + n log(n).a = 3, b = 4, p = logb(a) = log4(3), f (n) = n log(n),g(n) = np

p = log4(3) < log4(4) = 1

Ekkor f (n) = n log(n) polinomiálisan gyorsabban nő, mint ag(n) = nlog4(3).Az M3-hoz ellenőrizni kell még a regularitási feltételt.

af(nb

)= 3

n

4log(n4

)<

34n log(n) =

34f (n), c =

34< 1

Így T (n) = Θ(f (n)) = Θ(n log(n)).

Page 82: Adatstruktúrák és Algoritmusok

A

6. T (n) = 2T (n2 ) + n log(n)

a = 2, b = 2, p = logb(a) = log2(2) = 1, f (n) = n log(n),g(n) = np = n1. Ekkor f (n) gyorsabban nő, mint a g(n), denem polinomálisan, így a Mester tétel nem alkalmazható.

Page 83: Adatstruktúrák és Algoritmusok

A

6. T (n) = 2T (n2 ) + n log(n)a = 2, b = 2, p = logb(a) = log2(2) = 1, f (n) = n log(n),g(n) = np = n1. Ekkor f (n) gyorsabban nő, mint a g(n), denem polinomálisan, így a Mester tétel nem alkalmazható.

Page 84: Adatstruktúrák és Algoritmusok

A

T (n) = 2T (n2 ) + n log(n)

Page 85: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (1) = a > 0T (2) = 2T (1) + 2 log(2) = 2a + 2T (4) = 2T (2) + 4 log(4) = 2(2a + 2) + 8 = 4a + 12T (8) = 2T (4) + 8 log(8) = 2(4a + 12) + 24 = 8a + 48.

A T (2n) függvénytT (2n) = 2na + an

alakban keressük.Talán nem könnyű kitalálni, hogy an = 2n

n(n + 1)

2, így kapjuk,

hogy

T (2n) = 2na + 2nn(n + 1)

2.

Page 86: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (1) = a > 0T (2) = 2T (1) + 2 log(2) = 2a + 2T (4) = 2T (2) + 4 log(4) = 2(2a + 2) + 8 = 4a + 12T (8) = 2T (4) + 8 log(8) = 2(4a + 12) + 24 = 8a + 48.

A T (2n) függvénytT (2n) = 2na + an

alakban keressük.Talán nem könnyű kitalálni, hogy an = 2n

n(n + 1)

2, így kapjuk,

hogy

T (2n) = 2na + 2nn(n + 1)

2.

Page 87: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (1) = a > 0T (2) = 2T (1) + 2 log(2) = 2a + 2T (4) = 2T (2) + 4 log(4) = 2(2a + 2) + 8 = 4a + 12T (8) = 2T (4) + 8 log(8) = 2(4a + 12) + 24 = 8a + 48.

A T (2n) függvénytT (2n) = 2na + an

alakban keressük.

Talán nem könnyű kitalálni, hogy an = 2nn(n + 1)

2, így kapjuk,

hogy

T (2n) = 2na + 2nn(n + 1)

2.

Page 88: Adatstruktúrák és Algoritmusok

A rekurzió feloldása

T (1) = a > 0T (2) = 2T (1) + 2 log(2) = 2a + 2T (4) = 2T (2) + 4 log(4) = 2(2a + 2) + 8 = 4a + 12T (8) = 2T (4) + 8 log(8) = 2(4a + 12) + 24 = 8a + 48.

A T (2n) függvénytT (2n) = 2na + an

alakban keressük.Talán nem könnyű kitalálni, hogy an = 2n

n(n + 1)

2, így kapjuk,

hogy

T (2n) = 2na + 2nn(n + 1)

2.

Page 89: Adatstruktúrák és Algoritmusok

T (2n) = 2na + 2nn(n + 1)

2.

Végezzük el az n← log(n) helyettesítést. Így kapjuk, hogy

T (n) = na +12n log(n)(log(n) + 1) =

= na +12n log(n) +

12n log(n) log(n) = Θ(n log(n) log(n)).

Page 90: Adatstruktúrák és Algoritmusok

T (2n) = 2na + 2nn(n + 1)

2.

Végezzük el az n← log(n) helyettesítést. Így kapjuk, hogy

T (n) = na +12n log(n)(log(n) + 1) =

= na +12n log(n) +

12n log(n) log(n) = Θ(n log(n) log(n)).

Page 91: Adatstruktúrák és Algoritmusok

T (2n) = 2na + 2nn(n + 1)

2.

Végezzük el az n← log(n) helyettesítést. Így kapjuk, hogy

T (n) = na +12n log(n)(log(n) + 1) =

= na +12n log(n) +

12n log(n) log(n) = Θ(n log(n) log(n)).

Page 92: Adatstruktúrák és Algoritmusok

T (2n) = 2na + 2nn(n + 1)

2.

Végezzük el az n← log(n) helyettesítést. Így kapjuk, hogy

T (n) = na +12n log(n)(log(n) + 1) =

= na +12n log(n) +

12n log(n) log(n) = Θ(n log(n) log(n)).

Page 93: Adatstruktúrák és Algoritmusok

Számelméleti algoritmusok I

Page 94: Adatstruktúrák és Algoritmusok

Számelméleti definíciókat (fogalmak) és tételeket (állítások) a Zhalmazon fogalmazzuk meg, az algoritmusok Z+ ∪ 0 halmazonfuttatjuk.

Page 95: Adatstruktúrák és Algoritmusok

Oszthatósági reláció Z-n

Definíció Legyenek a, b ∈ Z. "a" osztója "b"-nek, ha létezikc ∈ Z úgy, hogy b = ac . Jele: a|b.

Page 96: Adatstruktúrák és Algoritmusok

Oszthatósági reláció Z-n

Definíció Legyenek a, b ∈ Z. "a" osztója "b"-nek, ha létezikc ∈ Z úgy, hogy b = ac . Jele: a|b.

Page 97: Adatstruktúrák és Algoritmusok

Prímszám

Definíció Egy p ∈ Z+, p > 1 számot prímszámnak nevezünk, ha1-en és önmagán kívül nincs más pozitív osztója.

Page 98: Adatstruktúrák és Algoritmusok

Megjegyzés

A prímszám szokásos definíciója: egy p 0-tól és ±1-től különbözőegész számot prímszámnak nevezünk, ha valhányszor osztója egyszorzatnak, mindannyiszor osztója a szorzat valamelyiktényezőjének, azaz

p|ab ⇐⇒ p|a vagy p|b.

Mi ezt a tulajdonságot a későbbiekben prímtulajdonságnak fogjuknevezni.Egy p 0-tól és ±1-től különböző egész számot felbonthatatlannak,vagy irreducibilisnek nevezünk, ha nincs valódi faktorizációja, azazp = ab-ből következik, hogy a = ±1, vagy a = ±p.Bizonyítható, hogy az egész számok gyűrűjében a prímszámok és azirreducibilis számok egybeesnek.

Page 99: Adatstruktúrák és Algoritmusok

Megjegyzés

A prímszám szokásos definíciója: egy p 0-tól és ±1-től különbözőegész számot prímszámnak nevezünk, ha valhányszor osztója egyszorzatnak, mindannyiszor osztója a szorzat valamelyiktényezőjének, azaz

p|ab ⇐⇒ p|a vagy p|b.

Mi ezt a tulajdonságot a későbbiekben prímtulajdonságnak fogjuknevezni.

Egy p 0-tól és ±1-től különböző egész számot felbonthatatlannak,vagy irreducibilisnek nevezünk, ha nincs valódi faktorizációja, azazp = ab-ből következik, hogy a = ±1, vagy a = ±p.Bizonyítható, hogy az egész számok gyűrűjében a prímszámok és azirreducibilis számok egybeesnek.

Page 100: Adatstruktúrák és Algoritmusok

Megjegyzés

A prímszám szokásos definíciója: egy p 0-tól és ±1-től különbözőegész számot prímszámnak nevezünk, ha valhányszor osztója egyszorzatnak, mindannyiszor osztója a szorzat valamelyiktényezőjének, azaz

p|ab ⇐⇒ p|a vagy p|b.

Mi ezt a tulajdonságot a későbbiekben prímtulajdonságnak fogjuknevezni.Egy p 0-tól és ±1-től különböző egész számot felbonthatatlannak,vagy irreducibilisnek nevezünk, ha nincs valódi faktorizációja, azazp = ab-ből következik, hogy a = ±1, vagy a = ±p.

Bizonyítható, hogy az egész számok gyűrűjében a prímszámok és azirreducibilis számok egybeesnek.

Page 101: Adatstruktúrák és Algoritmusok

Megjegyzés

A prímszám szokásos definíciója: egy p 0-tól és ±1-től különbözőegész számot prímszámnak nevezünk, ha valhányszor osztója egyszorzatnak, mindannyiszor osztója a szorzat valamelyiktényezőjének, azaz

p|ab ⇐⇒ p|a vagy p|b.

Mi ezt a tulajdonságot a későbbiekben prímtulajdonságnak fogjuknevezni.Egy p 0-tól és ±1-től különböző egész számot felbonthatatlannak,vagy irreducibilisnek nevezünk, ha nincs valódi faktorizációja, azazp = ab-ből következik, hogy a = ±1, vagy a = ±p.Bizonyítható, hogy az egész számok gyűrűjében a prímszámok és azirreducibilis számok egybeesnek.

Page 102: Adatstruktúrák és Algoritmusok

Legnagyobb közös osztó

Definíció Az a, b ∈ Z számok legnagyobb közös osztója:

lnko(a, b) =

0, ha a = 0 és b = 0

maxd ∈ Z+ | d |a és d |b egyébként

Page 103: Adatstruktúrák és Algoritmusok

Legnagyobb közös osztó

Definíció Az a, b ∈ Z számok legnagyobb közös osztója:

lnko(a, b) =

0, ha a = 0 és b = 0

maxd ∈ Z+ | d |a és d |b egyébként

Page 104: Adatstruktúrák és Algoritmusok

Megjegyzés

Ha az a és b számok közül nem mindkettő 0, akkor egy δ számotaz a és b számok kitüntetett közös osztójának nevezünk, ha a δszám

1 az a és b számok közös osztója;2 az a és b számok bármely közös osztójának a többszöröse.

Elemi számelméletben meg szokták mutatni, hogy ha az a és bszámok közül nem mindkettő 0, akkor az a és b számok legnagyobbközös osztója egyúttal a kitüntetett közös osztójuk is.

Page 105: Adatstruktúrák és Algoritmusok

Megjegyzés

Ha az a és b számok közül nem mindkettő 0, akkor egy δ számotaz a és b számok kitüntetett közös osztójának nevezünk, ha a δszám

1 az a és b számok közös osztója;2 az a és b számok bármely közös osztójának a többszöröse.

Elemi számelméletben meg szokták mutatni, hogy ha az a és bszámok közül nem mindkettő 0, akkor az a és b számok legnagyobbközös osztója egyúttal a kitüntetett közös osztójuk is.

Page 106: Adatstruktúrák és Algoritmusok

Megjegyzés

Ha az a és b számok közül nem mindkettő 0, akkor egy δ számotaz a és b számok kitüntetett közös osztójának nevezünk, ha a δszám

1 az a és b számok közös osztója;2 az a és b számok bármely közös osztójának a többszöröse.

Elemi számelméletben meg szokták mutatni, hogy ha az a és bszámok közül nem mindkettő 0, akkor az a és b számok legnagyobbközös osztója egyúttal a kitüntetett közös osztójuk is.

Page 107: Adatstruktúrák és Algoritmusok

Jelölés

Tetszőleges a, b ∈ Z számok esetén legyen

L(a, b) := ua + vb | u ∈∈ Z, v ∈ Z .

Az L(a, b) halmazt az a és b elemekből képzett lineáriskombinácók halmazának nevezzük.

Most megismerkedünk a reprezentációs, a redukciós és a rekurzióstétellel.

Page 108: Adatstruktúrák és Algoritmusok

Jelölés

Tetszőleges a, b ∈ Z számok esetén legyen

L(a, b) := ua + vb | u ∈∈ Z, v ∈ Z .

Az L(a, b) halmazt az a és b elemekből képzett lineáriskombinácók halmazának nevezzük.

Most megismerkedünk a reprezentációs, a redukciós és a rekurzióstétellel.

Page 109: Adatstruktúrák és Algoritmusok

Jelölés

Tetszőleges a, b ∈ Z számok esetén legyen

L(a, b) := ua + vb | u ∈∈ Z, v ∈ Z .

Az L(a, b) halmazt az a és b elemekből képzett lineáriskombinácók halmazának nevezzük.

Most megismerkedünk a reprezentációs, a redukciós és a rekurzióstétellel.

Page 110: Adatstruktúrák és Algoritmusok

1. Reprezentációs tétel

Ha a és b egyidejűleg nem 0, akkor

lnko(a, b) = minx ∈ L(a, b) | x > 0.

Page 111: Adatstruktúrák és Algoritmusok

1. Reprezentációs tétel

Ha a és b egyidejűleg nem 0, akkor

lnko(a, b) = minx ∈ L(a, b) | x > 0.

Page 112: Adatstruktúrák és Algoritmusok

Következmény

A legnagyobb közös osztó bármely közös osztó többszöröse.

Page 113: Adatstruktúrák és Algoritmusok

Következmény

A legnagyobb közös osztó bármely közös osztó többszöröse.

Page 114: Adatstruktúrák és Algoritmusok

2. Redukciós tétel

Legyenek a, b ∈ Z. Ekkor

lnko(a, b) = lnko(a− b, b)

Page 115: Adatstruktúrák és Algoritmusok

2. Redukciós tétel

Legyenek a, b ∈ Z. Ekkor

lnko(a, b) = lnko(a− b, b)

Page 116: Adatstruktúrák és Algoritmusok

3. Rekurziós tétel

Legyenek a, b ∈ Z. Ekkor

lnko(a, b) = lnko(b, a mod b)

Page 117: Adatstruktúrák és Algoritmusok

3. Rekurziós tétel

Legyenek a, b ∈ Z. Ekkor

lnko(a, b) = lnko(b, a mod b)

Page 118: Adatstruktúrák és Algoritmusok

Redukciós algoritmus

REDUK(a,b ‖ d∗)INPUT a, b ∈ Z+ ∪ 0OUTPUT d∗

1. WHILE (b 6= 0)

2. IF b > a THEN CSERE(a, b)

3. a←− a− b

4. d∗ ←− a

5. RETURN(d∗)

Page 119: Adatstruktúrák és Algoritmusok

Redukciós algoritmus

REDUK(a,b ‖ d∗)INPUT a, b ∈ Z+ ∪ 0OUTPUT d∗

1. WHILE (b 6= 0)

2. IF b > a THEN CSERE(a, b)

3. a←− a− b

4. d∗ ←− a

5. RETURN(d∗)

Page 120: Adatstruktúrák és Algoritmusok

Euklideszi algoritmus

EUK(a,b ‖ d∗)INPUT a, b ∈ Z+ ∪ 0OUTPUT d∗

1. WHILE (b 6= 0)

2.(ab

)←−

( ba mod b

)3. d∗ ←− a

4. RETURN(d∗)

Page 121: Adatstruktúrák és Algoritmusok

Euklideszi algoritmus

EUK(a,b ‖ d∗)INPUT a, b ∈ Z+ ∪ 0OUTPUT d∗

1. WHILE (b 6= 0)

2.(ab

)←−

( ba mod b

)3. d∗ ←− a

4. RETURN(d∗)

Page 122: Adatstruktúrák és Algoritmusok

Példa

Határozzuk meg a redukciós algoritmus és a rekurziós algoritmussegítségével a 90 és a 24 legnagyobb közös osztóját. A buletmódon megjelölt lépések azok, amelyeken keresztül a rekurziósalgoritmus eljut a legnagyobb közös osztóhoz.

•lnko (90, 24) = lnko(66, 24) = lnko(42, 24) = lnko(18, 24) =

=•

lnko (24, 18) = lnko(6, 18) =•

lnko (18, 6) =

= lnko(12, 6) = lnko(6, 6) = lnko(0, 6) =

=•

lnko (6, 0) = 6

Page 123: Adatstruktúrák és Algoritmusok

Példa

Határozzuk meg a redukciós algoritmus és a rekurziós algoritmussegítségével a 90 és a 24 legnagyobb közös osztóját. A buletmódon megjelölt lépések azok, amelyeken keresztül a rekurziósalgoritmus eljut a legnagyobb közös osztóhoz.

•lnko (90, 24) = lnko(66, 24) = lnko(42, 24) = lnko(18, 24) =

=•

lnko (24, 18) = lnko(6, 18) =•

lnko (18, 6) =

= lnko(12, 6) = lnko(6, 6) = lnko(0, 6) =

=•

lnko (6, 0) = 6

Page 124: Adatstruktúrák és Algoritmusok

Példa

Határozzuk meg a redukciós algoritmus és a rekurziós algoritmussegítségével a 90 és a 24 legnagyobb közös osztóját. A buletmódon megjelölt lépések azok, amelyeken keresztül a rekurziósalgoritmus eljut a legnagyobb közös osztóhoz.

•lnko (90, 24) = lnko(66, 24) = lnko(42, 24) = lnko(18, 24) =

=•

lnko (24, 18) = lnko(6, 18) =•

lnko (18, 6) =

= lnko(12, 6) = lnko(6, 6) = lnko(0, 6) =

=•

lnko (6, 0) = 6

Page 125: Adatstruktúrák és Algoritmusok

A rekurziós algoritmus, mint Euklideszi osztásoksorozata

A rekurziós algoritmust lehet úgy értelmezni, mint Euklidesziosztások sorozatát, melyben

Minden egyes lépésben az osztóból lesz az osztandó és amaradékból lesz az osztó;Ezt az eljárást addig iteráljuk, amíg a maradék nem váliknullává;A legnagyobb közös osztó a maradékok sorozatában az utolsózérustól különböző maradék.

Page 126: Adatstruktúrák és Algoritmusok

A rekurziós algoritmus, mint Euklideszi osztásoksorozata

A rekurziós algoritmust lehet úgy értelmezni, mint Euklidesziosztások sorozatát, melyben

Minden egyes lépésben az osztóból lesz az osztandó és amaradékból lesz az osztó;Ezt az eljárást addig iteráljuk, amíg a maradék nem váliknullává;A legnagyobb közös osztó a maradékok sorozatában az utolsózérustól különböző maradék.

Page 127: Adatstruktúrák és Algoritmusok

A rekurziós algoritmus, mint Euklideszi osztásoksorozata

A rekurziós algoritmust lehet úgy értelmezni, mint Euklidesziosztások sorozatát, melyben

Minden egyes lépésben az osztóból lesz az osztandó és amaradékból lesz az osztó;

Ezt az eljárást addig iteráljuk, amíg a maradék nem váliknullává;A legnagyobb közös osztó a maradékok sorozatában az utolsózérustól különböző maradék.

Page 128: Adatstruktúrák és Algoritmusok

A rekurziós algoritmus, mint Euklideszi osztásoksorozata

A rekurziós algoritmust lehet úgy értelmezni, mint Euklidesziosztások sorozatát, melyben

Minden egyes lépésben az osztóból lesz az osztandó és amaradékból lesz az osztó;Ezt az eljárást addig iteráljuk, amíg a maradék nem váliknullává;

A legnagyobb közös osztó a maradékok sorozatában az utolsózérustól különböző maradék.

Page 129: Adatstruktúrák és Algoritmusok

A rekurziós algoritmus, mint Euklideszi osztásoksorozata

A rekurziós algoritmust lehet úgy értelmezni, mint Euklidesziosztások sorozatát, melyben

Minden egyes lépésben az osztóból lesz az osztandó és amaradékból lesz az osztó;Ezt az eljárást addig iteráljuk, amíg a maradék nem váliknullává;A legnagyobb közös osztó a maradékok sorozatában az utolsózérustól különböző maradék.

Page 130: Adatstruktúrák és Algoritmusok

a0 = q0b0 + r0

b0 = q1r0 + r1

r0 = q2r1 + r2...

rn−2 = qnrn−1 + rn

rn−1 = qn+1rn + 0

Page 131: Adatstruktúrák és Algoritmusok

Lamé tétele

Ha az euklideszi algoritmusban a > b > 0 és Fk+1 > b, akkor arekurzív hívások száma kevesebb, mint k .

Page 132: Adatstruktúrák és Algoritmusok

Lamé tétele

Ha az euklideszi algoritmusban a > b > 0 és Fk+1 > b, akkor arekurzív hívások száma kevesebb, mint k .

Page 133: Adatstruktúrák és Algoritmusok

KOSZONOM A FIGYELMET !