1

2014. Április 8.

Algoritmusok komplexitása

Függvények növekedése

Nagyságrend

3

Nagy Ordó jelölés

Aszimptotikus komplexitási mérték, a számítógépes

programok „jóságát”(gyorsaságát, takarékosságát)

jellemzi

Nem próbáljuk meg PONTOSAN megszámolni, hány

lépés egy algoritmus, hanem inkább azt, hogy ez a

lépésszám milyen mértékben nő a bemeneti adatok

számának növekedéséhez viszonyítva

Olyan jellemző, amely a különböző operációs

rendszerek, fordítók, CPU-k esetén is alkalmazható

Ez az aszimptotikus komplexitás az ún. nagy ordó

jelöléssel fejezhető ki. (Big-O)

4

Függvények növekedése: Nagy Ordó

Definíció: f és g két függvény: NR+. Azt

mondjuk, hogy f(n) = O(g(n))(„nagy ordó g(n)”)

akkor és csak akkor, ha létezik két olyan pozitív

konstans c és n0 úgy, hogy

f(n) c·g(n) minden nn0-ra.

Azt mondjuk ekkor, hogy g(n) (aszimptotikus) felső

korlátja f(n)-nek

5

Aszimptotikus felső korlát

f(n)

g(n)

c g(n) • f(n) c g(n) minden n n0

• g(n) az aszimptotikus felső

korlátja f(n)-nek

•Jelölése: f(n)=O(g(n))

•Olvasása: f(n) nagy ordó g(n)

•Angolul: f(n) is big oh of

g(n).

n0

6

Példa az aszimptotikus felső korlátra

f(n)=3n2+5

g(n)=n2

4g(n)=4n2 4 g(n) = 4n2

= 3n2 + n2

3n2 + 9 minden n 3

> 3n2 + 5 = f(n)

Tehát: f(n)=O(g(n)): 3n2+5=O(n2)

3

7

Nagy Ordo példák

f(n) = 15n2 + 7n g(n) = ½·n3

f(n)=O(g(n)) mert n0=16 és c=2 választással,

minden n n0-ra

f(n) = 15n2 + 7n 16n2 n3 = c·g(n).

5n4 + 27n = O(n4).

n0=1, c=32. (De pl. n0=3 és c=6 is jó)

8

Nagy Ordo példák (folytatás)

Mutassuk meg, hogy 3n2+2n+5 = O(n2)

9

Nagy Ordo példák (folytatás)

Mutassuk meg, hogy 3n2+2n+5 = O(n2)

10 n2 = 3n2 + 2n2 + 5n2

3n2 + 2n + 5 ha n 1

c = 10, n0 = 1

10

Nagy Ordo példák (folytatás)

A lehető legegyszerűbb és legkisebb függvényt használjuk az O mögött:

3n2+2n+5 = O(n2)

Ezek itt pl. helyesek, de nem hasznosak:

3n2+2n+5 = O(3n2+2n+5)

3n2+2n+5 = O(n2+n)

3n2+2n+5 = O(3n2)

11

Nagy Ordo példák (folytatás)

f1(n) = 10 n + 25 n2

f2(n) = 20 n log n + 5 n

f3(n) = 12 n log n + 0.05 n2

f4(n) = n1/2 + 3 n log n

• O(n2)

• O(n log n)

• O(n2)

• O(n log n)

12

Nagy Ordo példák (folytatás)

f(n) = a·nk + …, f(n)=O(2n).

f(n) = a·nk + …, f(n) = O(nk) minden r k-ra

n = O(n·log(n))

n·log(n) = O(nd) , d=? d>1

13

Nagy Ordo „rendezés”

• f(n) = O(f(n)) minden f-re

• (log(n))k = O(n) minden konstans k-ra

• nk = O(2n) minden konstans k-ra

14

Nagy Ordo „rendezés”

- A polinomok dominálnak („nagyobbak”), mint a logaritmus függvények, illetve ezek hatványai

- Az exponenciális függvények dominálnak a

polinomok fölött

- (a·log(n) = O(log(n)) minden a-ra, ezért a log alapját

nem kell kiírni)

15

Nagy Ordo „rendezés”

16

Függvények növekedése

f(n) = O(g(n) jelentése: c g(n) egy felső korlátja f(n)-nek, olvasd: „nagy

ordó g(n)”

f(n) = (g(n)) jelentése: c g(n) egy alsó korlátja f(n)-nek olvasd: „nagy

omega g(n)”

f(n) = (g(n)) jelentése: f(n) és g(n) egyformán növekszik,

konstans szorzó erejéig, olvasd: „ teta g(n)”

Informálisan: A nagy ordo kb azt jelenti, hogy az f függvény kisebb

egyenlő, mint g, a kis ordo pedig, hogy az f határozottan kisebb

f(n) = (g(n) másképpen azt jelenti, hogy

f(n) = O(g(n) ÉS g(n) = O(f(n))

f(n) = o(g(n)) jelentése:

olvasd: „kis ordó g(n)” 0

)(

)(lim

ng

nf

n

17

Aszimptotikus alsó korlát

f(n)

c g(n)

•létezik olyan c és n0 , hogy

minden n n0 -ra f(n) c

g(n)

• g(n) az f(n) aszimptotikus

alsó korlátja

• Jelölés: f(n)=(g(n))

n0

18

Példa az aszimptotikus alsó korlátra

f(n)=n2/2-7

c g(n)=n2/4

g(n)=n2

g(n)/4 = n2/4

= n2/2 – n2/4

n2/2 – 9 minden n 6

< n2/2 – 7

Tehát: f(n)= (g(n)).

6

19

Aszimptotikus szoros korlát

f(n)

c1 g(n)

• f(n) = O(g(n)) és f(n) = (g(n))

n0

c2 g(n)

20

Függvények növekedése

f(n) = (g(n) másképpen azt is jelenti, hogy

f(n) = O(g(n) ÉS g(n) = O(f(n))

Ekkor azt mondjuk, hogy a két függvény

NAGYSÁGRENDJE megegyezik

Tulajdonképpen a lényeg ezen nagyságrendi

egyezés megállapítása

Nagy Ordó – Big Oh!

21

Aszimptotikus alsó () és felső(O) korlátok

egymáshoz való viszonya

22

( f ) O( f ) ( f )

• f

Aszimptotikus korlátok

23

Néhány függvény időkomplexitása

Komplexitás 10 20 30 40 50 60

n 110-5 sec 210-5 sec 310-5 sec 410-5 sec 510-5 sec 610-5 sec

n2 0.0001 sec 0.0004 sec 0.0009 sec 0.016 sec 0.025 sec 0.036 sec

n3 0.001 sec 0.008 sec 0.027 sec 0.064 sec 0.125 sec 0.216 sec

n5 0.1 sec 3.2 sec 24.3 sec 1.7 perc 5.2 perc 13.0 perc

2n 0.001sec 1.0 sec 17.9 perc 12.7 nap 35.7 év 366 évsz

3n 0.59sec 58 perc 6.5 év 3855 évsz 2108évsz 1.31013

évsz

log2 n 310-6 sec 410-6 sec 510-6 sec 510-6 sec 610-6 sec 610-6 sec

n log2 n 310-5 sec 910-5 sec 0.0001 sec 0.0002 sec 0.0003 sec 0.0004 sec

24

NAGY ORDO/Big-O

Time Complexity and Speed

25

Complexity 10 20 50 100 1 000 10 000 100 000

O(1) < 1 s < 1 s < 1 s < 1 s < 1 s < 1 s < 1 s

O(log(n)) < 1 s < 1 s < 1 s < 1 s < 1 s < 1 s < 1 s

O(n) < 1 s < 1 s < 1 s < 1 s < 1 s < 1 s < 1 s

O(n*log(n)) < 1 s < 1 s < 1 s < 1 s < 1 s < 1 s < 1 s

O(n2) < 1 s < 1 s < 1 s < 1 s < 1 s 2 s 3-4 min

O(n3) < 1 s < 1 s < 1 s < 1 s 20 s 5 hours 231 days

O(2n) < 1 s < 1 s 260

days hangs hangs hangs hangs

O(n!) < 1 s hangs hangs hangs hangs hangs hangs

O(nn) 3-4 min hangs hangs hangs hangs hangs hangs

Algoritmusok komplexitása

27

Algoritmusok komplexitása

• Mit lehet és mit nem lehet megoldani a számítógépek

használatával?

• Ha egy probléma megoldható, milyen könnyű illetve milyen

nehéz azt megoldani?

• Mennyi ideig tart megoldani? - időkomplexitás

• Mekkora tár kell hozzá? - tárkomplexitás

• A komplexitás elmélet ezekre e kérdésekre próbál válaszolni

Algoritmus fogalma

Az algoritmus pontos utasítások halmaza, amelyeket elvégezve (akár személyesen, akár számítógéppel) valamely probléma megoldását kapjuk. MEGÁLL!!

Az algoritmusokat aszerint hasonlítjuk össze, hogy mennyi ideig futnak,mekkora a tárigényük.

Run-time amalízis: a futási idő miként változik a bemeneti adatok számának növelésével?

28

29

Két kritériumot használunk az algoritmusok összehasonlítására:

a.) tár komplexitás b.) idő komplexitása i

s

a.) valamely algoritmus tár komplexitása az a memória mennyiség, ami a program futásához szükséges.

b.) valamely algoritmus idő komplexitása az az idő (mennyiség), amely a program futásához szükséges

Komplexitás

Komplexitás

Idő komplexitás:

nagyságrendi becslés a megoldáshoz szükséges

műveletek számára vonatkozóan, a bemenő adatok

függvényében. Egy műveletet egy időegység alatt

végrehajthatónak képzelünk el, ezért nevezzük

időkomplexitásnak, hiszen így a futási időre kapunk

információt. Ez az időegység ugyan függ a konkrét géptől,

de emberi érzékeléssel nemigen tudunk különbséget tenni

–ezért a függvény NÖVEKEDÉSE az input

adatmennyiség függvényében a lényeges!

30

Tár komplexitás-ld. Adatszerkezetek:

a probléma megoldásához szükséges memória

nagyságrendi becslése.

Egy példa

31

Egy adott program/algoritmus T(n) futási idejének

becslésekor a bemenő adatok n számának függvényében

kiszámítjuk, hogy az utasítások hányszor hajtódnak végre:

ÁTLAG:

1. olvassuk be az n számot

//felhasználó begépeli)

2. sum= 0 // inicializálás

3. i=0

4.while 1<n

5. olvassuk be a számot=

//felhasználó begépeli

6. sum=sum+number

7.i=i+1

8.átlag=sum/n

KIÉRTÉKELÉSEK SZÁMA:

1 (időegység)

1

1

n

n

n

n

1

T(n)=4n+4

32

Futási idő

A legtöbb algoritmus bemeneti

objektumokat alakít kimeneti

objektumokká.

A futási idő tipikusan növekszik

az input méretének

növekedésével.

Az átlagos esetet nehéz elemezni.

A legrosszabb ( worst case)

helyzetet vesszük jellemzőnek.

Ezt könnyebb elemezni, és

fontosabb is. (robotika,

közgazdaságtan)

0

20

40

60

80

100

120

Ru

nn

ing

Tim

e1000 2000 3000 4000

Input Size

best case

average case

worst case

Worst, best, average

Worst-case (legrosszabb eset ): A műveletek maximális száma, garantáltan ennyi lépés után eredményt ad,bármilyen input esetén

Best-case (legjobb eset): A műveletek minimális szám – nem praktikus

Average-case (átlagos eset):

Nehéz jól megbecsülni, bármilyen inputra elképzeljük (vagy valószínűségi eloszlást rakhatunk az inputra) ennek függvényében a várható átlagos lépésszám

33

Egyszerű példa legrosszabb, átlagos, legjobb esetekre

Lineáris (szekvenciális keresés):

A lista /tömb elejétől kezdve megnézzük az elemeket és

megállunk, ha megtaláltuk.

Worst case: utolsónak találjuk meg, ez n elem esetén n

lépés

Best case: elsőre megtaláljuk, ez 1 lépés

Average case:

34

Lineáris keresés C++ program - O (n)

bool LinSearch(double x[ ], int n, double item){

for(int i=0;i<n;i++){

if(x[i]==item) return true;

else return false;

}

return false;

}

O (n): hiszen a ciklus – ebben a megvalósításban n-

szer fut, ez az algoritmus lineáris (cn-nel egyenlő

nagyságrendű)

35

36

A lineáris keresés

Előny:

- Könnyű megérteni

- A tömb elemeit nem kell rendezni

Hátrány:

-Lassú, átlagosan n/2 lépés

37

Adott egy szám, value, és egy rendezett tömb a[], meg kell

találni azt az i indexet, amely tömbelem azt az értéket

tartalmazza, mint a value : a[i] = value, vagy, ha nincs

ilyen, akkor kiírni, hogy nincs.

Az algoritmus működése: a felénél megnézzük a tartalmat, ha

kisebb a keresett számnál, akkor a középső index lesz az

intervallum bal oldala, az eredeti a jobboldala:

a[bal] value a[jobb]

Bináris keresés O(log2n)

8 2 1 3 4 6 5 7 10 9 11 12 14 13 0

64 14 13 25 33 51 43 53 84 72 93 95 97 96 6

Bináris keresés

lo

Példa: 14 elemű tömbben a 33-at keressük meg

jobb

8 2 1 3 4 6 5 7 10 9 11 12 14 13 0

64 14 13 25 33 51 43 53 84 72 93 95 97 96 6

jobb felező

Bináris keresés

8 2 1 3 4 6 5 7 10 9 11 12 14 13 0

64 14 13 25 33 51 43 53 84 72 93 95 97 96 6

bal felező

Bináris keresés

8 2 1 3 4 6 5 7 10 9 11 12 14 13 0

64 14 13 25 33 51 43 53 84 72 93 95 97 96 6

bal felező jobb

Bináris keresés

8 2 1 3 4 6 5 7 10 9 11 12 14 13 0

64 14 13 25 33 51 43 53 84 72 93 95 97 96 6

bal jobb

Bináris keresés

8 2 1 3 4 6 5 7 10 9 11 12 14 13 0

64 14 13 25 33 51 43 53 84 72 93 95 97 96 6

bal jobb fele

Bináris keresés

8 2 1 3 4 6 5 7 10 9 11 12 14 13 0

64 14 13 25 33 51 43 53 84 72 93 95 97 96 6

bal

jobb

Bináris keresés

8 2 1 3 4 6 5 7 10 9 11 12 14 13 0

64 14 13 25 33 51 43 53 84 72 93 95 97 96 6

bal

jobb

felező

Bináris keresés

8 2 1 3 4 6 5 7 10 9 11 12 14 13 0

64 14 13 25 33 51 43 53 84 72 93 95 97 96 6

bal

jobb

felező

Bináris keresés

Bináris keresés C++ program

bool BinSearch(double list[ ], int n, double item, int&index){

int left=0;

int right=n-1;

int mid;

while(left<=right){

mid=(left+right)/2;

if(item> list [mid]){ left=mid+1; }

else if(item< list [mid]){right=mid-1;}

else{

item= list [mid];

index=mid;

return true; }

}// while

return false;

47

Előny:

Gyors, O(log2n)

Hátrány:

Rendezni kell a tömböt nagyság / ábécé

sorrendben

48

Bináris keresés

Bináris keresés O(log2n)

n jelölje az összes elem számát, amelyek közül meg akarunk keresni

egyet.

k jelölje a keresés lépéseinek számát.

A keresés során minden lépésben megfelezzük az elemek számát.

49

Lépések

száma

elemek száma, amik

közül keresünk

0 n

1 n/2

2 (n/2)/2=n/22

…

k (n/2)/2…/2=n/2k =1

Legrosszabb esetben felezéskor

már csak egy, éppen a keresett

elemünk maradt, ezért

n/2k=1

n=2k

k=log2n

50

Algoritmusok

Akkor is nehéz két algoritmust öszehasonlítani, ha

ugyanazt a problémát oldják meg, pl. két rendező

algoritmus.

Az első lehet gyorsabb kis n-ekre a második pedig

nagyobb n-re

Az első lehet gyorsabb, ha pl. az n szám már csaknem

rendezve van, a második pedig általános esetben.

Lin és bin. keresések összehasonlítása

Az iterációk átlagos száma

Darabszám Lineáris keresés Bináris

keresés

10 5.5 2.9

100 50.5 5.8

1,000 500.5 9.0

10,000 5000.5 12.0

51

52

O(1) – konstans futási idő

Program:

x = 3*y + 2; z = z + 1;

Ennek végrehajtása konstans ideig tart, azt nehéz lenne megmondani, hogy hány sec egy adott számítógépen, de akárhányszor fut, egyformának vehető a futási idő

O(1) azt jelenti, hogy VALAMILYEN konstans, lehet ez 5, 7, vagy akár 7,234,817 . Lehetne O(c)-t is írni.

53

O(n) - Linear Time-lineáris idejű alg.

Program:

for (i = 0; i < n; i++)

v[ i ] = v[ i ] + 1;

Ez a ciklus pontosan n-szer fut le, tehát feltételezve, hogy a

ciklus belsejének végrehajtása konstansnyi idő, akkor a

teljes futási idő n-nel arányos: O(n).

Az éppen aktuális utasításszám lehet pl. 50, és a futási idő

17n microsec, de lehet éppen 17n+3 is

Ameddig ez az n-nek lineáris függvénye mindig O(n)-t

írunk, és azt mondjuk, hogy lineáris a futási idő.

Példa: lineáris keresés

54

Kis n-ekre mi a jobb?

Azt várjuk, hogy a lineáris idejű algoritmus jobb,mint a négyzetes idejű. Ez nagyjából így is van, de:

TFH, egyik program

O(n2) = n2+4, a másik pedig O(n) = 4n+92

n2+4 > 4n+92? vagy n2 > 4n+88 ?

n=10: 100>128 HAMIS

n=11: 121>132 HAMIS

n=12: 144>136 IGAZ

Minden n<12 –re az O(n2) – es program gyorsabb

55

Példa: O(n2) – kvadratikus, négyzetes futási időre

Egymásba ágyazott hurkoknál::

for (i = 0; i < n; i++)

for (j = 0; j < n; j++)

a[ i ][ j ] = b[ i ][ j ] * x;

A külső ciklus n-szer fut le,és minden egyes futásánál a

belső is n-szer: n*n = n2

Ennek tehát O(n2) a futási ideje.

Azt mondjuk, hogy ez négyzetes, vagy kvadratikus

futási idejű program.

56

Egy program mátrix szorzásra

for (i = 0; i < n; i++)

{

for (j = 0; j < n; j++)

{

C[ i ][ j ] = 0;

for (k = 0; k < n; k++)

{

C[ i ][ j ] = C[ i ][ j ] + A[ i ][ k ] * B[ k ][ j ];

}

}

}

3 egymásba ágyazott hurok: n*n*n = n3.

A legbelső: számok szorzása és összege O(1) idejű.

Így e program összességében O(n3) idejű.

Különböző programszerkezetek kompl.

57

58

Futási idők elnevezése

Nagy

Ordo/Big-

O

jelentés n=4 n=16

O(1) konstans idejű 1 1

O(log n) logaritmikus idejű 2 4

O(n) lineáris idejű 4 16

O(nlogn) nlogn idejű 8 64

O(n2) négyzetes idejű 16 256

O(n3) köbös idejű 64 4096

O(nk) polinomiális idejű 4k 16k

O(2n) exponenciális

idejű

16 65,536

59

Szabályok szorzásra és összeadásra

Ha T1(n) = O(f(n)) és T2(n) = O(g(n)), akkor

T1(n) * T2(n) = O(f(n) * g(n)).

T1(n) + T2(n) = O( max {f(n), g(n)} )

60

P

Ha adott egy bizonyítás, arról (algoritmikusan) könnyű

eldönteni, hogy jó-e.

Ha a tétel adott, annak bizonyítását algoritmikusan lehetetlen

megkeresni.

P A feladatoknak azt az osztályát, amelyek

polinomiális idejű algoritmussal megoldhatók, P-nek

nevezzük

Ezek tehát azok az algoritmusok, amelyek valójában

„kivárhatók”

61

62

Példák P-beli problémákra

P: Olyan eldöntendő problémák, amelyeknél a választ

(igen,nem) meg tudjuk keresni polinom idejű algoritmussal

Probléma Leírás Algoritmus Igen Nem

MULTIPLE Igaz-e hogy x többszöröse

y-nak? Ált. isk.: osztás 51, 17 51, 16

RELPRIME X és y relatív prím-e? Euklidesz (ie. 300 )

34, 39 34, 51

PRIMES Az x szám prímszám? AKS (2002) 53 51

LSOLVE Is there a vector x that

satisfies Ax = b? Gauss-Edmonds

elimination

0 1 1

2 4 2

0 3 15

,

4

2

36

1 0 0

1 1 1

0 1 1

,

1

1

1

Agrawal–Kayal–Saxena prím teszt=AKS, O(log 7,5n)

63

NP (co-NP)

Azokat a feladatokat, melyeknél a megoldás helyességét tudjuk polinomiális idő alatt ellenőrizni, NP-vel jelöljük. (Itt a P a polinomiális szó kezdőbetűje, N pedig a nem-determinisztikusé.)

Tulajdonképpen azok a polinomidőben tesztelhető feladatok, melyeknél az igenlő válasz külső segítséggel eldönthető. A külső segítség az ún. tanu.

Amelyekre pedig a nemleges választ lehet eldönteni polinomiális idő alatt, azok az ún. co-NP nevű osztályba tartoznak.

64

NP példák

NP-beli feladatok:

- például n lányt és n fiút összeházasítani úgy, hogy csak

ismerősök házasodhatnak. Ha valaki a hozzárendelést

megcsinálja, akkor gyorsan tudjuk ellenőrizni hogy az

tényleg helyes-e.

- az utazó ügynök problémája is: n városból bizonyosak

között van repülőjárat. Van-e olyan repülős körút, amely

minden várost pontosan egyszer érint?

- adott néhány fajta csempénk, ki tudunk tölteni velük

szabályosan egy n-szer n-es négyzetet?

- adott egy összetett szám, írjuk fel két egynél nagyobb

egész szám szorzataként (faktorizáció).

65

?P?=?NP?

Általánosságban az a sejtés, hogy P nem egyenlő NP-vel,

és P=(NP co-NP).

!!1 000 000 DOLLÁROS FELADAT!!

?P?=?NP?

66

http://webcache.googleusercontent.com/search?q=cache:GgohifMPKKAJ:

cs.iupui.edu/~xkzou/teaching/CS580/NP-Completeness.ppt+np+np-

complete+np-hard+figure+ppt&cd=2&hl=hu&ct=clnk&gl=hu

67

P, NP, NP nehéz, NP teljes

Az A feladat B-re visszavezethető: ha létezik A-nak egy polinomidejű megoldása, ami szubrutinként használhatja a B megoldását.

NP-nehéz feladat: ha minden NP-beli probléma visszavezethető rá

Protein design NP nehéz – 2002-ben biz

NP-teljes feladat: amik maguk is benne vannak NP-ben.

NP-teljes feladatokra példák:

- Hamilton-kör

- egy gráf pontjai kiszínezhetők-e maximum 3 színnel úgy, hogy bármely él két vége különböző színű legyen

- kielégíthetőségi probléma is, amely azt kérdezi, hogy lehet-e logikai változóknak értéket adni, hogy egy egyszerű formula (pl. KNF: és-ekkel összekapcsolt vagyok) igaz legyen.

Shortest superstring (genes) NP-complete

68

Reducing SST TO TSP

69

70

Nem megoldható problémák létezése

Gödel eredménye: Hilbert eldöntésproblémájának megoldhatatlanságát

bizonyítja: ha adott egy kellő kifejezőerővel rendelkező, kezehető

formális rendszer, ahhoz nem található olyan, minden esetre

alkalmazható algoritmus, ami minden állításról megmondaná, hogy a

rendszer szabályainak megfelelôen levezethető-e vagy sem.

Példák:

- a Peano aritmetika formulahalmaza a megfelelő levezetési

szabályokkal

- vagy a halmazelmélet valamely axiómarendszer

- csoportok és gyűrűk elméletével is: nem létezik algoritmus, amely

mondjuk minden csoportelméleti állításról megmondaná, hogy

teljesül-e vagy sem az összes csoportban.

Traveling Salesman

Traveling Salesman Problem

Az utazó ügynök probléma NP-teljes.

TSP

Adottak:

- G = (V,E) , n csúcsú gráf.

- c(e): egész értékű költség függvény az éleken

- K természetes szám

Kérdés: Van-e olyan Hamilton kör, melynek költsége

legfeljebb k?

71

TSP NP-teljes

Hamilton körre lehet visszavezetni

G = (V,E), H legyen teljes gráf V-n, a c költség

c(e)=

A legolcsóbb útvonal H-ban n akkor és csak akkor, ha G-

ben van Hamilton kör.

Ha nincs, akkor egy olyan élet használtunk, ami

eredetileg nem tartozott a gráfhoz, s annak költsége 2.

Ezért ez esetben a költség n + 1.

72

1, ha eE

2, ha eE

Forrás:http://www8.cs.umu.se/kurser/TDBAfl/VT06/algorith

ms/BOOK/BOOK3/NODE108.HTM#SECTION026220000

00000000000

73

Nem megoldható problémák létezése

Gödel eredménye: Hilbert eldöntésproblémájának

megoldhatatlanságát bizonyítja: ha adott egy kellő

kifejezőerővel rendelkező, kezelhető formális rendszer,

ahhoz nem található olyan algoritmus, ami minden

állításról megmondaná, hogy a rendszer szabályainak

megfelelően levezethető-e vagy sem.

Példák:

-a Peano aritmetika formulahalmaza a megfelelő levezetési

szabályokkal

-a halmazelmélet valamely axiómarendszer

-csoportok és gyűrűk elméletével is: nem létezik algoritmus,

amely mondjuk minden csoportelméleti állításról

megmondaná, hogy teljesül-e vagy sem az összes csoportban.

74

Gyakorlat

Természetesen az, hogy egy algoritmus polinomiális idejű nem jelenti azt, hogy a gyakorlatban is hatékonynak kellene tekintenünk, vagy hogy az ellenkezôje automatikusan kizárja a használható eljárások közül.

Például a lineáris programozási feladatok megoldására ma is legszélesebb körben alkalmazott eljárás a szimplex módszer nem polinomiális idejű.

A polinomiális algoritmusok vizsgálata azonban ebbôl a szempontból is sikeres: ilyen algoritmus keresése gyakran a gyakorlatban is fontos és használható eredményre vezetett ahogyan ez a lineáris programozás esetében is történt. A talált polinomiális algoritmus segítségével egy sor olyan feladatot is sikerült gyors algoritmussal megoldani, melyekre korábban ilyen nem volt ismert.

75

Turing gépek

Turing gép=számítási modell

Miért fontos ez a modell?

Be lehet bizonyítani, hogy

minden olyan kiszámítható

probléma, amit a másik

számítógépek ki tudnak

számítani, kiszámítható a

Turing modellel.

Vagyis: Ha olyan problémát

találunk, ami Turing géppel

NEM számítható ki, akkor az

MEGOLDHATATLAN

(ELDÖNTHETETLEN)

probléma.

(MA –De quantum szg? ND)

Turing gép : szalag, helyekkel, jobbra-

balra mozog, egy pozíciót ír, egy

pozíciót olvas

76

Tár komplexitás másképpen

Definíció:

Legyen M (determinisztikus) Turing gép (program),

amely minden inputra megáll. Az M

tár komplexitása az az f: N->N függvény, ahol

f(n)=a legjobboldali szalag pozíció, melyet a gép elér

akármilyen n db input esetén.

77

Idő komplexitás másképpen

Definíció: M legyen olyan Turing gép (program), amire a

Turing gép megáll, bármilyen input esetén. A futási idő,

vagy más néven az M idő komplexitása

az f : N -> N, ahol f(n) az a maximális lépésszám, amit M

használ valamely n bemenő adat esetén.

78

Megállási probléma/HALTing problem

Nem magától értetődő, hogy valamely program esetén

MEGÁLL a számítógép.

Megállási probléma/Halting problem:

Adott program és adott input esetén meg lehet-e

határozni, hogy a program megáll ezen input

esetén?

Ez példa ELDÖNTHETETLEN problémára.

BIZ.: EGY példát kell adni olyan programra és

bemenetre, amely esetén ezt nem lehet eldönteni.

79

Megállási probléma

Indirekt, TFH, létezik olyan Turing gép program, hívjuk

Megállási Problémát Megoldó Programnak=MPMP

Ennek bemenete egy program (PéldaProgram=PP) és annak

egy inputja (Példa Adat=PA). A kimenet pedig az a sztring,

hogy ezekre az adatokra a PP program megáll (Halt), vagy

nem áll meg: (Loop)

A Megállási Problémát Megoldó Program terve

PP + PA

MPMP Halt vagy

Loop

80

Megállási probléma

Írjunk egy új programot, legyen UP a neve.

UP bemenő adata legyen ugyanaz a PéldaProgram a Példa Adatokkal együtt, és használja az MPMP algoritmust, annak eldöntésére, hogy a PéldaProgram megáll-e ezekre az adatokra, vagy sem.

Ha az MPMP azt adja hogy Halt, akkor UP azt írja ki hogy Loop,

ha pedig MPMP azt adja, hogy Loop, akkor azt írja ki hogy Halt.

Akárhogyan is, mindig rossz választ fog adni.

81

Megállási probléma

UP konstrukciója

PP

PA

Halt ()

Loop

Halt UP, használva a

MPMP

algoritmust

Input Output Uj Program=UP

UP bemenő adata legyen ugyanaz a PéldaProgram a Példa Adatokkal együtt, és használja az MPMP algoritmust, annak eldöntésére, hogy a PéldaProgram megáll-e ezekre az adatokra, vagy sem.

Ha az MPMP azt adja hogy Halt, akkor UP azt írja ki hogy Loop,

ha pedig MPMP azt adja, hogy Loop, akkor azt írja ki hogy Halt.

82

Megállási probléma

Tegyük fel, hogy a PP bemenete valamely PA-val jelölt

sztring.

Jelölés: P(PA) legyen a P program eredménye valamely PA

bemeneti sztringgel – ez is sztring, ez is lehet egy program

bemenete.

http://www.youtube.com/watch?v=dhs04ofFJPI

83

Megállási probléma

MPMP(PP)

HALT, ha PP megáll a PA-

bemenetre

LOOP, ha PP nem áll meg a PA-

bemenetre

UP(PP) (szubrutinként

használja az MPMP-t) HALT, ha a bemenetre MPMP

Loop-ot ír ki

LOOP, ha a bemenetre MPMP Halt-

ot ír

UP(UP) –??? (Ha MPMP azt írná ki, hogy Loop, akkor ő Haltot ad ki,

ha viszont MPMP azt írnáki hogy Halt, akkor ő Loop-ot ír ki)-vagyis ha

áll, akkor megy, és ha megy akkor áll – átlós eljárás

84

Erős Church - Turing Tézis

Minden ÉSSZERŰ számítástechnikai

modell polinom idő/tár ekvivalens

(mindegy milyen (de adekvát) modellt

használunk)

NEM ésszerű: pl. a fizikai lehetőségeket nem

helyesen írja le