2018. Algoritmusok komplexitása Függvények növekedése Nagyságrend 1 Nagy Ordó jelölés Függvények növekedése: Nagy Ordó 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) Definíció: f és g két függvény: N R+. 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 n 0 úgy, hogy f(n) c g(n) minden n n 0 -ra. Azt mondjuk ekkor, hogy g(n) (aszimptotikus) felső korlátja f(n)-nek 3 4
Aszimptotikus felső korlát Példa az aszimptotikus felső korlátra f(n) c g(n) minden n n 0 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). c g(n) f(n) g(n) 4 g(n) = 4n 2 = 3n 2 + n 2 3n 2 + 9 minden n 3 > 3n 2 + 5 = f(n) Tehát: f(n)=o(g(n)): 3n 2 +5=O(n 2 ) 4g(n)=4n 2 f(n)=3n 2 +5 g(n)=n 2 n 0 3 5 6 Nagy Ordo példák Nagy Ordo példák (folytatás) f(n) = 15n 2 + 7n g(n) = ½ n 3 f(n)=o(g(n)) mert n 0 =16 és c=2 választással, minden n n 0 -ra f(n) = 15n 2 + 7n 16n 2 n 3 = c g(n). Mutassuk meg, hogy 3n 2 +2n+5 = O(n 2 ) 5n 4 + 27n = O(n 4 ). n 0 =1, c=32. (De pl. n 0 =3 és c=6 is jó) 7 8
Nagy Ordo példák (folytatás) Nagy Ordo példák (folytatás) A lehető legegyszerűbb és legkisebb függvényt használjuk az O mögött: Mutassuk meg, hogy 3n 2 +2n+5 = O(n 2 ) 10 n 2 = 3n 2 + 2n 2 + 5n 2 3n 2 + 2n + 5 ha n 1 c = 10, n 0 = 1 3n 2 +2n+5 = O(n 2 ) Ezek itt pl. helyesek, de nem hasznosak: 3n 2 +2n+5 = O(3n 2 +2n+5) 3n 2 +2n+5 = O(n 2 +n) 3n 2 +2n+5 = O(3n 2 ) 9 10 Nagy Ordo példák (folytatás) Nagy Ordo példák (folytatás) f(n) = a n k +, f(n) = O(n k ) minden r k-ra f1(n) = 10 n + 25 n 2 f2(n) = 20 n log n + 5 n f3(n) = 12 n log n + 0.05 n 2 f4(n) = n 1/2 + 3 n log n O(n 2 ) O(n log n) O(n 2 ) O(n log n) f(n) = a n k +, f(n)=o(2 n ). n = O(n log(n)) n log(n) = O(n d ), d=? d>1 11 12
Nagy Ordo rendezés f(n) = O(f(n)) minden f-re (log(n)) k = O(n) minden konstans k-ra n k = O(2 n ) minden konstans k-ra Nagy Ordo rendezés - A polinomok dominálnak ( nagyobbak ), mint a logaritmus függvények, illetve ezek hatványai - (a log(n) = O(log(n)) minden a-ra, ezért a log alapját nem kell kiírni) - Az exponenciális függvények dominálnak a polinomok fölött 13 14 Nagy Ordo rendezés 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) = O(g(n) ÉS g(n) = O(f(n)) akkor f és g NAGYSÁGRENDJE EGYENLŐ Analízis: f(n) = o(g(n)) jelentése: f ( n) olvasd: kis ordó g(n) lim n g( n) 0 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 15 16
KIEGÉSZÍTŐ ANYAG:Aszimptotikus alsó korlát KIEGÉSZÍTŐ ANYAG: Példa az aszimptotikus alsó korlátra létezik olyan c és n 0, hogy minden n n 0 -ra f(n) c g(n) g(n) az f(n) aszimptotikus alsó korlátja Jelölés: f(n)= (g(n)) f(n) c g(n) g(n)/4 = n 2 /4 = n 2 /2 n 2 /4 n 2 /2 9 minden n 6 < n 2 /2 7 Tehát: f(n)= (g(n)). g(n)=n 2 f(n)=n 2 /2-7 c g(n)=n 2 /4 n 0 6 17 18 KIEGÉSZÍTŐ ANYAG: Aszimptotikus szoros korlát KIEGÉSZÍTŐ ANYAG: Függvények növekedése f(n) = O(g(n)) és f(n) = (g(n)) n 0 c 2 g(n) f(n) c 1 g(n) 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) 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) f ( n) lim n 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 0 19 20
KIEGÉSZÍTŐ ANYAG: Függvények növekedése Nagy Ordó Big Oh! 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 21 22 KIEGÉSZÍTŐ ANYAG: Aszimptotikus korlátok Néhány függvény időkomplexitása Aszimptotikus alsó ( ) és felső(o) korlátok egymáshoz való viszonya f ( f ) ( f ) O( f ) Komplexitás 10 20 30 40 50 60 n 1 10-5 sec 2 10-5 sec 3 10-5 sec 4 10-5 sec 5 10-5 sec 6 10-5 sec n 2 0.0001 sec 0.0004 sec 0.0009 sec 0.016 sec 0.025 sec 0.036 sec n 3 0.001 sec 0.008 sec 0.027 sec 0.064 sec 0.125 sec 0.216 sec n 5 0.1 sec 3.2 sec 24.3 sec 1.7 perc 5.2 perc 13.0 perc 2 n 0.001sec 1.0 sec 17.9 perc 12.7 nap 35.7 év 366 évsz 3 n 0.59sec 58 perc 6.5 év 3855 évsz 2 10 8 évsz 1.3 10 13 évsz log 2 n 3 10-6 sec 4 10-6 sec 5 10-6 sec 5 10-6 sec 6 10-6 sec 6 10-6 sec n log 2 n 3 10-5 sec 9 10-5 sec 0.0001 sec 0.0002 sec 0.0003 sec 0.0004 sec 23 24
NAGY ORDO/Big-O Time Complexity and Speed 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(n 2 ) < 1 s < 1 s < 1 s < 1 s < 1 s 2 s 3-4 min O(n 3 ) < 1 s < 1 s < 1 s < 1 s 20 s 5 hours 231 days O(2 n ) < 1 s < 1 s 260 days hangs hangs hangs hangs O(n!) < 1 s hangs hangs hangs hangs hangs hangs O(n n ) 3-4 min hangs hangs hangs hangs hangs hangs 25 26 Algoritmusok komplexitása Mit lehet és mit nem lehet megoldani a számítógépek használatával? Algoritmusok komplexitása 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 28
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? Komplexitás 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 29 30 Komplexitás Egy példa Tár komplexitás-ld. Adatszerkezetek: a probléma megoldásához szükséges memória nagyságrendi becslése. 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: 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! 31 Á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ő Worst, best, average 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) Running Time 120 100 80 60 40 20 0 best case average case worst case 1000 2000 3000 4000 Input Size 33 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 34 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: 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 Bináris keresés O(log2n) Előny: - Könnyű megérteni - A tömb elemeit nem kell rendezni Hátrány: -Lassú, átlagosan n/2 lépés 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] 37 38 Bináris keresés Bináris keresés Példa: 14 elemű tömbben a 33-at keressük meg 6 13 14 25 33 43 51 53 64 72 84 93 95 96 97 6 13 14 25 33 43 51 53 64 72 84 93 95 96 97 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 lo jobb felező jobb
Bináris keresés Bináris keresés 6 13 14 25 33 43 51 53 64 72 84 93 95 96 97 6 13 14 25 33 43 51 53 64 72 84 93 95 96 97 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 bal felező bal felező jobb Bináris keresés Bináris keresés 6 13 14 25 33 43 51 53 64 72 84 93 95 96 97 6 13 14 25 33 43 51 53 64 72 84 93 95 96 97 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 bal jobb balfelejobb
Bináris keresés Bináris keresés 6 13 14 25 33 43 51 53 64 72 84 93 95 96 97 6 13 14 25 33 43 51 53 64 72 84 93 95 96 97 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 bal jobb bal jobb felező Bináris keresés Bináris keresés C++ program 6 0 13 14 25 33 43 51 53 64 72 84 93 95 96 97 1 2 3 4 5 6 7 8 9 10 11 12 13 14 bal jobb felező 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; 48
Bináris keresés Bináris keresés O(log2n) Előny: Gyors, 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. Hátrány: Rendezni kell a tömböt nagyság / ábécé sorrendben Lépések elemek száma, amik száma közül keresünk 0 n 1 n/2 2 (n/2)/2=n/2 2 k (n/2)/2 /2=n/2 k =1 Legrosszabb esetben felezéskor már csak egy, éppen a keresett elemünk maradt, ezért n/2 k =1 n=2 k k=log 2 n 49 50 Algoritmusok Lin és bin. keresések összehasonlítása 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. Az iterációk átlagos száma Darabszám Lineáris keresés Bináris keresés 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ő O(n) - Linear Time-lineáris idejű alg. 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. 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ő. 53 Példa: lineáris keresés 54 Kis n-ekre mi a jobb? Példa: O(n 2 ) kvadratikus, négyzetes futási időre 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(n 2 ) = n 2 +4, a másik pedig O(n) = 4n+92 n 2 +4 > 4n+92? vagy n 2 > 4n+88? n=10: 100>128 HAMIS n=11: 121>132 HAMIS n=12: 144>136 IGAZ Minden n<12 re az O(n 2 ) es program gyorsabb 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 = n 2 Ennek tehát O(n 2 ) a futási ideje. Azt mondjuk, hogy ez négyzetes, vagy kvadratikus futási idejű program. 55 56
Egy program mátrix szorzásra Különböző programszerkezetek kompl. 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 = n 3. A legbelső: számok szorzása és összege O(1) idejű. Így e program összességében O(n 3 ) idejű. 57 58 Futási idők elnevezése Szabályok szorzásra és összeadásra 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(n 2 ) négyzetes idejű 16 256 O(n 3 ) köbös idejű 64 4096 O(n k ) polinomiális idejű 4 k 16 k O(2 n ) exponenciális idejű 16 65,536 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)} ) 59 60
Ha adott egy bizonyítás, arról (algoritmikusan) könnyű eldönteni, hogy jó-e. P 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 RELPRIME Igaz-e hogy x többszöröse y-nak? X és y relatív prím-e? Ált. isk.: osztás 51, 17 51, 16 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 Agrawal Kayal Saxena prím teszt=aks, O(log 7,5 n), 4 2 36 1 0 0 1 1 1 0 1 1, 1 1 1 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 nemdeterminisztikusé.) 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. 63 64
NP példák?p?=?np? NP-beli feladatok: - 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ó). Általánosságban az a sejtés, hogy P nem egyenlő NP-vel és P = (NP co-np)!!1 000 000 DOLLÁROS FELADAT!! 65 66 d1 http://webcache.googleusercontent.com/search?q=cache:ggohifmpkkaj: cs.iupui.edu/~xkzou/teaching/cs580/np-completeness.ppt+np+npcomplete+np-hard+figure+ppt&cd=2&hl=hu&ct=clnk&gl=hu 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:?p?=?np? - 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. 67 68
67. dia d1 Forrás: http://webcache.googleusercontent.com/search?q=cache:ggohifmpkkaj:cs.iupui.edu/~xkzou/teaching/cs580/np-completeness.ppt+np+np-com developer; 2014.04.07.
Shortest superstring (genes) NP-complete 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 72
TSP NP-teljes Nem megoldható problémák létezése Hamilton körre lehet visszavezetni G = (V,E), H legyen teljes gráf V-n, a c költség c(e)= 1, ha e E 2, ha e 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. Forrás:http://www8.cs.umu.se/kurser/TDBAfl/VT06/algorith ms/book/book3/node108.htm#section026220000 00000000000 73 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 Turing gépek 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ű. 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. 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ép : szalag, helyekkel, jobbrabalra mozog, egy pozíciót ír, egy pozíciót olvas 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) 76
Tár komplexitás másképpen Idő 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. 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. 77 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? 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) 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. PP + PA MPMP Halt vagy Loop 79 A Megállási Problémát Megoldó Program terve 80
Megállási probléma Megállási probléma Írjunk egy új programot, legyen UP a neve. UP konstrukciója 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. PP PA UP, használva a MPMP algoritmust Halt ( ) Loop Halt Akárhogyan is, mindig rossz választ fog adni. Input Uj Program=UP Output 81 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 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. https://www.youtube.com/watch?v=92whn-pafcs MPMP(PP) UP(PP) (szubrutinként használja az MPMP-t) HALT, ha PP megáll a PAbemenetre LOOP, ha PP nem áll meg a PAbemenetre LOOP, ha a bemenetre MPMP Haltot ír HALT, ha a bemenetre MPMP Loop-ot ír ki 83 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 85