Eötvös Loránd Tudományegyetem Természettudományi Kar. Péter Zsófia. Véletlenített algoritmusok és alkalmazásaik. Matematika BSc Szakdolgozat

Átírás

1 Eötvös Loránd Tudományegyetem Természettudományi Kar Péter Zsófia Véletlenített algoritmusok és alkalmazásaik Matematika BSc Szakdolgozat Témavezető: Dr. Fekete István Számítógéptudományi Tanszék Budapest, 2017

2 Köszönetnyilvánítás Szeretném megköszönni témavezetőmnek, Fekete Istvánnak, hogy felhívta a figyelmemet a témára, illetve azt is, hogy szaktudásával és lelkesedésével nagyban hozzájárult a szakdolgozat elkészüléséhez. Külön köszönöm a programok megírásában nyújtott segítségét, és hogy bármikor, bármilyen problémával fordulhattam hozzá.

3 Tartalomjegyzék Bevezetés 5 1. A munkatársfelvétel probléma A feladat és a determinisztikus megoldás Az algoritmus elemzése Az algoritmus véletlenített változata A munkatársfelvétel programja Véletlen permutációk előállítása Permutálás rendezéssel Permutálás cserékkel Gyorsrendezés (Quicksort) A gyorsrendezés algoritmusa Az algoritmus futási ideje A gyorsrendezés pogramja A k adik elem kiválasztása A k adik elem kiválasztása véletlenítéssel Az algoritmus elemzése A k-adik elem kiválasztásának programja Polinomazonosság ellenőrzése A feladat és a megoldás elve Az algoritmus elemzése Prímtesztelés Egy kezdetleges algoritmus Az algoritmus elemzése A Miller Rabin prímteszt

4 7. Karger algoritmusa a MinCut problémára Karger algoritmusa Az algoritmus elemzése Egy továbbgondolt változat Véletlenített hash elés alkalmazása Szükséges előismeretek A helyzetérzékeny hash elés algoritmusa Egy példa a módszer illusztrálására A módszer hibája A k-nn program Összefoglalás 56 Irodalomjegyzék 57

5 Bevezetés "Az ember talán hajlamos a túlzásokra, hogy szándékosságot lásson ott is, ahol lehet, hogy merő véletlen." Agatha Christie Szakdolgozatomban az algoritmusok hatékonyságának növelésére alkalmazott egyik módszerrel, a randomizálással foglalkozom, amely a kezdetektől fogva jelen van a számítógépes világban. A véletlenített algoritmusok közös tulajdonsága, hogy a működésük során bizonyos pontokon felhasználják a véletlen kimenetel eredményét. Az általam ismertetett módszerekben ez véletlenszám generálással történik. A legtöbb programozási nyelvben létezik pszeudo véletlenszám generátor, ami valójában általában egy determinisztikus algoritmus, amely hash függvényeket alkalmaz statisztikailag véletlennek tűnő számok előállítására. A randomizált algoritmusokat két csoportba sorolhatjuk: azokat, amelyek sosem adnak téves megoldást, illetve a véletlen csupán a futási idejüket befolyásolja, Las Vegas típusú, azokat pedig, amelyek kis valószínűséggel ugyan, de nem egzakt eredményt adhatnak vissza, Monte Carlo típusú algoritmusoknak nevezzük. Az utóbbi csoportba tartozók tévedésének valószínűségére is kitérek a dolgozatomban. A véletlenítés egyik nagy előnye a hatékonyságnövelés mellett az egyszerűség. Látni fogjuk, hogy a módszer mennyire sokoldalúan használható a matematika és az informatika számos területén, legyen szó rendezésről, keresésről, prímtesztelésről, algebrai problémáról, vagy akár gráfelméleti alkalmazásról, ezekre mind mind láthatunk példát a különböző fejezetekben. Természetesen a véletlenített algoritmusok köre ennél sokkal szélesebb; a teljesség igénye nélkül szerettem volna kitérni néhány konkrét alkalmazásra. Néhány algoritmust implementáltam Python nyelven. A programok forráskódját és a futási eredményeket az illető algoritmusok leírásánál megadtam. A fejezetek könnyebb megértéséhez az ábrákat a GeoGebra nevű programmal készítettem. A randomizálás, illetve a bizonyítások valószínűségszámítási alapokat igényelnek, amelyekről a dolgozatom érdeklődő Olvasója a [1] és [2] könyvek első néhány fejezetében részletesen tájékozódhat. 5

6 1. fejezet A munkatársfelvétel probléma Kezdjük a véletlenítés eszközének a szemléltetését egy klasszikus példával, a munkatársfelvétel problémával. Először megadunk a feladatra egy véletlent nem használó algoritmust, majd megnézzük ennek a valószínűségi elemzését, végül áttérünk a véletlenített változatra. A véletlenítés ennek az egyszerű feladatnak a megoldásában azt jelenti, hogy a valószínűségi elemzés eredménye alapján, várhatóan kisebb költség reményében a bemenő adat sorrendjét előbb randomizáljuk, vagyis az állásra jelentkezők meghallgatását nem az eredeti, hanem véletlenített sorrendben végezzük A feladat és a determinisztikus megoldás Feladat: Képzeljük el, hogy egy nagy vállalat vezető pozíciójában vagyunk, és szeretnénk felvenni egy új alkalmazottat egy adott munkakörbe. Tegyük fel, hogy egy munkaközvetítő cég jelölteket küld nekünk. Miután egy adott jelölttel elbeszélgettünk, el tudjuk dönteni, hogy alkalmasabb e a feladatra mint az állást jelenleg betöltő személy, és ha igen, akkor őt vesszük fel helyette. Azonban ez számunkra nyilvánvalóan költséggekkel jár: bizonyos összeget fizetünk az állásközvetítő cégnek minden jelölt után ezt jelöljük c j vel, illetve további, nagyobb költséggel jár egy jelentkező tényleges felvétele, hiszen nem csak az előző alkalmazottat kell elbocsátanunk, hanem az állásközvetítő cégnek is nagyobb részesedést fizetünk az alkalmas jelentkező kiközvetítéséért ennek költségét jelöljük c f el. Tegyük fel, hogy az n számú jelöltünket 1 től n ig sorszámozzuk. Célunk nem csak az, hogy a legvégén megtaláljuk a számunkra legalkalmasabb jelöltet, hanem az is, hogy megbecsüljük ennek a végső költségét. Nézzük meg ezután a Munkatársfelvétel eljárást, amely megoldja a legalkalmasabb jelölt kiválasztását. Technikai okokból tegyük fel, hogy az egész procedúra előtt felveszünk egy mindenkinél rosszabb fiktív jelöltet. 6

7 Munkatársfelvétel(n) 1 legjobb 0 2 for i 1 to n 3 do felvételi beszélgetés az i edik jelölttel 4 if i edik jelölt jobb, mint a legjobb sorszámú 5 then legjobb i 6 i edik jelölt felvétele 1.2. Az algoritmus elemzése Az algoritmus elemzéséhez használjuk a már korábban bevezetett c j és c f költségeket. Figyeljük meg, hogy a végső költség megállapításánál az egyes műveletek végrehajtásának a száma a mérvadó. Mivel minden jelölttel el kell beszélgetnünk, hogy el tudjuk dönteni, ki a legalkalmasabb, így az elbeszélgetés c j költségét n szer kell megfizetnünk (ez nagyságrendben Θ(nc j )) és ezt nem tudjuk sehogyan sem elkerülni függetlenül attól, végül hány embert alkalmazunk, így ez mindig állandó lesz. Fontosabb most számunkra a lehetséges jelentkezők munkábaállításának költségigénye, amit korábban c f el jelöltünk. Számunkra m jelölt tényleges felvétele esetén az algoritmus Θ(nc j + mc f ) összköltségéből az mc f tag lesz érdekesebb. Mikor következik be számunkra a legrosszabb eset? Ha az állásközvetítő cég a jelölteket az alkalmasságuk szerinti növekvő sorrendben küldi hozzánk, akkor ez esetben mindegyik jelöltet fel fogjuk venni, ennek a költsége pedig Θ(nc f ) lesz ennyi tehát a legkedvezőtlenebb eset költségigénye. Nincs okunk azonban azt feltételezni, hogy a jelöltek pont ebben a sorrendben érkeznek hozzánk, és ezt befolyásolni sem tudjuk, ezért célszerű lenne az átlagos esetet kiszámítani, ehhez hívjuk segítségül a valószínűségi elemzést. Ennek során valószínűségi módszereket alkalmazunk a probléma vizsgálatára, jelen esetben a Munkatársfelvétel eljárás várható költségének maghatározására. Csak akkor alkalmazhatunk valószínűségi elemzést, ha van valami sejtésünk a bemeneti adatok eloszlásáról, vagy még jobb, ha ismerjük azt. Így az algoritmus várható futási ideje vagy költsége a bemeneti adatok eloszlása felett értendő lényegében a futási időt átlagoljuk az összes lehetséges bemenetre. Esetünkben tegyük fel, hogy a jelölteket alkalmasságuk szerint sorba tudjuk rendezni nevezzük ezt rangnak. Minden jelölt kap egy 1 és n közti egyedi számot, az i edik jelölt rangsor szerinti sorrendjét jelölje rang(i). Minél alkalmasabb egy jelölt, annál nagyobb a rangja, valamint az rang(1), rang(2),..., rang(n) lista az 1, 2,..., n lista egy permutációja. Feltehetjük, hogy a bemeneti rangok listája egyenletes eloszlású véletlen permutáció, vagyis az összes n! permutáció azonos valószínűséggel fordulhat elő. Az elemzéshez szükségünk lesz egy valószínűségszámításbeli fogalomra, illetve lemmára. 7

8 Definíció. Tekintsünk egy A eseményt az S eseménytérben. Ekkor az A eseményhez tartozó I{A} indikátor valószínűségi változó a következő: I{A} = { 1, ha az A esemény bekövetkezik 0, ha az A esemény nem következik be Lemma. Legyen A egy esemény az S eseménytérben, és legyen X A = I{A} az A esemény indikátora. Ekkor a várható értéke E[X A ] = P (A). Most pedig szeretnénk meghatározni, hogy várhatóan hányszor veszünk fel új jelöltet, ezt jelölje X. Vezessünk be n számú valószínűségi indikátorváltozót. Az X i indikátorváltozó tartozzon ahhoz az eseményhez, hogy felvettük az i edik jelöltet. Ekkor { 1, ha az i edik jelöltet felvettük X i = I{az i edik jelöltet felvettük} = 0, ha az i edik jelöltet nem vettük fel, és X = X 1 + X X n. Az lemma miatt E[X i ] = P {az i edik jelöltet felvettük}, így annak a valószínűségét kell meghatároznunk, hogy az algoritmusban a felvételnek megfelelő művelet végrehajtódik az eljárás során. Az 5. sorban az i edik jelöltet akkor vesszük fel, ha jobb az előtte lévő i 1 jelöltnél. Mivel feltettük, hogy a jelöltek véletlen sorrendben érkeznek, így az első i jelölt sorrendje is véletlen, és ezek közül bármelyik lehet a legjobb, azonos 1 i valószínűséggel. Tehát 1 i annak a valószínűsége, hogy az i edik jelölt jobb az első i 1 jelöltnél, így fel is vesszük. Az lemma alapján így E[X i ] = 1 i. Ezek alapján E[X] a következő módon határozható meg: [ n ] E[X] = E X i = = i=1 n E [X i ] i=1 n i=1 1 i = ln n + Θ(1), (1.1) 8

9 ahol a második sor a várható érték linearitásából következik, a harmadik az 1.2 egyenletből, a legutolsó pedig egy későbbi fejezetben kimondott állításból. Ezek alapján megfogalmazható a következő lemma: Lemma. Ha a jelöltek véletlen sorrendben érkeznek, akkor a Munkatársfelvétel eljárásban a jelöltek felvételének teljes költsége Θ(c f ln n) Megjegyzés. A Munkatársfelvétel probléma tulajdonképpen a maximum kiválasztás egy lehetséges modellje, amikor is a maximális elemet (esetünkben a legalkalmasabb jelöltet) nyilvántartjuk az eljárás során. Szokás még az eljárás költségét háztetőkkel szemléltetni: képzeljük el, hogy különböző magasságú házak állnak sorban mellettünk. Ha a legelső ház magasságából tekintjük őket, akkor azon háztetők száma, amiket látunk, azon jelöltek számát jelenti, akiket alkalmazni fogunk, ez pedig pont az eljárás költsége Az algoritmus véletlenített változata Előzőleg láttuk, hogy az algoritmus valószínűségi elemzéséhez információkkal kellett rendelkeznünk a bemeneti adatok eloszlásáról. Feltettük, hogy a bemeneti adatok eloszlása egyenletes eloszlású véletlen permutáció. Azonban azt, hogy helyes feltételezéssel éltünk az eloszlással kapcsolatban, nem igazán tudjuk alátámasztani, ugyanis semmilyen információnk nincs arról, hogy az ügynökség mi alapján küldi hozzánk a jelölteket. Elképzelhető, hogy a következő jelölt kiválasztása csupán a véletlentől függ, azonban erről nem tudunk megbizonyosodni. Szeretnénk viszont, hogy az eljárás költsége ne függjön ilyen tényezőktől, hanem várhatóan minél inkább közelebb legyen az átlagos esetben kiszámolt költséghez ehhez lehet hatékony eszközünk a randomizálás. A bemenő adatok sorrendjét véletlenítjük a feldolgozás előtt Definíció. Egy algoritmust véletlenített algoritmusnak nevezünk, ha a viselkedését, lépéseit nemcsak a bemenet határozza meg, hanem egy véletlenszám generátor által előállított értékek is. Az eljárásunkban a randomizálás a jelöltek véletlenszerű permutálásával történik majd. Hogy mindez hogyan néz ki a gyakorlatban, arra a következő fejezetben térünk ki. Tegyük fel, hogy az n számú jelölt listáját előzetesen megkapjuk az ügynökségtől. Most azonban nem bízunk a véletlenszerű sorrendjükben, hanem mi magunk gondoskodunk róla: az algoritmus annyiban változik, hogy a kapott listát előzetesen permutáljuk ezzel biztosítva az egyenletes véletlen eloszlást, majd a továbbiakban ugyanúgy járunk el, mint ahogy korábban. 9

10 Véletlenített Munkatársfelvétel(n) 1 a jelöltek listájának véletlen permutálása 2 legjobb 0 3 for i 1 to n 4 do felvételi beszélgetés az i edik jelölttel 5 if i edik jelölt jobb, mint a legjobb sorszámú 6 then legjobb i 7 i edik jelölt felvétele Látható, hogy ez az eljárás nem determinisztikus: egyazon bemenetre nem feltétlenül produkálja ugyanazt a lefutást (így a költséget sem), hiszen előzetesen a véletlennek is befolyása van. A randomizálás következtében, akármilyen rossz vagy jó bemenetet kapunk valamilyen forrásból, mindig az átlagos viselkedésre számíthatunk, nem pedig a legrosszabbra, vagy legjobbra. Ráadásul mindezt úgy, hogy közben semmilyen feltételezésre nincsen szükségünk. Ezt támasztja alá a következő állítás, Lemma. A Véletlenített Munkatársfelvétel eljárás futása során a felvételi költség várható értéke Θ(c f ln n). A lemma annak a következménye, hogy a permutálás utáni állapot pontosan megegyezik a már korábban elemzett Munkatársfelvétel eljárás bemeneti feltételével. 10

11 1.4. A munkatársfelvétel programja A munkatársfelvétel algoritmusát implementáltam Python nyelven. Nagyon megtetszett ez a programozási nyelv, elsősorban azért, mert rövid idő alatt el lehet jutni olyan szintre, amelyen egy egyszerűbb algoritmus kódját meg lehet írni. Az is tetszik a nyelvben, hogy esztétikus, jól olvasható, szinte megegyezik a pszeudokóddal. Ezért is tértem el dolgozatomban a kommentek elhelyezésének konvenciójától. A program, amelynek szemléletére a "látható házak száma elnevezés utal, a 1.2 ábrán szerepel, futási eredményét pedig azt megelőzően a 1.1 ábrán adtam meg. A program 10 x véletlen, n = 32 hosszú sorozaton meghatározza a relatív maximumok számát és ezek átlagát, valamint eltérésüket az Euler-Masceroni konstanstól, és ezeket az értékeket kiírja ábra. A látható házak száma program futási eredménye 11

12 1.2. ábra. A látható házak számának programja 12

13 2. fejezet Véletlen permutációk előállítása Az előző fejezetben ismertetett munkatársfelvételi problémára megadtunk egy randomizált algoritmust, amelynek kulcslépése a bemeneti adatok véletlenszerű permutálása volt. Most ennek a lépésnek nézzük meg néhány lehetséges megvalósítását, keressük tehát az 1, 2,..., n elemek egy véletlen permutációját Megjegyzés. Több algoritmus esetében is szükségünk lehet a bemeneti adatok permutációinak előállítására. Ismeretes az a tény, hogy egy mai 32-bites számítógépen a 13! = már nem ábrázolható egész számként, hiszen kettes számrendszerben felírva már több, mint 32 jegyű. Ezzel a reprezentáció-váltással éppen egybeesik az a mai általánosan tapasztalható sebességkorlát, hogy 12! = adatra még helyben kivárható egy program futása, de a 13! ra már nem. Nem reális tehát egy algoritmust n = 12 nél nagyobb méretű inputra futtatni, így szükségünk lehet arra, hogy az összes permutáció helyett csak bizonyos, véletlenszerűen előállított permutációkra teszteljük az algoritmust Permutálás rendezéssel Legyen az 1, 2,..., n számok az A[1..n] tömb elemei. Rendeljünk hozzá minden tömbelemhez egy véletlenszerű P [i] prioritást az [1, n 3 ] intervallumból (azért van szükségünk ekkora intervallumra, hogy minél nagyobb valószínűséggel különböző prioritásokat kapjunk), majd rendezzük a tömböt ezek szerint növekvő sorrendbe. Permutálás Rendezéssel(A) 1 n hossz[a] 2 for i 1 to n 3 do P [i] = Véletlen(1, n 3 ) 4 rendezzük az A tömböt P szerint 5 return A 13

14 Példa: Tegyük fel, hogy az algoritmus az A = 1, 2, 3, 4 tömbhöz a P = 13, 8, 51, 34 véletlen prioritásokat rendeli hozzá. Az algoritmus outputja ebben az esetben az A = 2, 1, 4, 3 véletlen permutáció Lemma. A Permutálás Rendezéssel eljárás egyenletes eloszlású véletlen permutációt ad, ha a prioritások mind különbözőek. Bizonyítás: Először is megmutatjuk, hogy az a permutáció, amelyben minden A[i] elem az i edik legkisebb prioritást kapja, 1/n! valószínűséggel áll elő. Jelölje X i azt az eseményt, hogy az A[i] elem kapja az i edik legkisebb prioritást n re. Így tehát szeretnénk azt meghatározni, hogy az összes X i esemény (i = 1,..., n) esemény egyszerre következik be. P (X 1 X 2... X n 1 X n ) = = P (X 1 ) P (X 2 X 1 ) P (X 3 X 1 X 2 )... P (X n X n 1... X 1 ). Azt tudjuk, hogy P (X 1 ) = 1/n, hiszen ez annak a valószínűsége, hogy n prioritásból pont az első lesz a legkisebb. Továbbá P (X 2 X 1 ) = 1/n 1, ugyanis ha A[1] prioritása a legkisebb, akkor a maradék n 1 prioritás közül bármelyik lehet azonos valószínűséggel a második legkisebb. Általánosan tehát i re: P (X i X i 1... X 1 ) = 1 n i + 1, hiszen ha az első i 1 elem kapta az első i 1 prioritást, akkor a maradék n i+1 elem bármelyike azonos valószínűséggel kaphatja az i edik legkisebb prioritást. Ebből következően: P (X 1 X 2... X n 1 X n ) = ( ) ( ) 1 1 n n 1 ( 1 2 ) ( ) 1 = 1 1 n!, így ezzel megmutattuk, hogy az eljárás 1/n! valószínűséggel állítja elő az identitás permutációt. Módosítsuk kissé a fenti bizonyítást, hogy tetszőleges permutációra alkalmazható legyen. Legyen σ = σ(1), σ(2),..., σ(n) az {1,2,...,n} halmaz egy rögzített permutációja. Jelöljük r i vel az A[i] elemhez rendelt prioritás rangsor szerinti sorszámát az összes prioritás között, vagyis ha A[i] prioritása az összes prioritás közül a j edik legkisebb, akkor legyen r i értéke j. Ha X i vel jelöljük azt az eseményt, hogy az A[i] elem éppen a σ(i) edik legkisebb prioritást kapja (vagyis r i = σ(i)), akkor a bizonyítás módosítás nélkül végigvihető. Vagyis ha egy adott σ permutáció valószínűségét akarjuk kiszámolni, akkor a fenti számolást kell megismételnünk, így ennek a permutációnak a valószínűségére is 1/n! adódik. 14

15 2.2. Permutálás cserékkel A rendezéssel történő permutálásnál jobb módszer a cserékkel való permutálás egy véletlen sorrend előállítására. Egy olyan eljárásról lesz szó, amely Θ(n) időben állít elő egy véletlen permutációt az elemek egy bizonyos szabály szerinti cserélgetésével, ráadásul mindezt úgy, hogy közben csak arra a memóriára van szüksége, amit a tömb tárolására használ. Induljunk ki az identitás permutációból. Az algoritmus lényege abban rejlik, hogy az i edik iterációban az A[i] tömbelemet kicseréljük az A[i], A[i + 1],..., A[n] elemek közül véletlenszerűen választott elemmel, majd a további lépésekben az A[i] elemhez már nem nyúlunk. Az algoritmusban szereplő Véletlen(a, b) eljárás generál egy a és b közötti egész számot (velük bezárólag). Permutálás Cserékkel(A) 1 n hossz[a] 2 for i 1 to n 3 do cseréljük meg az A[i] és az A[Véletlen(i, n)] elemeket Lemma. A Permutáció Cserékkel eljárás egy egyenletes eloszlású véletlen permutációt állít elő. Bizonyítás: Elevenítsük fel először azt, hogy adott n elem k ad osztályú permutációja alatt az elemeknek egy olyan rendezett, k hosszú sorozatát értjük, amelyben minden elem legfeljebb egyszer fordul elő. Tudjuk, hogy n elemnek n!/(n k)! különböző k ad osztályú permutációja van. A lemma bizonyítására egy ciklusinvariáns feltételt fogunk használni: A 2 3. sorokban lévő for ciklus i edik iterációja előtt minden lehetséges (i 1) ed osztályú permutáció pontosan (n i + 1)!/n! valószínűséggel áll elő az A[1..i 1] résztömbben. Először ellenőrizzük, hogy a feltétel teljesül az első iteráció előtt, majd igazoljuk, hogy minden iteráció után továbbra is érvényben marad. Végül a ciklus befejeződésekor az invariáns feltétel segítségével igazolhatjuk az algoritmus helyességét. Tekintsük az első iteráció előtti helyzetet, akkor i értéke 1. A ciklusinvariáns feltétel azt állítja, hogy minden lehetséges 0 ad osztályú permutáció (n i+1)!/n! = n!/n! = 1 valószínűséggel áll elő az A[1..0] résztömbben, ami egy üres tömb, és a 0 ad osztályú permutáció nem tartalmaz elemeket. Vagyis az A[1..0] résztömb minden 0 ad osztályú permutációt 1 valószínűséggel tartalmaz, tehát a ciklusinvariáns feltétel teljesül az első iteráció előtt. Tegyük fel, hogy a ciklus i edik iterációja előtt minden lehetséges (i 1) ed osztályú permutáció pontosan (n i + 1)!/n! valószínűséggel áll elő az A[1..i 1] résztömbben. Azt kell megmutatnunk, hogy a ciklus i edik iterációja után minden lehetséges i ed osztályú permutáció pontosan (n i)!/n! valószínűséggel áll elő az A[1..i] 15

16 résztömbben. Ha ez teljesül, akkor i értékének a növelése után a következő iterációban is teljesülni fog az invariáns feltétel. Ehhez tekintsük az i edik iterációt. Rögzítsünk egy tetszőleges i edrendű permutációt, az elemeit jelölje x 1, x 2,..., x i. A permutációt úgy is tekinthetjük, mint az (i 1) ed osztályú x 1,..., x i 1 permutáció, amit még egy x i elem követ. Legyen E 1 az az esemény, hogy az első (i 1) iteráció után az A[1..i 1] résztömbben pont az x 1,..., x i 1 (i 1) edrendű permutáció állt elő. A ciklusinvariáns feltétel miatt P (E 1 ) = (n i + 1)!/n! teljesül. Legyen E 2 az az esemény, hogy az i edik iteráció az x i elemet helyezi az A[i] helyre. Az A[1..i] résztömbben pontosan akkor áll elő az x 1, x 2,..., x i i ed osztályú permutáció, ha E 1 és E 2 is bekövetkezik, vagyis P (E 2 E 1 ) értékére van szükségünk. Ez pedig a definícióból: P (E 2 E 1 ) = P (E 2 E 1 ) P (E 1 ). A P (E 2 E 1 ) valószínűség értéke 1/(n i + 1), mivel az algoritmus 3. sora az A[i..n] résztömb n i + 1 eleme közül véletlenszerűen választja ki az A[i] helyre kerülőt. Ezért P (E 2 E 1 ) = P (E 2 E 1 ) P (E 1 ) 1 (n i + 1)! = n i + 1 n! (n i)! =. n! Az eljárás befejeződésekor i = n+1, így a ciklusinvariáns feltétel alapján minden n ed osztályú permutáció pontosan (n n)!/n! = 1/n! valószínűséggel áll elő az A[1..n] tömbben, tehát igazoltuk a lemmát, miszerint minden permutáció azonos valószínűséggel áll elő Megjegyzés. A cserékkel való véletlen permutáció előállításának algoritmusát először Ronald Fisher és Frank Yates dokumentálta, az általuk megadott algoritmus még papíron való levezetésre volt szánva, és Fisher Yates algoritmusként terjedt el. Később Richard Durstenfeld bevezette a modern, már számítógépre szánt változatot, amelyet Donald E. Knuth népszerűsített, így az algoritmus egyik legelterjedtebb megnevezése a Knuth Shuffle lett. Többfajta ekvivalens leírása is létezik, melyek lényegüket tekintve megegyeznek. A Python nyelv beépített eljárásként ezt az algoritmust használja egy sorozat (lista) véletlen permutációjának előállítására. A Munkatársfelvétel probléma feldolgozásában, illetve a véletlen permutációk előállításában az [3, 95. oldal] könyv és a [8] cikk volt a segítségemre. 16

17 3. fejezet Gyorsrendezés (Quicksort) A random algoritmusok közül talán éppen a gyorsrendezés a legismertebb. A gondos számítógépes implementációk és összehasonlítások azt mutatják, hogy a gyorsrendezés a mai napig talált leghatékonyabb eljárás: elég nagy méretű inputra várhatóan gyorsabban fut le, mint a többi ismert rendező eljárás. Egy ilyen megállapítás mindig nagyszámú összehasonlításon alapul, tehát várható értékben értendő. Ez a megközelítés a gyorsrendezés esetében szükséges is, hiszen a teljesítménye függ a bemenő adatok sorrendjétől. Az alkalmazott véletlenítés célja éppen az, hogy a kedvezőtlen input permutáció megvalósulásának esélyét egyenlővé tegyük az egyenletes eloszlásnak megfelelően bármely más sorrend valószínűségével A gyorsrendezés algoritmusa Feladat: Adva van egy (a 1, a 2,..., a n ) számsorozatunk. Tegyük fel, hogy az elemek mind különbözőek. Ezt a sorozatot szeretnénk növekvő sorrendbe rendezni, vagyis keressük az elemeknek egy (a 1, a 2,..., a n) permutációját, amire teljesül: a 1 < a 2 <... < a n. A probléma megoldására többféle rendező algoritmus is létezik, ebben a részben a gyorsrendezés véletlenített változatáról lesz szó, ami egy összehasonlítás alapú rendező algoritmus és a gyakorlatban az egyik leghatékonyabb rendező-algoritmusnak bizonyult. Legyen A[m..n] az a tömb, ami a rendezendő számsorozatunkat tartalmazza, ez lesz az algoritmus inputja. A módszer lényege egy véletlen-szám generálás, ennek alapján a tömb felosztása, illetve a résztömbökre alkalmazott rekurzív hívás. Az algoritmus akkor ér véget, ha az adott lépésben kialakult résztömbök már egyeleműek, hiszen akkor már nincs mit rendezni, mi pedig outputként visszakapjuk a rendezett sorozatot. 17

18 VéletlenítettGyorsrendezés (A, m, n) 1 if m < n 2 then q Véletlen-feloszt (A, m, n) 3 VéletlenítettGyorsrendezés (A, m, q 1) 4 VéletlenítettGyorsrendezés (A, q + 1, n) Véletlen-feloszt (A, m, n) 1 l Véletlen (m, n) 2 A[l] A[n] csere 3 x A[n] 4 i m 1 5 for j m to n 1 6 do if A[j] < x 7 then i i A[i] A[j] csere 9 A[i + 1] A[n] csere 10 return i ábra. Véletlen-feloszt eljárás működése: A tömböt helyben átrendezi a kitüntetett x elem szerint. A VéletlenítettGyorsrendezés algoritmusa az inputként kapott A tömb egy résztömbjét rendezi (A[m..n]), így ha az egész tömböt szeretnénk növekvő sorrendbe rendezni, akkor a következőféleképpen kell meghívnunk: VéletlenítettGyorsrendezés (A,1,hossz[A]). Az egész eljárás lényegében a Véletlen-feloszt eljáráson alapszik, ami a tömböt két részre osztja, mégpedig úgy, hogy véletlenszerűen választ egy elemet a tömbből, legyen ez az x őrszem, amely alapján csoportosítja a maradék elemeket. Technikai okokból kicseréli először a tömb legutolsó elemét x-szel, majd helyben átrendezi az előtte lévőket: for ciklussal végigmegy rajtuk, és megvizsgálja a következő feltételt: A[j] < x. Amennyiben ez igaz, végrehajtja a megfelelő a cserét. Az 3.1 ábra a felosztás egy köztes állapotát mutatja: az x őrszemnél kisebb elemeket a nála nagyobbak követik, végül pedig azok, amelyeket még nem vizsgált meg. 18

19 Ha végigért az elemeken, a kitüntetett elemet a helyére viszi, majd visszaadja annak indexét. A VéletlenítettGyorsrendezés rekurzív: az index alapján az eredeti tömbre két résztömbként tekintünk, amikre külön külön meghívjuk az algoritmust Az algoritmus futási ideje Az algoritmusok elemzésének egyik legfontosabb szempontja a felhasznált tárhelyen túl a futási idő vagy költség, erről lesz most szó. Érdemes sokszor az algoritmusnak a költségét egy kedvezőtlen és egy kedvező inputra vizsgálni, illetve ennek alapján a legrosszabb és legjobb esetet elemezni, majd a várható (átlagos) futási időt megállapítani. A VéletlenítettGyorsrendezés egy összehasonlítás alapú rendező algoritmus, így kézenfekvő a költséget az összehasonlítások száma alapján megállapítani jelöljük ezt T (n)-nel, ezt pedig a felosztás határozza meg: attól függően érhetjük el a legrosszabb vagy legjobb viselkedést, hogy az algoritmus a tömbnek melyik elemét sorsolja ki, ami alapján aztán azt felosztja. Nézzük először a legrosszabb esetet: tegyük fel, hogy a véletlenül sorsolt x őrszem a tömb legnagyobb eleme (a legkisebb elem választása esetén is analóg módon vezethető le), amit összehasonlít a többi n 1 elemmel, ez nyilvánvalóan n 1 összehasonlítás. Ezek után kialakul egy 0 és egy n 1 elemű résztömb, ez utóbbira szintén végrehajtjuk az algoritmust. Újfent tegyük fel, hogy ennek a résztömbnek is a legnagyobb elemét sorsolja ki őrszemnek, ekkor n 2 összehasonlítást végez, majd felosztja egy 0 és egy n 2 elemű résztömbre, amiben az összehasonlítások száma n 3, és így tovább. Ezek alapján azt feltételezve, hogy minden egyes híváskor az őrszem a lehető legkedvezőtlenebb elem lesz, megállapíthatjuk, hogy az algoritmus költsége a legrosszabb esetben: (n 1) + (n 2) = n(n 1) 2 = Θ(n 2 ) = T (n). Nézzük meg most a legjobb felosztást a legkedvezőbb futási idővel. Az előbbi tapasztalataink szerint a legrosszabb viselkedést a legkevésbé kiegyensúlyozott felosztással tudtuk elérni. Most tegyük fel, hogy a Véletlen-feloszt eljárás a tömböt nagyjából két egyenlő részre osztja fel, tehát általánosan egy n/2 és egy n/2 1 méretűre. Mint már korábban említettük, az eljárás rekurzív, így nézzük meg a legjobb felosztás futási idejének elemzéséhez azt a rekurziós fát, ami abban az esetben alakul ki, amikor a felosztás minden hívásnál a legkiegyensúlyozottabban történik. 19

20 3.2. ábra. A rekurziós fa azt az esetet szemlélteti, mikor a felosztás a legkiegyensúlyozottabb: az újjonan kialakult résztömbök hossza, amelyekre rendre meghívjuk az algoritmust, minden lépés után feleződik. A rekurziós fa az 3.2 ábrán látható. Figyeljük meg, hogy a felosztás költségigénye minden szinten n, illetve a fa magassága lg n(= log 2 n), így a legjobb eset futási ideje: T (n) = Θ(n lg n). Most azonban nem a legrosszabb, vagy a legjobb esetre vagyunk kíváncsiak, hanem szeretnénk meghatározni az algoritmus várható futási idejét. Azt már megállapítottuk, hogy a Véletlen-feloszt eljárás a kulcs. Ez az eljárás az algoritmus során legfeljebb n-szer hívódik meg (n hosszú bemenet esetén). Elemezzük azt, hogy ennek az eljárásnak az összes hívásában mennyi az összehasonlítások száma, jelöljük ezt X-szel, erre szeretnénk egy felső korlátot adni. Ahhoz, hogy X várható értékét meghatározzuk, szükségünk van annak vizsgálatára, hogy az algoritmus mikor hasonlít össze két elemet. Technikai okokból bevezetjük a következő jelöléseket: jelölje az A tömb elemeit y 1, y 2,..., y n, ahol y i az i-edik legkisebb elem, illetve értelmezzük az Y i,j halmazt, amely tartalmazza az y i és y j közötti elemeket, saját magukat is beleértve, vagyis Y i,j = {y i, y i+1,..., y j 1, y j }. Észrevehetjük, hogy az algoritmus során bármely két elemet egyetlen egyszer hasonlítunk össze, mégpedig akkor, mikor az egyiket őrszemnek választjuk, hiszen ezután az őrszemet már nem használjuk többször. Legyen X ij indikátorváltozó, vagyis { 1 ha yi -t és y X ij = j -t összehasonlítottuk 0 egyébként. 20

21 Az összehasonlítás az algoritmus teljes lefutására vonatkozik, nem csak a Véletlenfeloszt eljárás egy hívására. Mivel minden számpárt legfeljebb egyszer hasonlítunk össze, az összes összehasonlítás számát a következőféleképpen írhatjuk fel: X = n 1 n i=1 j=i+1 Vegyük most mindkét oldal várható értékét. Ennek a kiszámításához szükségünk lesz az lemmára, illetve később egy állításra: Definíció. Legyen n egy pozitív egész szám. Az n-edik harmonikus számot a következőképpen definiáljuk: X ij. H n = n = n k=1 1 k Állítás. Az n-edik harmonikus szám nagyságrendi becslése a következő: H n = n k=1 1 k = lg n + Θ(1). Az lemmát és a várható érték linearitását kihasználva levezethetjük a következőt: E[X] = E = = n 1 [ n 1 n i=1 j=i+1 n i=1 j=i+1 n 1 n i=1 j=i+1 X ij ] E [X ij ] P (y i összehasonlítása y j vel). (3.1) Most már csak a valószínűség kiszámításával kell boldogulnunk. Nézzük meg azt, hogy milyen esetekben nem hasonlítunk össze két elemet. Tegyük fel, hogy a bemenet az 1 és 10 közötti számokat tartalmazza, és a véletlenül kiválasztott őrszem a 3. Ekkor a Véletlen-feloszt eljárás a bemenetet két részre osztja úgy, hogy minden elemet összehasonlít az őrszemnek kisorsolt 3-mal. A két résztömb: {2,1} és {6,4,5,7,8,10,9}. Vegyük észre, hogy az első résztömb egyetlen elemét sem hasonlítja össze közben a második résztömb egyetlen elemével sem. Általánosan tehát ha az x őrszemet úgy választjuk, hogy y i < x < y j, akkor y i és y j többet nem kerül összehasonlításra. Viszont ha az y i elemet választjuk őrszemnek az Y ij halmaz bármelyik eleme előtt, akkor y i -t összehasonlítjuk a halmaz minden 21

22 elemével, saját magát leszámítva. A mi példánkban tehát az első őrszem a 3, így a 3-at és a 7-et összehasonlítjuk, mivel a 3 az első elem az Y 3,7 -ből, viszont a 2-őt és a 7-et soha nem hasonlítjuk össze, mert az Y 2,7 -ben az első őrszem a 3. Vagyis y i és y j csak abban az esetben kerül összehasonlításra, ha az első őrszem a Y i,j halmazból y i vagy y j, mi pedig ennek a valószínűségét keressük. Fontos megjegyeznünk, hogy őrszemválasztáskor az Y i,j halmaz minden eleme egyformán valószínű, és mivel a halmaznak j i + 1 eleme van, valamint az őrszemeket függetlenül választjuk, annak a valószínűsége, hogy egy elem őrszem legyen 1/(j - i + 1). Tehát: P (y i összehasonlítása y j -vel) = P (y i vagy y j az első őrszem Y i,j -ből) = P (y i az első őrszem Y i,j -ből) + P (y j az első őrszem Y i,j -ből) 1 = j i j i = j i + 1 (3.2) Vagyis 3.1 és 3.2 alapján: E[X] = n 1 n i=1 j=i+1 2 j i + 1. Vezessünk be új változót (k = j i), majd felhasználva az állítást: E[X] = n 1 n i=1 j=i+1 i=1 k=1 2 j i + 1 n 1 n i 2 E[X] = k + 1 n 1 n i 2 < E[X] = k i=1 k=1 n 1 = Θ(lg n) = Θ(n lg n). i=1 Láthattuk tehát, hogy a költség várható értékének a felső becslése megegyezik a legjobb eset költségével. A fenti levezetéssel a következő tételt igazoltuk: Tétel. A VéletlenítettGyorsrendezés várható futási ideje feltéve, hogy az elemek különbözőek Θ(n lg n). 22

23 Valójában egy ennél erősebb állítás is igazolható: Állítás. A VéletlenítettGyorsrendezés várható összehasonlításainak száma AÖ (n) 1.39n lg n Megjegyzés. A bizonyítás kulcsgondolata a véletlen építésű bináris keresőfa felépítésének várható költségén alapul. A bináris keresőfa felépítése az algoritmusunkhoz hasonló módon történik: a véletlenszerűen választott őrszem kerül a gyökércsúcsba, majd tőle balra helyezzük el a fában a nála kisebb, jobbra pedig a nála nagyobb elemeket. Jelöljük f(n) el az összehasonlítások várható számát. Ez nem más, mint az n pontot tartalmazó bináris fák átlagos csúcsmagasság összege, vagyis az 1, 2,..., n számok összes permutációjából bináris keresőfát építünk, kiszámoljuk a csúcsok magasság összegét, majd mivel minden permutáció valószínűsége 1/n! elosztjuk n! sal, ezzel átlagolva a kapott értéket. Bizonyítás: Mi valójában az f(n) érték egy felső becslésére vagyunk kíváncsiak. Ha az őrszemnek választott elem a k adik a sorban, akkor a partícionáló eljárás után az A[k] helyre kerül, és egy k 1, illetve egy n k résztömböt kell tovább rendezni, ezt az esetet jelöljük (n k) val. Az átlagos összehasonlítás számot úgy kapjuk meg, hogyha a k = 1, 2,..., n eseteket mind 1/n valószínűséggel vesszük figyelembe, vagyis f(n) = 1 n n f(n k). k=1 Egy adott k értékre a következő adódik: f(n k) = n 1 + f(k 1) + f(n k), ahol az összeg első tagja az elemek összehasonlítása az első kitüntetett elemmel, a második két tag pedig a rekurzív hívásból adódik. Ekkor: f(n) = 1 n n [(n 1) + f(k 1) + f(n k)] = k=1 = (n 1) + 1 n n [f(k 1) + f(n k)] = k=1 = (n 1) + 1 [f(0) + f(n 1) + f(1) + f(n 2) f(n 1) + f(0)], n mivel f(0) = 0, végül azt kapjuk, hogy f(n) = (n 1) + 2 n 1 f(k). n 23 k=2

24 Azt állítjuk, hogy ennek a rekurzív egyenletnek a megoldására f(n) 2n ln n (n 1) teljesül, ezt teljes indukcióval fogjuk belátni. Az n = 1 esetben f(1) = 0, ami nyilvánvaló, és erre teljesül a 2 ln 1 = 0. Tegyük fel, hogy az összefüggés teljesül 1, 2,..., (n 1) re, ekkor: f(n) = (n 1) + 2 n 1 f(k) (n 1) + 2 n 1 2k ln k = n n k=2 n 1 = (n 1) + 4 k ln k (n 1) + 4 n n k=2 = (n 1) + 4 ([ ] x 2 n ) ln x x2 n k=2 n 2 x ln xdx = = (n 1) + 4 n 2 n 4 [2 ln n 1] 4 (2 ln 2 1) n 2n ln n + (n 1) n 4 n 0.39 < 2n ln n = 2nlog 2 n log 2 e 1.39n log 2 n. Ezzel beláttuk a tétel állítását. Jogosan merülhet fel a kérdés, hogy a Gyorsrendezés algoritmusának miért a véletlenített változata hasznosabb a gyakorlatban. A még randomizálatlan változatban őrszemnek a tömb egy adott elemét szokás választani, pl. az elsőt. Ilyen esetben, egy számunkra kedvezőtlen inputon az algoritmus futási ideje nagyobb lesz, mint az átlagos várható futási idő. Ezt szeretnénk a véletlenítés eszközével befolyásolni. Mivel nem tudjuk garantálni, hogy a bemeneti számok minden permutációja egyformán valószínű legyen (pl. azért mert az adatok összegyűjtése gyakran mindig ugyanazt a szisztémát követi), így azt a randomizálást választjuk, hogy a tömb nem egy meghatározott, hanem egy véletlenül kiválasztott elemét jelöljük ki őrszemnek, amivel jobb átlagos viselkedést érhetünk el. A gyorsrendezés elemzése a [3, 141. oldal] könyv alapján készült A gyorsrendezés pogramja A gyorsrendezés programja is "önmagáért beszél", így a 3.4 ábrán látható kódban sem helyeztem el komment sorokat. Az előző 3.3 ábrán szereplő futási eredményen jól követhető a rekurzív algoritmus működése. 24

25 3.3. ábra. A gyorsrendezés egy végrehajtása 25

26 3.4. ábra. A gyorsrendezés programja. 26

27 4. fejezet A k adik elem kiválasztása Ebben a fejezetben egy olyan problémát vizsgálunk meg, amelynek első olvasásra nem sok köze van a gyorsrendezéshez, később azonban kiderül, hogy a véletlenítés egy olyan algoritmusra vezet, amelyet féloldali gyorsrendezésnek" is lehetne nevezni A k adik elem kiválasztása véletlenítéssel Feladat: Adott egy n elemű rendezetlen tömb, mi pedig szeretnénk a tömb nagyság szerinti k adik elemét meghatározni. Elsőként felmerülhet az az ötlet, hogy először valamilyen rendező algoritmussal rendezzük nagyság szerint növekvő sorrendbe az elemeket, majd könnyedén ki tudjak választani belőlük a k adikat. Azonban ha jobban belegondolunk, nincs szükségünk a tömb rendezésére, így az felesleges plusz költséget jelentene; elég lenne meghatározni a nála kisebb k 1 számú, illetve a nála nagyobb n k db elemet ahhoz, hogy egy konkrét elem esetében megbizonyosodjunk arról, hogy valóban a nagyság szerinti k adik. A feladatra adott véletlenített algoritmus pont ezen az elven működik majd. Először is vegyük alapul a Gyorsrendezésnél már megismert Véletlen feloszt eljárást, ami a tömböt egy véletlenszerűen választott elem szerint osztja ketté a nála kisebbek, illetve nagyobbak tömbjére. Ha a véletlenszerűen választott elem pont a k adik elem volt, akkor szerencsénk van. Ha azonban nem, akkor is könnyedén el tudjuk dönteni, hogy az eljárás rekurzív hívásával melyik résztömbben kell tovább keresnünk. k adikelem (k, A, m, n) 1 if m < n 2 then q Véletlen-feloszt (A, m, n) 3 if q = k 4 then return q 27

28 5 else if q < k then 6 return k adikelem(k q, A, q + 1, n) 7 else if q > k then 8 return k adikelem(k, A, m, q 1) Véletlen-feloszt (A, m, n) 1 l Véletlen (m, n) 2 A[l] A[n] csere 3 x A[n] 4 i m 1 5 for j m to n 1 6 do if A[j] < x 7 then i i A[i] A[j] csere 9 A[i + 1] A[n] csere 10 return i Az algoritmus elemzése Az eljárás költségének szempontjából a számunkra legkedvezőtlenebb eset akkor fordul elő, amennyiben a Véletlen feloszt eljárás a tömböt aránytalanul osztja fel, nevezetesen a véletlenszerűen kiválasztott elem a legnagyobb, vagy a legkisebb, hiszen a rekurzív hívásban ebben az esetben csak eggyel csökkent a tömb mérete, amiben tovább kell keresnünk, így pont mint a VéletlenítettGyorsrendezés esetében a költség Θ(n 2 ) lesz. A legjobb eset pedig nyilvánvaló, hiszen ha a kiválasztott elem pont a k adik volt, akkor a költség mindössze az n 1 db összehasonlítás, ami nagyságrendileg Θ(n). Az átlagos esetben felmerülő költségről, vagyis a várható összehasonlítások számáról a következő tétel igazolható: Tétel. Tetszőleges k [1..n] esetén a k adikelem eljárás végrehajtott összehasonlításainak várható számára: EÖ(n, k) 4n. Bizonyítás: Az egyszerűség kedvéért tegyük fel, hogy a tömb az 1, 2,..., n számok egy permutációját tartalmazza. Az állítást n re vonatkozó teljes indukcióval fogjuk belátni. Az n = 0, 1 esetben az állítás nyilvánvalóan igaz. Igazoljuk n 2 re, feltéve, hogy kisebb elemszámra már igaz. Vezessük meg a következő jelöléseket: f(n, k) =EÖ(n, k), f j (n, k) pedig legyen az összehasonlítások várható értéke olyan feltétel mellett, hogy a véletlenszerűen kiválasztott elem éppen j volt. Ennek a feltételnek a valószínűsége 1/n, hiszen minden elem egyformán valószínű. 28

29 Amennyiben j = k, akkor f j (n, k) = n 1. Ha j k, akkor a j nél kisebb, illetve j nél nagyobb elemek egymás közötti sorrendje is egyforma valószínűségű. Ezért k < j esetén az (n 1) még hozzáadódik f(j 1, k), míg k > j esetén f(n j, k j). Összefoglalva az alábbi összefüggést kapjuk a várható értékre: n 1 f j (n, k) = n 1 + f(j 1, k) n 1 + f(n j, k j) A teljes várhatóérték tétele alapján: ha j = k ha k < j ha k > j f(n, k) = 1 n n f j (n, k). j=1 Beírva ide f j (n, k) előbbi alakját, az esetszétválasztás és átrendezés után a következőt kapjuk: f(n, k) = (n 1) + 1 n n j=k+1 f j (j 1, k) + 1 k 1 f j (n j, k j). n Mind j 1, mind k j kisebb n nél, ezért ide beírhatjuk az indukciós feltétel szerinti becsléseket: f(n, k) (n 1) + 1 n n j=k+1 j=1 4(j 1) + 1 k 1 4(n j) = n j=1 = (n 1) + 1 n 1 4j + 1 k 1 4(n j) = (n 1) 4 n 1 j 4 k 1 j + 4 k 1 (n j) = n n n n n = (n 1) + 4 n j=k n(n 1) 2 j= + 4 k 1 (n 2j) = n j=1 = 3(n 1) + 4 2) + (n 2(k 1)) (k 1)(n = n 2 = 3(n 1) + 4 n (k 1)(n k) 3(n 1) + 4 ( ) 2 n 1 3n + 4 n 2 n 2 n 4 = 4n. Közben alkalmaztuk a számtani sorozatok összegképletét, illetve a számtani és mértani közép közötti egyenlőtlenséget. A fejezet megírásához a [9] forrásmunkát használtam fel. j=1 j=1 j=1 29

30 4.3. A k-adik elem kiválasztásának programja A k-adik elem kiválasztásának 4.2 ábrán látható programját minden lehetségen k értékre futtattam. A 4.1 ábrán szereplő kiírás a helyesen elvégzett kiválasztásokat mutatja ábra. A k adik elem kiválasztás programjának futása minden k értékre 30

31 4.2. ábra. A k adik elem kiválasztásának programja 31

32 5. fejezet Polinomazonosság ellenőrzése A következőkben egy algebrai feladatra, a polinomazonosságra fogunk véletlenített algoritmust adni A feladat és a megoldás elve Vezessük be először a következő fogalmakat: Definíció. Egyhatározatlanú polinomoknak nevezzük az olyan f(x) = a 0 + a 1 x + a 2 x a k x k formális kifejezéseket, ahol k 0 egész szám és a 0, a 1,..., a k komplex számok. Az x neve határozatlan, a i k pedig a polinom együtthatói. Tegyük fel, hogy a k 0, ez esetben k adfokú polinomról beszélünk. Ha az együtthatók racionálisak, racionális polinomokról beszélünk, amiknek a halmazát Q[x] el jelöljük Definíció. Az általánosság kedvéért beszélhetünk többhatározatlanú, vagy más néven többváltozós polinomokról is. Többváltozós polinomon olyan kifejezéseket értünk, amelyek az x 1, x 2,..., x n határozatlanokból és valamilyen együtthatókból épülnek fel összeadás, kivonás és szorzás segítségével. Példa egy négyváltozós, racionális együtthatós polinomra: f(x) = 2x 1 x 2 +3x 2 3 +x 3 x 5 4. Egy többváltozós polinom foka a benne szereplő tagok fokának maximuma, és egy tag foka a benne szereplő kitevők összege. A példaként megadott többváltozós polinom foka 6. A polinomok felírhatók egyváltozós esetben a k i=0 a ix i, többváltozós esetben pedig a r m1,m2,...,mn x m1 1 x m x mn n kanonikus alakban Állítás. Két polinom akkor és csak akkor egyenlő, ha a kanonikus alakjaikban az együtthatók megegyeznek. 32

33 Azonban a polinomok legtöbbször nem kanonikus alakban vannak megadva, hanem például egyváltozós esetben a k i=1 (x a i) szorzat alakban, így pedig nem magától értetődő az, hogy vajon egy szorzat alakban megadott polinom egyenlő-e egy pl. kanonikus alakban megadott polinommal. Megpróbálhatjuk a szorzat alakot kanonikus alakká transzformálni. Rendre szorozzuk be a szorzat i edik tényezőjét az első i 1 tényezővel. Az együtthatók szorzása azonban Θ(k 2 ) nagyságrendű. Feltételezzük, hogy minden szorzás végrehajtható konstans időben, habár ha az együtthatók szorzata túl gyorsan nő, akkor előfordulhat, hogy a számok összeadása és szorzása már nem megoldható konstans időben. Felmerül a kérdés, hogy vajon a szorzások eredménye helyes-e. Ezt azonban leginkább úgy tudnánk ellenőrizni, hogy még egy programot írunk az ellenőrzésre is, ez viszont feltehetően ugyanazt a módszert alkalmazná, amit előzőleg használtunk, így ezzel nem fogjuk tudni megállapítani az eredmény helyességét. Célszerű lenne ezért egy olyan algoritmust találni, ami nem ezekre az alappillérekre épít. Legyen F (x 1,..., x n ) és G(x 1,..., x n ) két n változós, racionális együtthatós polinom. A kérdés tehát, hogy a két polinom azonos-e, vagy ekvivalens megfogalmazásban, a polinomok különbsége az azonosan nulla polinom-e (minden együttható nulla): F? G H = F G? 0. Ennek eldöntésére alkalmazott algoritmus alapötlete az, hogy helyettesítsünk be véletlen eloszlás szerint, egymástól függetlenül választott számokat, és nézzük meg, hogy azokat a polinomokba behelyettesítve az eredmény egyenlő-e. Ha nem, akkor nyilván nem lehet a két polinom azonos, ha pedig igen, akkor azok. Látni fogjuk, hogy az algoritmus kellő számú megismétlése után annak az esélye, hogy az algoritmus mindannyiszor azt adja vissza, hogy a polinomok azonosak pedig nem így van nagyon csekély. A megoldás algoritmusa Legyenek ɛ i k (i = 1,..., n) a [0, 2k] intervallumból egyenletes eloszlás szerint véletlenszerűen és egymástól függetlenül választott egész számok. (Vagyis az intervallumban szereplő összes egész szám bármelyik ɛ i választásánál egyformán valószínű.) Helyettesítsük be őket H ba, vagyis vizsgáljuk meg H(ɛ 1,..., ɛ n ) értékét. Ha nem 0 értéket kapunk, megállunk, hiszen ekkor H nem az azonosan 0 polinom. Ha 0 értéket kapunk, megismételjük a számítást. Ha mindannyiszor egymás után 0 értéket kapunk, akkor azt mondjuk, hogy H azonosan 0. 33

34 5.2. Az algoritmus elemzése Előfordulhat, hogy az algoritmus nem a helyes választ adja vissza. Vizsgáljuk meg a különböző eseteket. Amennyiben H 0, akkor H(ɛ 1,..., ɛ n ) = 0 bármely ɛ = (ɛ 1,..., ɛ n ) ra, így az algoritmus a helyes választ fogja adni. Abban az esetben, ha H 0 és H(ɛ 1,..., ɛ n ) 0, akkor az algoritmus szintén helyes választ ad, hiszen talált egy olyan értéket, amire a polinom nem azonosan 0. (Így tehát abban az esetben, ha nemleges választ kapunk, akkor az mindig helyes.) Ellenben, ha H 0, viszont H(ɛ 1,..., ɛ n ) = 0, akkor rossz választ kapunk, hiszen ebben az esetben megtaláltuk a nem azonosan 0 polinom egy gyökét. Azt, hogy legfeljebb mekkora a hiba valószínűsége, a következő a gyakorlatban sokat használt lemma mondja ki: Lemma. (Schwartz Zippel lemma) Ha H nem azonosan 0, n változós, legfeljebb k adfokú polinom, és az ɛ i i = (1,..., n) értékek a [0, N 1] intervallumból egyenletes eloszlás szerint véletlenszerűen és egymástól függetlenül választott egész számok, akkor P (H(ɛ 1,..., ɛ n ) = 0) k N. A bizonyításban alkalmazzuk a következő definíciót, illetve állítást: Definíció. Egy A esemény B eseményre vett feltételes valószínűségét a következőképpen definiáljuk: P (A B) P (A B) =. P (B) Állítás. Egy A esemény valószínűsége legfeljebb: P (A) P (A B)P (B) + P (A B)P (B). (5.1) Bizonyítás: Az állítást n szerinti teljes indukcióval bizonyítjuk. Az állítás n = 1 re nyilván igaz, hiszen az algebra alaptételéből tudjuk, hogy egy k adfokú polinomnak legfeljebb k db különböző gyöke lehet, ami számunkra a kedvező eseteket jelenti az összes lehetséges N esetből, így a keresett valószínűség P (H(ɛ)) k. Most tegyük N fel, hogy az állítás igaz n 1 változós polinomra, bizonyítsuk n változósra. Legyen tehát n > 1, és rendezzük H t x 1 hatványai szerint: H = H 0 + H 1 x 1 + H 2 x H t x t 1, 34

35 ahol H 0,..., H t az x 2,..., x n változók polinomjai, H t nem azonosan 0, és t k. Mármost P (H(ɛ 1,..., ɛ n ) = 0) = P (H(ɛ 1,..., ɛ n ) = 0 H(ɛ 2,..., ɛ n ) = 0) P (H(ɛ 2,..., ɛ n ) = 0)+ + P (H(ɛ 1,..., ɛ n ) = 0 H(ɛ 2,..., ɛ n ) 0) P (H(ɛ 2,..., ɛ n ) 0) P (H(ɛ 2,..., ɛ n ) = 0) + P (H(ɛ 1,..., ɛ n ) = 0 H(ɛ 2,..., ɛ n ) 0). Az egyenlőséget az állítás alapján írtuk fel. Most nézzük meg, hogy a továbbiakban hogyan tudjuk az összeg tagjait megbecsülni: az első tag az indukciós feltevésből becsülhető, a második tag pedig legfeljebb t/n (mivel ɛ 1 független az ɛ 2,..., ɛ n változóktól, így ha azokat úgy rögzítjük, hogy H t 0 és így H mint x 1 polinomja nem azonosan 0, akkor legfeljebb t/n annak a valószínűsége, hogy ɛ 1 a gyöke legyen). Így ezekből: P ((H(ɛ 1,..., ɛ n ) = 0) k t N + t N k N. A bizonyítást ezzel befejeztük. Használjuk most a lemmát, és állapítsuk meg az algoritmusunk hibázásának valószínűségét. Kiindulásként az ɛ i knek (i = 1,..., n) a [0, 2k] intervallumból egyenletes eloszlás szerint véletlenszerűen és egymástól független egész számokat választottunk. Ha H azonosan 0, akkor az algoritmus ezt meg fogja állapítani. Azonban ha nem, akkor minden egyes iterációban a lemma szerint 1/2 nél kisebb a valószínűsége, hogy az algoritmus hibázik, vagyis 0 át ad vissza. 100 függetlenül megismételt kísérletnél ez már nál kisebb valószínűséget jelent, ami már kielégítő. Most a módszer alkalmazására tekintsünk egy példát egy páros gráfban teljes párosítás létezésének eldöntésére Definíció. Páros gráfnak nevezzük azokat a gráfokat, amelyek csúcsai két diszjunkt A és B halmazba oszthatók úgy, hogy minden él egy A és B beli pontot köt össze Definíció. Egy G gráf éleinek olyan halmazát, amelyeknek nincs közös pontjuk, független élhalmaznak, vagy más néven részleges párosításnak nevezzük. Teljes párosítás az olyan párosítás, amely G minden csúcsát lefedi. Módszerünkből adódik a következő párosítás-algoritmus: Legyen G páros gráf A és B csúcsosztályokkal, A = {a 1,..., a n }, B = {b 1,..., b n }. Minden a i b j élhez rendeljünk hozzá egy x ij változót. Konstruáljunk meg ebből egy n n es M = (m ij ) 35

36 mátrixot a következőképpen: { xij ha a m ij = i b j E(G) 0 egyébként Tétel. A G páros gráfban akkor és csak akkor van teljes párosítás, ha det(m) 0. Bizonyítás: Tekintsük a determináns egy kifejtési tagját: ±m 1π(1) m 2π(2)... m nπ(n), ahol a π az 1,..., n számok egy permutációja. Ahhoz, hogy ez ne 0 legyen, az kell, hogy a i és b π(i) minden i re össze legyen kötve, vagyis hogy {a 1 b π(1),..., a n b π(n) } teljes párosítás legyen G ben. Így ha G-ben nincs teljes párosítás, akkor a determináns 0. Ha G ben van teljes párosítás, akkor minden ilyennek megfelel egy nem 0 kifejtési tag, és mivel bármely kettő tartalmaz két különböző változót, így ezek nem ejtik ki egymást, tehát a determináns nem 0. Megállapíthatjuk továbbá, hogy legfeljebb n 2 változónk van, illetve minden változó elsőfokú, így válasszuk az {1, 2,..., 2n 2 } intervallumból a változókba való véletlen behelyettesítést. A módszer lényege, hogy amíg a determinánst formálisan kifejteni bonyolult, behelyettesítéssel könnyen ellenőrizhető, hogy a polinom 0, vagy sem Megjegyzés. A tétel igaz nem csak páros gráfra, hanem bármely gráfra, az algoritmus pedig ennek megfelelően átalakítható. Felhasznált szakirodalom: [6] és [7]. 36

37 6. fejezet Prímtesztelés A számelmélet talán egyik legnagyobb területe a prímszámok karakterizciójával, illetve a velük kapcsolatos feladatokkal foglalkozik. Nem nehéz észrevennünk, hogy a prímek a mai napig nagyon fontos szerepet játszanak a hétköznapi életünkben is. Gondoljunk csak az RSA titkosítási eljárásra, ami napjaink egyik leggyakrabban alkalmazott titkosítási eljárásának számít. Az RSA például azon a tényen alapszik, hogyha ismerjük két nagy prímszám szorzatát, akkor abból nagyon nehezen (vagy egyáltalán nem) tudjuk meghatározni az osztóit, vagyis magát a két nagy prímszámot. Felmerül a kérdés, hogyan találhatunk nagy prímeket. A kézenfekvő megoldás, hogy vegyünk nagy számokat véletlenszerűen mindaddig, amíg prímet nem találunk. A prímszámtétel értelmében ami a prímszámok sűrűségére vonatkozó tétel, ha véletlenül választunk egy elég nagy számot, akkor relatíve nagy a valószínűsége, hogy prím, pontosabban egy véletlenszerűen választott n egész 1/ ln n valószínűséggel lesz prím. Egyáltalán nem triviális azonban, hogyan ellenőrizzük egy nagy számról, hogy prím-e. Egy 2002 ben bizonyított tétel kimondja, hogy egy adott számról a szám méretében polinomiális időben eldönthető, hogy prím-e. Mi azonban most egy a gyakorlatban gyakran alkalmazott, véletlent használó prímtesztelő algoritmust fogunk megismerni. Ezek a módszerek azért is szépek, mert nem egy osztó megtalálásával igazoljuk majd egy számról, hogy nem prím, hanem lényegében bizonyos feltételek megsértésével. Vezessünk be előtte néhány definíciót és egy tételt: Definíció. Azokat a természetes számokat, amelyeknek pontosan két osztójuk van az 1 és önmaguk, prímszámoknak nevezzük Definíció. Összetett számoknak nevezzük azokat az 1 nél nagyobb természetes számokat, amelyeknek kettőnél több osztójuk van Definíció. Egy m számot pszeudoprímnek vagy Charmichael-számnak nevezünk, ha összetett, és a (a, m) = 1 esetén a m 1 1 mod m. 37

38 Tétel. Kis Fermat tétel Ha m prím, akkor a (1 a m 1) természetes számra a m 1 1 mod m Megjegyzés. Ha adott m mellett egy a számra a m 1 1 mod m, akkor azt mondjuk, hogy kielégíti a Fermat feltételt. Amennyiben m összetett, és egy hozzá nem relatív prím a számot választunk, akkor a m 1 1 mod m, így a a számra megkövetelt Fermat feltétel jellemzi a prímeket Egy kezdetleges algoritmus Első nekifutásra tekintsünk egy olyan algoritmust, ami csak akkor működik, hogyha nem pszeudoprímekre alkalmazzuk. Legyen tehát az algoritmus inputja egy m szám, amiről tudjuk, hogy nem pszeudoprím, és ezt vessük alá a következő prímtesztnek: válasszunk egy a számot véletlenszerűen, egyenletes eloszlás szerint az {1,..., m 1} intervallumból, és ellenőrizzük le, hogy kielégíti-e a Fermat feltételt. Ha nem, akkor biztosan kijelenthetjük, hogy m nem prím. Ha kielégíti a feltételt, akkor ismételjük meg 100 szor az eljárást, egymástól függetlenül, véletlenszerűen választott a számokkal Az algoritmus elemzése Célszerű lenne kiszámítani a tévedés valószínűségét. Ha az inputként adott m számra, és a véletlenül választott a ra teljesül a kongruencia, azonban m mégsem prím, akkor az algoritmus tévedett. A kiszámításhoz vezessük be a következő jelöléseket: legyen Z m = {a : (a, m) = 1}, vagyis az m-hez relatív prímek halmaza, amik csoportot alkotnak, továbbá H m = {a : a Z m és a m 1 1 mod m}, ami egy további tulajdonsággal bővült, azonban szintén csoport. Mivel feltettük, hogy m nem prím és nem is pszeudoprím, így vegyük észre, hogy H m Z m, vagyis H m valódi részcsoportja Z m nek, és így az elemszáma is legfeljebb fele akkora: Hm 1. Mivel tudjuk, hogy a teszt csak a H Z m 2 m beliekre lesz igaz (vagyis legfeljebb a felére lesz igaz), így a tévedés valószínűsége legfeljebb 1, 100 független 2 megismétlés esetében pedig már csak legfeljebb ( 1 2 )100. Az a tény, hogy az algoritmus nagy valószínűséggel pszeudoprímekre csődöt mond, azon alapszik, hogy egy p pszeudoprím esetében minden, a p hez relatív 38

39 prím a számra teljesül a Fermat feltétel, így ezekre különösképp nehéz olyan a t találni, ami megsértené azt. Mi azonban most nem elégszünk meg egy bizonyos esetekben működő megoldással. A következőkben egy olyan randomizált módszert ismertetünk, ami minden szám esetén alkalmazható, és szintén nagyon nagy eséllyel jó megoldással terminál A Miller Rabin prímteszt Mint már beharangoztuk, a Miller Rabin teszt minden szám esetén alkalmazható, nem kell attól tartanunk, hogy az algoritmus azért mond csődöt, mert pszeudoprímmel állunk szemben. Adott tehát egy m páratlan számunk. Írjuk fel az m 1 számot a következő alakban: m 1 = 2 k M, ahol M páratlan, majd írjuk fel a m 1 1 et szorzat alakban: a m 1 1 = a 2kM 1 = (a 2k 1M + 1)(a 2k 1M 1) = = (a 2k 1M + 1)(a 2k 2M + 1)(a 2k 2M 1) = =... = = (a 2k 1M + 1)(a 2k 2M + 1)... (a M + 1)(a M 1) Definíció. Azt mondjuk, hogy az (m, a) átmegy a Miller Rabin teszten vagy kielégíti a Miller Rabin feltételt, ha az (a 2k 1M + 1), (a 2k 2M + 1),..., (a M + 1), (a M 1) számok valamelyike osztható m el. Az algoritmus leírása Adott egy m számunk, vessük alá a következő prímtesztnek: Válasszunk 1 és m 1 között véletlenszerűen egy a számot, és vizsgáljuk meg, hogy kielégíti-e a Miller Rabin feltételt. Ha nem, akkor m biztosan összetett. Ha igen, akkor válasszunk új a t. Amennyiben 100 szor egymás után teljesül a feltétel, akkor az algoritmus azt mondja, hogy m prím Lemma. Akkor és csak akkor elégíti ki minden minden 1 a m 1 egész szám a Miller Rabin feltételt, ha m prímszám. Bizonyítás: 1. Ha m összetett, akkor bármely valódi osztója megsérti a Miller Rabin feltételt. 2. Tegyük fel, hogy m prím. Ekkor a Fermat tétel szerint bármely 1 < a < m természetes számra a m 1 1 mod m. Mivel feltettük, hogy m prím, ezért ha egy szorzatnak osztója, akkor valamelyik szorzótényezőnek is osztója kell 39

40 hogy legyen, így a Miller Rabin feltételben szereplő szorzótényezők közül is legalább egy osztható m mel, vagyis a kielégíti a feltételt Megjegyzés. Vegyük észre, hogy minden olyan a szám, amely megsérti a Miller Rabin feltételt, megsérti a Fermat feltételt is. Azonban az nem igaz, hogy csak akkor sérti meg a Miller Rabin feltételt, ha a Fermat feltételt is, hiszen lehet m összetett, és így lehet osztója egy szorzatnak anélkül, hogy bármelyik tényezőnek is osztója volna. Az algoritmus hatékonysága abban rejlik, hogy a Fermat feltétellel ellentétben a Miller Rabin feltételt összetett számokra a maradékosztályok nagy része megsérti. Ezt mondja ki a következő tétel, amit bizonyítás nélkül közlünk:, és amiből látszik, hogy ez a teszt ugyanakkora eséllyel terminál jó megoldással, mint amelyet korábban használtunk, azonban ez bármely számra alkalmazható Tétel. Ha m összetett, akkor azon a knak legalább a fele, amelyekre (a, m) = 1, megsérti a Miller Rabin tesztet. A prímtesztelés elemzéséhez a [7, 95. oldal] könyvet vettem igénybe. 40

41 7. fejezet Karger algoritmusa a MinCut problémára Ebben a fejezetben ismét látjuk majd azt, hogy miként képes a randomizálás jelentősen egyszerűsíteni egy algoritmust. Jelen esetben egy gráfelméleti problémára adunk egyszerűen kezelhető és nagy valószínűséggel pontos megoldást adó eljárást. A MinCut probléma leírásához szükségünk lesz néhány definíció bevezetésére. Tegyük fel, hogy adva van egy G(V, E) irányítatlan gráf, ami V = n csúcsból és E = m élből áll Definíció. A G = (V, E ) gráf a G gráf részgráfja, ha V V, E E, valamint egy pont és egy él pontosan akkor illeszkedik egymásra G -ben, ha G-ben is illeszkedők Definíció. Egy (v 0, e 1, v 1, e 2, v 2,..., v k 1, e k, v k ) sorozatot élsorozatnak nevezünk, ha e i a v i 1 -t és v i -t összekötő él. Ha v 0 = v k, akkor az élsorozat zárt. Ha a csúcsok mind különbözőek, akkor egy utat definiáltunk Definíció. Egy G gráf összefüggő, ha bármely két pontjához található a két pontot összekötő út G-ben. Pontosabban: a G gráf összefüggő, ha bármely u és v pontjához található olyan út, amelynek végpontjai u és v, és amely út G egy részgráfja. A probléma megadásához definiálnunk kell egy bizonyos vágás fogalmat: Definíció. A G = (V, E) gráf egy S vágásának nevezzük a V csúcshalmaz egy alkalmasan választott részhalmazát (S, S V ). A vágás értéke azon élek száma, amik S és S \ V között futnak. (Élsúlyozott esetben ezeknek az éleknek az összsúlya.) Ezeket az éleket elhagyva a gráfból a gráf több komponensre esik szét. Egy vágást minimálisnak tekintünk, ha bármely másik vágás értéke legalább akkora. Az 7.1 ábrán egy 2 értékű vágást szemléltetünk. 41

42 7.1. ábra. Vágás egy gráfon: narancssárgával jelöltük a vágásban szereplő pontokat, illetve a vágás értékét meghatározó éleket. A vágás értéke 2. Feladat: Adott egy összefüggő, irányítatlan, n csúcsú, illetve m élű (esetleg élsúlyozott, ahol a súlyok nemnegatívak) G gráf. Keresünk G-ben egy minimális értékű vágást, ezt nevezzük MinCut problémának. Ezt az esetet megkülönböztetjük attól a problémától, amikor egy s t minimális vágást keresünk, ahol s és t megadott pontok, amiknek a két különböző ponthalmazba kell esnie. Jelen esetben nincsenek ilyen feltételeink. Különösen élsúlyozatlan esetben szokás úgy emlegetni a feladatot, hogy keressük az éleknek azt az alkalmasan megválasztott minimális számú halmazát (egy vágáshoz tartozót), amit eltávolítva a gráfból, a gráf már nem lesz összefüggő, viszont ennél kevesebb éllel ezt nem tudjuk elérni Karger algoritmusa Karger algoritmusa egy Monte Carlo típusú véletlenített algoritmus, vagyis kis valószínűséggel rossz eredménnyel terminálhat. (Később látni fogjuk, mekkora is ez a valószínűség.) Az algoritmus lényegében egy kontrakciónak nevezett műveleten alapul, ami szerint véletlenülszerűen kiválasztunk egy élt az élhalmazból (minden él egyformán valószínű), majd annak két végpontját összevonjuk. Ezt mindig úgy értelmezzük, hogy megszűntetjük a két csúcs közötti összes élt, illetve az új csúcs a régi csúcsok minden szomszédját megtartja. Az algoritmus pontos leírásához szükségünk lesz néhány elnevezés és jelölés ismertetésére. Használni fogjuk a leírásban a szupercsúcs és szuperél fogalmakat, amelyek a következőket jelentik: szupercsúcsnak nevezzük a csúcsoknak egy csoportját, vagyis egy szupercsúcs több csúcsot is tartalmazhat. Két szupercsúcs A és B között futó éleket szuperélnek nevezzük, vagyis a szuperél nem más, mint olyan élek egy csoportja, amelynek egyik végpontja A-ban, másik pedig B-ben van. Inicializáláskor minden csúcsot a saját szupercsúcsa tartalmazza, és minden szuperél egy élből áll. Az x szupercsúcs által tartalmazott csúcsokat V (x) el, továbbá x és y szu- 42

43 percsúcsok között futó éleket tartalmazó szuperélt E xy nal jelöljük. A szupercsúcsok halmazát jelöljük val, a szuperélekét pedig Ω val. Az algoritmus véletlenszerűen választ egy élt a szuperélek közül (egyenletes eloszlás szerint), egyesíti (kontraktálja) a végpontjait, és ezt addig ismétli, amíg összesen két szupercsúcs marad. Ez a két szupercsúcs definiálja a vágást, amit kerestünk. Karger (G) 1, Ω ; 2 for each v V do 3 v új szupercsúcs; 4 V (v ) {v}; 5 {v }; 6 for each (x, y) E do 7 E xy {(x, y)}; 8 Ω Ω {(x, y)}; 9 while > 2 do 10 (x, y) véletlenszerűen válaszott él Ω -ból; 11 Kontrakció(x, y, ); 12 Ω Ω \ E x y ; 13 return {a, b} and E ab ; Kontrakció (u, v, ) 1 w új szupercsúcs; 2 V (w) V (u) V (v); 3 for each d \ {u, v} do 4 E wd E ud E vd ; 5 ( \ {u, v} {w}; Az 7.2 ábrán láthatjuk, hogy az algoritmus megtalált egy 2 értékű minimális vágást. Azonban a véletlennek köszönhetően választhattunk volna olyan szuperéleket és szupercsúcsokat a kontrakció során, ami nem a minimális vágást eredményezte volna. Nézzük meg, mekkora a valószínűsége annak, hogy az algoritmus véletlen választással megtalál egy minimális vágást Az algoritmus elemzése Tétel. Annak a valószínűsége, hogy a Karger algoritmus egy minimális vágással tér vissza, legalább 1 ( n 2). Bizonyítás: Rögzítsünk egy minimális S vágást. Egy vágás mint már említettük a csúcsokat valamiféleképpen partícionálja. Nevezzük vágásbeli éleknek azokat az 43

44 7.2. ábra. Az ábrán Karger algoritmusának egy lehetséges lefutása látható, ami jelen esetben egy minimális vágást ad vissza. Pirossal jelöltük a kontrakcióra szánt szupercsúcsokat. éleket, amik S és V \ S között futnak. Nyilvánvaló, hogyha S vágás az algoritmus outputja, akkor az algoritmus során egyetlen vágásbeli él sem lett kiválasztva kontrakcióra. Visszafelé, hogyha az algoritmus csak olyan éleket kontraktál, amik nem vágásbeliek, akkor S az algoritmus outputja. Nézzük meg, hogy mennyi a valószínűsége, hogy a Karger algoritmus outputja éppen S. Összesen n 2 él kerül kiválasztásra, amiknek a végpontjait összevonjuk, hiszen minden összevonásnál egy csúccsal kevesebb lesz, és tudjuk, hogy a végén mindössze 2 szupercsúcsunk marad. A kiválasztott éleket sorszámozhatjuk 1 től n 2 ig a kiválasztásuk szerint. P (Karger outputja S ) = P (1. él nem vágásbeli ) P (2. él nem vágásbeli 1. él nem vágásbeli )... P (n 2. él nem vágásbeli 1., 2.,..., n 3. él nem vágásbeli ) Azt mondjuk, hogy egy él jó, ha nem vágásbeli, vagyis ha nem S és V \ S között fut. Legyen K a vágásbeli élek, m pedig a gráf összes éleinek a száma. Egy v csúcs szomszédait deg(v) vel jelöljük, így ha bármely csúcs önmagában egy vágást határoz meg, illetve ha a minimális vágás értéke K, akkor elmondható, hogy v re deg(v) K. Így m = v deg(v)/2 n K/2. Ebből következően: P (1. él jó) = 1 K m 1 K n K 2 n 2 n. 44

45 A következő lépés az, hogy megmutatjuk, hogy a multigráfban (ahol többszörös éleket is megengedünk), az első j 1 kontrakció után, ha egyik él sem vágásbeli él volt, akkor a minimális vágás értéke még mindig K. Jelöljük az első j 1 kontrakció után kialakult gráfot G j vel. Minden G j beli vágás egy érvényes vágás G ben is, vagyis a minimális vágás G j ben legalább akkora értékű, mint S. Ha az első j 1 él nem vágásbeli volt, akkor bármely c G j re, a V (c) beli csúcsok a minimális vágás ugyanazon oldalán vannak, vagyis vagy mindegyik S vagy mindegyik V \ S. Ezért S egy érvényes vágás G j -ben is, és a minimális vágás értéke G j ben pont annyi, mint a minimális vágás értéke G ben. Legyen j 1, és legyen P j annak a valószínűsége, hogy a j edik él jó, feltéve, hogy az első j 1 is jó: P j = P (j. él jó 1., 2.,..., j 1. élek mind jók) K = 1 élek száma a multrigráfban K 1 szupercsúcsok száma K 2 Az első egyenlőség definíció szerint igaz, a második azért, mert az első j 1 él jó, így a minimális vágás még mindig érvényes vágás G j ben, ezért a valószínűsége annak, hogy a j-edik él jó, megegyezik azzal, hogy a K értékű vágás egyik éle sem lett kiválasztva. Az egyenlőtlenség pedig abból adódik, hogy mivel minden szupercsúcs egyben egy vágást is definiál, ezért minden szupercsúcs foka K, ennélfogva a csúcsok száma a multrigráfban legalább annyi, mint a szupercsúcsok száma K/2. A Kontrakció minden egyes hívásakor eggyel csökken a szupercsúcsok száma, így az j 1 kontrakció után n j + 1. Vagyis j 1, P j 1 K 2 K (n j + 1) = n j n j + 1 = n j 1 n j + 1 Ezt a levezetést felhasználva megkapjuk: P (Karger outputja S ) = P 1 P 2... P n 2 n 2 n A tétel állítását ezzel beláttuk. = n 3 n 1 n 4 n n(n 1) = 1 ( n 2). 45

46 7.3. Egy továbbgondolt változat Akármennyire is pozitívak szeretnénk lenni, az 1/Θ(n 2 ) valószínűség nem túl nagy, még mindig elég nagy esélyünk van egy hibás outputra. Hogyan tudnánk ezen javítani? Ismételjük meg az algoritmust tetszőleges sokszor, és jegyezzük meg a kapott eredményeket. Ezek közül a végén könnyedén ki tudjuk választani a legjobbat. Nézzük meg először az algoritmust, majd azt, hogy így mekkora esélyünk van a tényleges minimális vágás megtalálására. Legyen C > 0 egy tetszőleges választott konstans. IsmételtKarger (G) futtassuk C (n 2) ln n szer a Karger algoritmust; jegyezzük meg a minimális vágásokat, legyen az output a legjobb eredmény. Az IsmételtKarger futási ideje nyilvánvalóan Θ(n 4 log n), hiszen egy Θ(n 2 ) futási idejű algoritmust futtatunk Θ(n 2 log n) szer Tétel. P (IsmételtKarger helyes eredményt ad vissza) 1 1 n c, ahol C az algoritmusban használt konstans. Bizonyítás: A bizonyításhoz felhasználjuk a következő egyenlőtlenséget: Állítás. x > 0 : (1 1 x )x 1 e. P (IsmételtKarger outputja hibás) = P (Karger outputja hibás az összes C = (P (Karger outputja hibás)) C (n 2) ln n ( ) C ( n 1 ( 1 2) ln n n 2) ( = 1 1 ( n 2) ( ) C ln n 1 e = 1 n. C ) ( n 2) C ln n A tétel állításával egyező eredményre jutottunk. ( ) n ln n független lefutásakor) 2 46

47 Láthattuk tehát, hogy az eredeti algoritmus többszöri megismétlésével oly módon kijátszhatjuk a véletlen szerepét megőrizve annak minden előnyét, hogy növelni tudtuk a helyes output valószínűségét Megjegyzés. Később továbbfejlesztették az algoritmust, amely Karger Stein algoritmusként terjedt el, és aminek a futási ideje már Θ(n 2 log 3 n). A Karger algoritmus megértésében, illetve a bizonyítások ismertetésében az alábbi publikációkra támaszkodtam: [4], [5]. 47

48 8. fejezet Véletlenített hash elés alkalmazása Ebben a fejezetben a véletlenített hash elés egy módszerét, a helyzetérzékeny hash elést (locality sensitive hashing, LSH) ismertetem, utána bemutatom egy konkrét problémakörben történő alkalmazását, majd elemezést adok az eredmény várható hibájára. Az LSH egy olyan hash elési módszer, amely arra lett kifejlesztve, hogy nagy dimenziójú adatok dimenziószámát a véletlen segítségével csökkentse, méghozzá azzal az elvárással, hogy a bizonyos szempontok szerinti hasonló adatok továbbra is hasonlók maradjanak. Ez algoritmikus szempontból azt jelenti esetünkben, hogy a hasonlóságukat megörző adatok a hash elés során nagy valószínűséggel egyazon edénybe kerüljenek. Ezt az eljárást a következőkben a k legközelebbi szomszéd problémára (röviden k nn probléma) fogom alkalmazni, bizonyos kémiai molekulák fingerprintjei kapcsán. A feladat az, hogy megadjuk egy adott molekulához legközelebb eső k db molekulát Szükséges előismeretek A feladat kiindulásaként gyógyszermulekulák egy publikus (National Cancer Institute által kibocsátott) halmaza állt a rendelkezésemre, ami csaknem 250 ezer molekula gráfját tartalmazza. Ezeknek a fingerprintekké kódolt formáját használtam. (A kódolási eljárás a feladat szempontjából most lényegtelen.) Egy molekula gráf fingerprintje olyan d = 1024 hosszú 0 1 sorozat, amely nem egy-egyértelmű, viszont őrzi a molekula kémiai tulajdonságait. Ha két molekula hasonló tulajdonságú, akkor a fingerprintjeik közel vannak egymáshoz. A közelség fogalmát most az úgynevezett Hamming távolsággal értelmezzük Definíció. Két fingerprint Hamming távolsága azoknak a biteknek a száma, ahol a két sorozatban különböző értéket találunk. (Az egyik 0, a másik 1, vagy pedig fordítva.) Egy a és b pont Hamming távolságát d(a, b) vel jelöljük. 48

49 Feladat: A k nn probléma a molekula fingerprintek halmazán a következőképpen értelmezhető: adott a fingerprintek S halmaza. Az input egy tetszőleges q S, az output pedig k db q tól különböző p 1, p 2,..., p k S, amikre a következő teljesül: d(q, p i ) d(q, r) fennáll r p i, q, r S. Ha ez a feltétel k nál több pontra is fennáll, akkor bármelyik k db elfogadható közülük, így tehát az eredmény nem mindig egyértelmű. Egy lehetőségként felmerülhet és kisebb adathalmazokra működik is, hogy vizsgáljunk meg minden pontot és számítsuk ki a kitüntetett ponttól vett Hamming távolságukat. Azonban ekkora adatmennyiség esetén ez nagyon nagy számú összehasonlítást igényelne, így ez nem lenne hatékony. A hasonlósági feladatokra, főképp gyakori végrehajtás esetén, célszerűbb hatékonyabb eljárást keresni, esetünkben ez a helyzetérzékeny hash elés, másképp LSH A helyzetérzékeny hash elés algoritmusa A probléma hatákonyabb megközelítése most az alaphalmaz alkalmas felosztásában rejlik. Elegendő lenne azoknak a fingerprinteknek a vizsgálata, amelyek a lekérdező elemnek egy közvetlen környezetében helyezkednek el, így a többi elemet figyelmen kívül hagyhatjuk. A fingerprintek a {0, 1} d teret határozzák meg, ahol a d dimenzió értéke Ezt a dimenziót csökkentjük a helyzetérzékeny hash elés segítségével oly módon, hogy véletlenszerűen kiválasztott koordináták alapján hash táblát készítünk, majd ezekben helyezzük el a molekulák fingerprintjeit. Ebben az esetben elegendő a fingerprinteknek csak a kiválasztott koordinátáit megvizsgálni, majd a lekérdező elemmel azonos edénybe kerülők Hamming távolságát meghatározni, és ezek közül kiválasztani a k db legkisebbhez tartozó molekulát. A hash eléstől nem csak azt várjuk el, hogy helyes legyen, vagyis hogy a közel álló elemek nagy valószínűséggel azonos edénybe kerüljenek, hanem azt is, hogy az edények elemszáma közel azonos legyen, így a keresési idő nem függ majd a bemeneti lekérdező molekulától. Megjegyzendő, hogy a hash táblát elég egyszer felépíteni, utána tetszőleges számú kereséshez felhasználhatjuk. A hash elés menete a következő lépésekből áll: 1. Először is a hash eléshez használt pozíciók száma legyen r [1, d], ahol d a dimenziótszámot, vagyis a fingerprintek hosszát jelöli. 2. Minden kiválasztott koordináta értéke 0 vagy 1 lehet, így minden pozíció kétfelé hash eli a fingerprintek terét, ezek alapján a hash tábla mérete: m = 2 r. Ez valójában az edények számát jelenti, szélsőséges esetben r = 0 esetén m = 1 db edényünk lesz, míg r = d esetén m = 2 d, vagyis minden pont külön edénybe kerül. 49

50 3. Hash pozíciók megválasztása: válasszunk r db koordinátát az [1, d] intervallumból, mindegyiket egymástól függetlenül, véletlenszerűen. Ehhez célszerű véletlenszám generátort alkalmazni. 4. Leképezés a hash tábla edényeibe: a fingerprinteket aszerint helyezzük el a különböző edényekbe, hogy a kiválasztott pozíciókban milyen értékek szerepelnek. Azt várjuk, hogy az edényekbe nagyjából hasonló számú fingerprint kerül. Elképzelhető, hogy az LSH nem a pontos megoldást találja meg. A k legközelebbi elem közül csak azokat veszi észre, amelyek a lekérdező molekulával együtt egy edénybe kerülnek. Azokat az elemeket viszont, amelyek a bemeneti fingerprinttől különböző edénybe kerülnek, a keresés nem fogja megvizsgálni, így előfordulhat, hogy az eredmény csak közelítő jellegű Egy példa a módszer illusztrálására Nézzünk meg egy konkrét példát a módszer szemléltetésére. Az egyszerűség kedvéért kevés számú, kis dimenziójú adatokkal dolgozunk. Legyen a fingerprintek dimenziója d = 7. Példánkban a lekérdező fingerprintet jelöljük P vel. Ennek a fingerprintnek keressük k = 3 legközelebbi szomszédját egy 6 elemű halmazban, ahol a fingerprinteket A tól F ig címkéztük fel ábra. Az adathalmaz. 50

51 A 8.1 ábrán látható a lekérdező P pont, illetve a teljes vizsgált adathalmaz. Pirossal jelöltük a fingerprinteknek azokat a koordinátáit, amelyek eltérnek a lekérdező pont ugyanazon helyen lévő koordinátáitól, majd ezek alapján a jobb szélső oszlopban meghatároztuk a Hamming távolságokat. Ezek szerint a P hez legközelebb eső három molekulaleíró elem a B, C, D lettek, és ennek a meghatározásához 6 érték kiszámítására volt szükség ábra. A hash elést meghatározó, véletlenszerűen választott pozíciók. Most alkalmazzuk a példánkra a helyzetérzékeny hash elést. Válasszunk véletlenszerűen r = 3 koordinátát, legyenek ezek a 2., 5. és a 6., ezeket kékkel jelöltük a 8.2 ábrán. Ezek alapján helyezzük el a fingerprinteket a hash tábla edényeibe. A kialakult hash tábla a 8.3 ábrán látható. A hash elés után a keresést csak abban az edényben folytatjuk, amelyikbe maga a lekérdező P fingerprint is került. Így a P hez legközelebbi három szomszéd az A, B és C lettek, ezek megtalálásához három távolságérték kiszámítására volt szükség. Látható, hogy eredmény nem pontos, az LSH után a keresés csak kettő fingerprintet talált meg a három valóban legközelebbi szomszéd közül, és így egy tévesen került a megoldás halmazba. A következő alfejezetben megnézzük, mi az eljárás hibázásának a valószínűsége A módszer hibája Először is vizsgáljuk meg, hogy az LSH mekkora valószínűséggel veszít el, illetve talál meg egy legközelebbi szomszédot. Egy fingerprint elhelyezése a hash táblában 51

52 8.3. ábra. A hash tábla. a bitjeinek a véletlenszerűen kiválasztott hash pozíciókban lévő értékeitől függ. Az edények száma, vagyis a hasht tábla mérete 2 r lesz, ha r db pozíciót jelölünk ki véletlenszerűen. Ezek az összes lehetséges kitöltést reprezentálják. Legyen P a lekérdező fingerprint, Q pedig egyike a k legközelebbi szomszédnak. Azt a besorolást, ami szerint P és Q különböző edénybe kerül, hibás besorolásnak tekintjük, hiszen a keresés Q t mivel másik edénybe került biztosan nem fogja megtalálni. Erre akkor kerülhet sor, ha P és Q legalább egy hash pozícióban eltérő értékkel rendelkezik. A hiba becsléséhez vezessünk be különböző paramétereket: továbbra is jelölje d a fingerprintek hosszát, legyen δ azon pozíciók száma, ahol P és Q különböznek. Tegyük fel, hogy ezek a pozíciók egyenletes véletlen eloszlásúak, vagyis ugyanakkora eséllyel bárhol elhelyezkedhetnek. Legyen a d dimenzió értéke 1024, r pedig 10. Ha a δ t pl. 41 nek választjuk (a tapasztalat szerint ez egy 40 körüli érték), akkor δ/d = 41/1024 = 0.04 annak a valószínűsége, hogy P és Q egyetlen véletlen hash pozícióban különböznek, vagyis 0.96 annak a valószínűsége, hogy egyazon edénybe kerülnek. Vizsgáljuk meg annak a valószínűségét, hogy a helyzetérzékeny hash elés után a keresés megtalálja a Q legközelebbi szomszédot. Tegyük fel, hogy azon bitek, amelyekben a lekérdező ponttól különbözik, egyenletesen oszlanak el. Ekkor annak a valószínűsége, hogy az r db hasítópozíció nem talál el egyetlen különbség bitet sem a δ db közül: ( ) ( ) d δ d P M = / r r = ( ) ( ) / = Közelítsük a tört értékét az első összetartozó hányados 10 edik hatványával, ( ) tal. (Ez a közelítés a következőképpen is felfogható: válasszuk ki a 10 hash-pozíciókat úgy, hogy megengedjük az ismétlődéseket. Ekkor vegyük annak 52

53 a valószínűségét, hogy egyetlen egyszer sem találunk el egy különbség bitet.) Ebben az esetben Q megtartásának és elvesztésének valószínűsége: P M = P E = 1 P M Vizsgáljuk meg azt, hogyan tudnánk a módszer ezen hibáján javítani. Egy jó megoldás lehet az, hogy egymás után több hash elést végzünk, majd az edényeket egyesítjük. Abban az esetben, ha elvesztünk egy legközelebbi szomszédot az első hash elés során, még visszanyerhetjük a második és az első hash elés uniójával. Annak a valószínűsége, hogy így megtartjuk Q t: P (2) M = P M + P E P M Három, egyesített listájú hash elés után pedig már szinte biztos, hogy a hash elés nem veszíti el a P hez közeli Q t: P (3) M = P M(1 + P E + P 2 E) Általánosan annak a valószínűsége, hogy a j edik LSH alkalmával sem veszítjük el Q t: P (j) M = P M(1 + P E + PE P j 1 E ). Ebből adódóan, ha a hash elések számát a végtelenségig növeljük, és használjuk a P E = 1 P M összefüggést: lim P (j) M = lim P M(1 + P E + PE P j 1 E ) = P 1 M = 1. j j 1 P E Vagyis a módszer végrehajtásának kellő számú megismétlése esetén 1 a valószínűsége annak, hogy egy P hez közeli Q fingerprintet megtalálunk. Így elmondható, hogy ez a módszer már kellően biztonságos A k-nn program Az LSH alkalmazását szoftveres módon én is kipróbálhattam a gyakorlatban, témavezetőmnek köszönhetően, aki a rendelkezésemre bocsájtott egy korábbi projektből származó kereső programot (pontosabban annak oktatási célú változatát). A program futtatása a korábban említett fingerprintek halmazának betöltésével kezdődik. Ezek után beállítandó a hash elésben részt vevő pozíciók száma, én ezt 10 nek választottam, majd ezek alapján elkészült a fingerprintek szétosztása az edényekbe (az edények száma 2 10 ). Végül kiválasztandó maga a lekérdező fingerprint, amelynek legközelebbi k db szomszédját keressük, a k értékét 5 nek választottam. 53

54 A program kiírja a szekvenciális keresés egzakt, és az LSH alkalmazásával kapott eredményeket is, így a pontosság ellenőrizhető. Témavezetőm megerősített abban az érzésemben, hogy a program intenzív használata szükséges ahhoz, hogy mélyebb, differenciáltabb tapasztalatokra tegyünk szert, pl. a program paramétereinek finom-hangolásában. Célom ezúttal a módszer elméleti bemutatása és ismertetése mellett a szoftveres kipróbálásra szorítkozott, néhány meggyőző futtatás erejéig. Ennek megfelelően, végül alább látható a program alkalmazása és néhány futtatás eredménye ábra. A megfelelő beállítások után a program megtalálta az összes legközelebbi szomszédot, és ehhez mindössze a keresések 0.34 százaléka hajtódott végre. 54

55 8.5. ábra. Az eredmény ebben az esetben most csak közelítő jellegű, hiszen a tényleges öt legközelebbi szomszéd közül csak hármat talált meg ábra. A hash elés ismételt alkalmazása után a program ismét pontos eredményt adott, a teljes keresések mindössze 2.58 százalékának felhasználásával. 55