DM eloadas marc 25 hang - users.itk.ppke.hub_novak/DM/DM_eloadas_marc_25.pdf · 1dj\ 2ugy ghilqtfly...

$: DM eloadas marc 25 hang - users.itk.ppke.hub_novak/DM/DM_eloadas_marc_25.pdf · 1dj\ 2ugy ghilqtfly 'hilqtfly i pvj npw i jjypq\ 1o5 $]w prqgmxn krj\ i q 2 j q Äqdj\ rugy j q ´$
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


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


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


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


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


- 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


20


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(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(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


Í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


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


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

DM eloadas marc 25 hang - users.itk.ppke.hub_novak/DM/DM_eloadas_marc_25.pdf · 1dj\ 2ugy ghilqtfly...

Documents

Transcript of DM eloadas marc 25 hang - users.itk.ppke.hub_novak/DM/DM_eloadas_marc_25.pdf · 1dj\ 2ugy ghilqtfly...