View
2
Download
0
Category
Preview:
Citation preview
https://www.magyarkurir.hu/hirek/vilagmeretu-kozos-imadsagra-hiv-vilagjarvany-idejen-ferenc-papa-marcius-25-re
1
Ferenc pápa:…”Kérektehát mindenkit, hogyegyrészt mindennaptöbbször is imádkozza ela miatyánkot, március 25-én, szerdán délben viszontközösen, mindnyájanegyütt imádkozzuk.”
2020. Március 25.
2
2020. Március 25.
Függvények növekedése
Nagyságrend
Összeállította és előadja: Bércesné dr. Novák Ágnes
Függvények növekedése
Miért szükséges?
Algoritmus-függvény
Bemenő adatok – kimenő eredmény
Nem mindegy, mennyire hatékony
3
Futási idő
4
T(n) a futási idő a program futása közben „elhasznált” időegységek száma, az n db bemenő adatok függvényében.
Általában nagyszámú bemenő adatról van szó: nem mindegy, hogy 10 adatot vagy 10 millió adatot kell pl. rendezni, utóbbi esetén a hatékonyság különösen fontos.
A T(n) futási időt más ismert függvényekkel szokás összehasonlítani: T(n) ≈cf(n), c pozitív konstans
Futási időhöz használt matematikai fogalmak
- Nagy ordó – „big O”
- (Kis ordó-analízis)
- Nagy omega -
- Teta – nagyságrend
5
Nagy ordó BIG O
7
Nagy Ordó jelölés
Aszimptotikus komplexitási mérték, algoritmusok ( 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)
8
Nagy ordó: 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
9
Nagy Ordó definíció
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, hogyf(n) c·g(n) minden nn0-ra.
Azt mondjuk ekkor, hogy g(n) (aszimptotikus) felső korlátja f(n)-nek
10
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
11
Példa az aszimptotikus felső korlátra
f(n)=3n2+5
g(n)=n2
4g(n)=4n24 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
12
Nagy Ordo példák (folytatás)
Példa
Mutassuk meg, hogy 3n2+5n-8 = O(n2)
Megoldás:
3n2+5n-8 3n2+5n
3n2+5n2 8n2
Ez már n=1 és c=8-ra igaz, tehát valóban
3n2+5n-8 = O(n2)
HÁZI FELADAT: Bizonyítsa, hogy
3n2+2n+5 = O(n2)
13
Nagy Ordo példák
Példa: Bizonyítsa be, hogy az alábbi függvényekre f(n)=O(g(n)):
f(n) = 15n2 + 7n g(n) = ½·n3
Megoldás:
minden n n0-ra
f(n) = 15n2 + 7n 15n2 + n2 16n2 n3 = c·g(n),
ha n=16 és c=2
HÁZI FELADATOK: Bizonyítsa, hogya.)3n2+2n+5 = O(n2)
b.) 5n4 + 27n = O(n4)
14
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)
15
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)
16
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))
d>1n·log(n) = O(nd) , d=?
17
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
18
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)
19
Nagy Ordo „rendezés”
20
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)”
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) = 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: olvasd: „kis ordó g(n)” 0
)(
)(lim
ng
nfn
21
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
22
Példa 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
23
Aszimptotikus szoros korlát
f(n)
c1 g(n)
• f(n) = O(g(n)) és f(n) = (g(n))
n0
c2 g(n)
24
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
nfn
25
Függvények növekedése
f(n) = (g(n) másképpen azt is jelenti, hogyf(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!
26
Aszimptotikus alsó () és felső(O) korlátok egymáshoz való viszonya
27
( f ) O( f )( f )• f
KIEGÉSZÍTŐ ANYAG: Aszimptotikus korlátok
28
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
29
NAGY ORDO/Big-O
Algoritmusok komplexitása
31
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 analízis: a futási idő miként változik a bemeneti adatok számának növelésével?
32
33
Két kritériumot használunk az algoritmusok összehasonlítására: a.) tár komplexitás b.) idő komplexitása isa.) 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égesműveletek számára vonatkozóan, a bemenő adatokfüggvényében. Egy műveletet egy időegység alattvégrehajthatónak képzelünk el, ezért nevezzükidőkomplexitásnak, hiszen így a futási időre kapunkinformá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 inputadatmennyiség függvényében a lényeges!
34
Tár komplexitás-ld. Adatszerkezetek:a probléma megoldásához szükséges memórianagyságrendi becslése.
Egy példa
35
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ás3. i=04.while i<n5. olvassuk be a számot= number//felhasználó begépeli6. sum=sum+number7.i=i+18.átlag=sum/n
KIÉRTÉKELÉSEK SZÁMA:1 (időegység)
11nn
nn1T(n)=4n+4= (n) 36
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
e
1000 2000 3000 4000
Input Size
best caseaverage caseworst case
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 nlépés
Best case: elsőre megtaláljuk, ez 1 lépés
Average case:
37
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
38
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ű)
39 40
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
41
Adott egy szám, value, és egy rendezett tömb a[], meg kelltalálni azt az i indexet, amely tömbelem azt az értékettartalmazza, mint a value : a[i] = value, vagy, ha nincsilyen, akkor kiírni, hogy nincs.
Bináris keresés O(log2n)
42
Ha a felénél talált szám nagyobb, mint a keresett, akkorközépső index-1 lesz az új intervallum jobb oldala, az eredeti balpedig az új bal oldal:
a[bal] value a[közép-1]
Bináris keresés O(log2n)
Az algoritmus működése: a felénél a[közép] megnézzük atartalmat, ha kisebb a keresett számnál, akkor a középső index+1lesz az intervallum bal oldala, az eredeti a jobboldala:
a[közép+1] value a[jobb]
821 3 4 65 7 109 11 12 14130
641413 25 33 5143 53 8472 93 95 97966
Bináris keresés
lo
Példa: 14 elemű tömbben a 33-at keressük meg
jobbbal
821 3 4 65 7 109 11 12 14130
641413 25 33 5143 53 8472 93 95 97966
jobbfelező
Bináris keresés
641413 25 33 5143 53 8472 93 95 97966
821 3 4 65 7 109 11 12 14130
641413 25 33 5143 53 8472 93 95 97966
bal felező
Bináris keresés
641413 25 33 5143 53 8472 93 95 97966
821 3 4 65 7 109 11 12 14130
641413 25 33 5143 53 8472 93 95 97966
bal felező jobb
Bináris keresés
641413 25 33 5143 53 8472 93 95 97966
821 3 4 65 7 109 11 12 14130
641413 25 33 5143 53 8472 93 95 97966
bal jobb
Bináris keresés
641413 25 33 5143 53 8472 93 95 97966
821 3 4 65 7 109 11 12 14130
641413 25 33 5143 53 8472 93 95 97966
bal jobbfele
Bináris keresés
641413 25 33 5143 53 8472 93 95 97966
821 3 4 65 7 109 11 12 14130
641413 25 33 5143 53 8472 93 95 97966
baljobb
Bináris keresés
641413 25 33 5143 53 8472 93 95 97966
821 3 4 65 7 109 11 12 14130
641413 25 33 5143 53 8472 93 95 97966
baljobb
felező
Bináris keresés
641413 25 33 5143 53 8472 93 95 97966
821 3 4 65 7 109 11 12 14130
641413 25 33 5143 53 8472 93 95 97966
baljobb
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; }
}// whilereturn false;
52
Előny:
Gyors, O(log2n)
Hátrány:
Rendezni kell a tömböt nagyság / ábécé sorrendben
53
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 keresniegyet.
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.
54
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=1n=2k
k=log2n
55
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áriskeresé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
56
57
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.
58
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
59
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 HAMISn=11: 121>132 HAMIS
n=12: 144>136 IGAZ
Minden n<12 –re az O(n2) – es program gyorsabb
60
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 kvadratikusfutási idejű program.
61
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.
62
63
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álisidejű
16 65,536
64
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)} )
HÁZI FELADAT: írjon algoritmust két n dimenziós vektor skalárszorzatának kiszámítására, és becsülje meg a futási idő nagyságrendjét.
A 3 házi feladatot a gyakorlatvezetőknek kell beadni!
A következő oldalakon (66-89) érdekes olvasmányok találhatóak, remélem sokaknak lesz
ideje végigolvasni.
KÖSZÖNÖM A FIGYELMET!
66
67
OLVASMÁNY: 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 lehetetlenmegkeresni.
PA feladatoknak azt az osztályát, amelyek
polinomiális idejű algoritmussal megoldhatók, P-neknevezzük
Ezek tehát azok az algoritmusok, amelyek valójában „kivárhatók”
68
OLVASMÁNY: 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)
69
OLVASMÁNY: NP (co-NP)
Azokat a feladatokat, melyeknél a megoldáshelyességét tudjuk polinomiális idő alattellenőrizni, NP-vel jelöljük. (Itt a P a polinomiálisszó 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.
70
OLVASMÁNY: NP példák
NP-beli feladatok:
- n lányt és n fiút összeházasítani úgy, hogy csakismerősök házasodhatnak. Ha valaki a hozzárendeléstmegcsinálja, akkor gyorsan tudjuk ellenőrizni hogy azté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ó).
71
OLVASMÁNY:?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?
72
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
d1
72. dia
d1 Forrás: 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=hudeveloper; 2014. 04. 07.
73
OLVASMÁNY: 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.
Olvasmány:Shortest superstring (genes) NP-complete
74
Reducing SST TO TSP
75 76
Olvasmány:Nem megoldható problémák létezése
Gödel eredménye: Hilbert eldöntésproblémájának megoldhatatlanságátbizonyítja: ha adott egy kellő kifejezőerővel rendelkező, kezehetőformális rendszer, ahhoz nem található olyan, minden esetrealkalmazható algoritmus, ami minden állításról megmondaná, hogy arendszer szabályainak megfelelôen levezethető-e vagy sem.
Példák:
- a Peano aritmetika formulahalmaza a megfelelő levezetésiszabályokkal
- vagy a halmazelmélet valamely axiómarendszer
- csoportok és gyűrűk elméletével is: nem létezik algoritmus, amelymondjuk minden csoportelméleti állításról megmondaná, hogyteljesül-e vagy sem az összes csoportban.
Olvasmány(később tanuljuk majd):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?
77
Olvasmány: 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.
78
1, ha eE2, ha eE
Forrás:http://www8.cs.umu.se/kurser/TDBAfl/VT06/algorithms/BOOK/BOOK3/NODE108.HTM#SECTION02622000000000000000
79
Olvasmány: Nem megoldható problémák létezése
Gödel eredménye: Hilbert eldöntésproblémájánakmegoldhatatlansá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ályainakmegfelelően levezethető-e vagy sem.
Példák:-a Peano aritmetika formulahalmaza a megfelelő levezetésiszabá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ólmegmondaná, hogy teljesül-e vagy sem az összes csoportban. 80
Olvasmány: Gyakorlat
Természetesen az, hogy egy algoritmus polinomiális idejűnem jelenti azt, hogy a gyakorlatban is hatékonynakkellene tekintenünk, vagy hogy az ellenkezôjeautomatikusan kizárja a használható eljárások közül.
Például a lineáris programozási feladatok megoldására ma islegszélesebb körben alkalmazott eljárás a szimplexmódszer nem polinomiális idejű.
A polinomiális algoritmusok vizsgálata azonban ebbôl aszempontból is sikeres: ilyen algoritmus keresése gyakrana gyakorlatban is fontos és használható eredményrevezetett ahogyan ez a lineáris programozás esetében istörtént. A talált polinomiális algoritmus segítségével egysor olyan feladatot is sikerült gyors algoritmussalmegoldani, melyekre korábban ilyen nem volt ismert.
81
Olvasmány: Turing gépek
Turing gép=számítási modell
Miért fontos ez a modell?
Be lehet bizonyítani, hogyminden olyan kiszámíthatóprobléma, amit a másikszámítógépek ki tudnakszámítani, kiszámítható aTuring modellel.
Vagyis: Ha olyan problémáttalálunk, ami Turing géppelNEM számítható ki, akkor azMEGOLDHATATLAN(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
82
Olvasmány: 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.
83
Olvasmány: 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.
84
Olvasmány: 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.
85
Olvasmány: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 MPMPHalt vagy
Loop
86
Olvasmány: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.
87
Olvasmány:Megállási probléma
UP konstrukciója
PPPA Halt ()
Loop
HaltUP, használva a
MPMP algoritmust
Input OutputUj 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.
88
Olvasmány: 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=wGLQiHXHWNk
(4:16)
https://www.youtube.com/watch?v=92WHN-pAFCs
89
Olvasmány: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
90
Olvasmány: Erős Church - Turing Tézis
Minden ÉSSZERŰ számítástechnikai modell polinom idő/tár ekvivalens
(pl. a Turing géppel, mindegy milyen -de adekvát-modellt használunk)
NEM ésszerű: pl. a fizikai lehetőségeket nem helyesen írja le
Recommended