1756 Rinnakkaisalgoritmien suunnittelu Rinnakkaisuuden hyödyntämisen perustekniikat J. Porras

Yleistä •Rinnakkaisten algoritmien luominen eri tarkoituksiin on peräkkäistä hankalampaa •Yleisten kaikkiin ympäristöihin soveltuvien metodien puutteen korvaa kokoelma erilaisia tekniikoita, jotka on havaittu tehokkaiksi eri ongelmilla

Tekniikat (Jájá) •Tasapainotettu puu (balanced tree) •Pointterihyppely (pointer jumping) •Hajoita ja hallitse (Divide and Conquer) •Ositus (Partitioning) •Liukuhihnoitus (pipelining) •Hitaan ja nopean menetelmän yhdistäminen (accelerated cascading) •Symmetrian hajoittaminen (symmetry breaking)

Tasapainotettu puu •Tasapainotetun puun menetelmässä syöte- elementit sijoitetaan puun lehtiin ja niillä suoritettavat operaatiot välisolmuihin Esim. Summan laskenta •Menetelmän käyttökelpoisuus perustuu pitkälti siihen kuinka nopeasti alipuuhun sisältyvä informaatio voidaan kerätä

Tasapainotettu puu •Esimerkki: Prefix-sum algoritmi –Olkoon meillä n elementin sarja {x 1, x 2, … x n } –Sarjan prefix sum on n osasummaa s i = x 1 *x 2 *…*x i, 1 < i < n –Yksinkertainen peräkkäinen ratkaisu Lasketaan s i s i-1 :stä s i = s i-1 *x i, 2 < i < n O(n) aikakompleksisuus

Tasapainotettu puu •Rinnakkainen Prefix sum -menetelmä –Käytetään tasapainotettu puu -tekniikkaa –Ylöspäin mentäessä välisolmut edustavat * operaatiota –Alaspäin tultaessa lesketaan prefix sum:mia kunkin tason solmuille

Tasapainotettu puu •Esimerkki: 8 elementin prefix sum –Ensimmäisellä aika-askeleella: y 1 = x 1 *x 2, y 2 = x 3 *x 4, y 3 = x 5 *x 6, y 4 = x 7 *x 8 –Toisella aika-askeleella y’ 1 = y 1 *y 2, y’ 2 = y 3 *y 4 –Kolmannella aika-askeleella y’’ 1 = y’ 1 *y’ 2 –Koska n = 8, neljännellä aika-askeleella suoritetaan vain s 1 = x 1 (= y’’ 1 = z’’ 1 )

Tasapainotettu puu –Neljännellä aika-askeleella rekursio alkaa purkautua s 1 = x 1 (= y’’ 1 = z’’ 1 ) –Viidennellä aika-askeleella (n = 2) s 1 = x 1 = y’ 1, s 2 = z’ 1 = –Kuudennella aika-askeleella (n = 4) s 1 = x 1 = y 1, s 2 = z 1 = s 3 = z 1 * x 3 = s 4 = z 2 = –Viimeisellä seitsemännellä aika-askeleella saadaan summat s 1 - s 8

Tasapainotettu puu •Prefix sum –Syötteen koolla n = 2 k, algoritmi vie ajan 2k+1 •k ensimmäistä askelta kuluu ylöspäin mennessä •k viimeistä askelta alaspäin tultaessa –Prefix sum algoritmin kompleksisuus on: Aikakompleksisuus T(n) = O(logn) TyökompleksisuusW(n) = O(n)

Tasapainotettu puu •Todistus k:n induktiolla: syötteen koko n = 2 k –k = 0 tapaus hoituu algoritmin 1. Askeleella –Oletetaan, että algoritmi toimii oikein kaikille syötteille kun n = 2 k –Todistetaan, että algoritmi laskee minkä tahansa n = 2 k+1 pituisen syötteen prefix sum:mat

Tasapainotettu puu –Muuttujissa z 1, z 2, …, z n/2 on sarjan {y 1, y 2, …, y n/2 } prefix sum:mat (induktiohypoteesin mukaan) –z j = y 1 * y 2 *…* y j eli z j = x 1 * x 2 *…* x 2j-1 * x 2j eli z j on s 2j :n prefix sum 1 < j < n/2 •jos i = 2j, niin s i = z i/2 •jos i = 1, tapaus triviaali •jos i = 2j + 1, niin s i = s 2j+1 = s 2j *x 2j+1 = z (i-1/2) *x i

Tasapainotettu puu •Prefix sum algoritmi ei kaipaa millään askeleella yhtäaikaista luku- tai kirjoitus- operaatiota –toimii siis EREW PRAM:ssa •Tasapainotettu puu -menetelmää käytetään paljon rinnakkaisalgoritmien kehittelyssä •Menetelmän ei tarvitse rajoittua vain bi- naaripuihin, vaan se soveltuu myös muihin

Pointterihyppely •Pointterihyppely tarjoaa yksinkertaisen ja tehokkaan menetelmän linkitettyihin listoi- hin tai puihin perustuvan datan käsittelyyn •Pointterihyppelyssä käytetään hyväksi solmusta toiseen osoittavia pointtereita (joita pitkin rakenteessa edetään)

Pointterihyppely •Suunnattu puu (root-directed tree) T on suunnattu graafi, jossa on olemassa solmu r, siten että: –kaikille v  V -{r} uloslähtevien linkkien määrä on 1 ja r:lle 0 –kaikille v  V -{r} on olemassa suunnattu polku v:stä r:ään

Pointterihyppely •Esimerkki: metsän juurien etsiminen –Olkoon F metsä, joka koostuu useista suunnatuista puista –Esitetään F n:n mittaisena vektorina P siten, että P(i) = j, jos (i,j) on linkki F:ssä (eli j on i:n vanhempi) –Juurelle P(i) = i –Määritetään kunkin solmun j juuri S(j), 1<j<n

Pointterihyppely •Peräkkäinen ratkaisu: –Etsitään juuret ja päivitetään lapsille tiedot –O(n) aikakompleksisuus •Rinnakkainen ratkaisu: –Määritellään kullekin solmulle seuraaja S(i) siten, että alkuun se on P(i) –Käytetään pointterihyppelyä muuttamaan seuraaja aina seuraavan solmun seuraajaan

Pointterihyppely –Kun tekniikkaa käytetään useita kertoja, lähestyy solmun seuraaja-informaatio puun juurta, lopulta paljastaen juuren –Pointterihyppelyn kompleksisuus: •aikakompleksisuus O(logn) •työkompleksisuus O(nlogn)

Pointterihyppely •Pointterihyppelyä kutsutaan myös nimellä Path Doubling, koska etäisyys solmun ja seuraajan välillä aina kaksinkertaistuu (ellei seuraaja ole juuri) •k:nnella iteraatiolla i:n ja S(i):n välinen etäisyys on 2 k ellei S(i) ole juuri •Menetelmä voi vaatia yhtäaikaista luku- operaatiota (eli tarvitaan CREW PRAM)

Hajoita ja hallitse •Divide and Conquer •Koostuu kolmesta askeleesta: –hajoitetaan ongelma useaan lähes samankokoi- seen osaan –ratkaistaan osat (rekursiivisesti) –yhdistetään osatulokset kokonaisratkaisuksi •Tekniikan käyttökelpoisuus riippuu pitkälti 1. ja 3. vaiheen tehokkuudesta

Hajoita ja hallitse •Konveksipeite -ongelma (Convex hull) –Olkoon meillä n pisteen joukko S = (p 1,…, p n ) –Jokaisella pisteellä on (x,y) koordinaatit –S:n konveksipeite on pienin mahdollinen polygoni Q, joka sisältää kaikki S:n n pistettä –Polygoni Q on konveksi, jos mille tahansa kahdelle pisteelle p ja q, viivesegmentti, jonka päätepisteet p ja q ovat, on kokonaisuudessaan Q:n sisällä

Hajoita ja hallitse •Konveksin peitteen ongelmassa pyritään määräämään S:n pisteet CH(S) (jossakin järjestyksessä) siten, että ne määräävät polygonin Q •Konveksin peitteen peräkkäinen ratkaisu käyttämällä hajoita ja hallitse tekniikkaa vie ajan O(n log n).

Hajoita ja hallitse •Rinnakkainen ratkaisu käyttämällä hajoita ja hallitse tekniikkaa: –Olkoon p ja q pisteet S:ssä siten, että ne edus- tavat pienintä ja suurinta x koordinaattia => Ne siis kuuluvat selvästi CH(S):ään –Samalla ne jakavat peitteen ylempään UH(S) p-q ja alempaan LH(S) q-p osaan –Koska ratkaisu on periaatteessa sama molem- mille osille, keskitytään vain ylemmän osan ratkaisuun

Hajoita ja hallitse –Oletetaan, että n luvun lajittelu voidaan suorit- taa O(log n) ajassa ja O(nlog n) operaatiolla –Oletetaan myös, että kahdella pisteellä ei ole samaa x tai y koordinaattia ja n on kahden potenssi –Alustetaan tehtävä lajittelemalla pisteet p i x- koordinaattinsa perusteella x(p 1 ) < x(p 2 ) < … < x(p n )

Hajoita ja hallitse –Olkoon meillä S:n osajoukot S 1 = (p 1, p 2, …, p n/2 ) ja S 2 = (p n/2 + 1,..., p n ) –Oletetaan, että UH(S 1 ) ja UH(S 2 ) on ratkaistu –Yhteinen ylätangentti UH(S 1 ):n ja UH(S 2 ):n välillä jättää UH(S 1 ):n ja UH(S 2 ):n alleen –Yhteisen ylätangentin etsintä voidaan suorittaa O(log n) ajassa (peräkkäisellä binaarisella etsinnällä)

Hajoita ja hallitse –Olkoot UH(S 1 ) = (q 1,..., q s ) ja UH(S 2 ) = (q’ 1,..., q’ t ) osajoukkojen konveksit peitteet –Jos yhteinen ylätangentti on (q i,q’ j ), niin UH(S) koostuu i ensimmäisestä UH(S 1 ):n elementistä ja t-j+1 viimeisestä UH(S 2 ):n elementistä eli UH(S) = (q 1,..., q i, q’ j,..., q’ t ) –Menetelmä, jolla UH(S 1 ) ja UH(S 2 ) yhdistetään vaatii yhtäaikaista lukuominaisuutta (yhteisen ylätangentin määrääminen)

Hajoita ja hallitse –Algoritmi laskee ylemmän peitteen n pisteelle ajassa O(log 2 n) ja suorittaa O(nlog n) operaa- tiota Algoritmi on siis kustannusoptimaalinen –Algoritmia voidaan tehostaa n  -hajoita ja hallitse menetelmällä ja liukuhinoitetulla hajoita ja hallitse menetelmällä –Optimaalinen aika ongelmalle on O(log n)

Ositus •Partitioning •Ositusmenetlmä voidaan jakaa kahteen vaiheeseen: –Jaetaan ongelma p itsenäiseen lähes samanko- koiseen osaongelmaan –Ratkaistaan p osaongelmaa rinnakkaisesti p prosessorilla

Ositus •Ajatus lähes sama kuin hajoita ja hallitse menetelmässä, mutta siinä missä hajoita ja hallitse keskittyy tehokkaan yhdistämis- menetelmän käyttöön, ositus perustuu ongelman tehokkaaseen jakamiseen siten, että osat on helppo yhdistää •Yksinkertaisimmillaan menetelmä jakaa ongelman p ei-päällekkäiseen osaan ja nämä p osaa sitten ratkaistaan erillisesti

Ositus •Joukkojen yhdistäminen: –Olkoon meillä joukko S, joka on täydellisesti järjestetty eli kaikille a,b  S joko a  b tai b  a –Olkoon A = (a 1,...,a n ) ja B = (b 1,...,b n ) kasva- vat joukot, joiden elementit on saatu joukosta S –Tarkastellaan ongelmaa, missä joukot A ja B tulee yhdistää yhdeksi järjestetyksi joukoksi C –Yksinkertainen peräkkäinen ratkaisu vie ajan O(n)

Ositus •Yksinkertainen yhdistämisalgoritmi: –Olkoon X = (x 1,..., x t ) sarja, jonka elementit ovat joukosta S –Määritellään x:n arvo (x  S) rank(x:X) siten, että se on niiden X:ssä olevien elementtien määrä, jotka ovat pienempiä kuin x –Olkoon Y = (y 1,...,y s ) satunnainen sarja ele- menttejä S:stä –Y:n yhdistäminen X:ään määrittää sarjan rank(Y:X) = (r 1,...,r s ), missä r i = rank(y i :X)

Ositus –Esimerkki: •X = (25, -13, 26, 31, 54, 7) ja Y = (13, 27, -27) •Rank(Y:X) = (2, 4, 0) –Oletetaan, että yhdistettävien jonojen A ja B elementit ovat erillisiä –Yhdistämisongelma voidaan nähdä ongelmana, missä jokainen A:n tai B:n elementti rankataan joukkoon A  B –Jos rank(x:A  B) = i, niin c i = x

Ositus –Koska rank(x:A  B) = rank(x:A) + rank(x:B), voidaan yhdistämisongelma ratkaista määrit- tämällä rank(A:B) ja rank(B:A) –Koska molempiin pätee samat periaatteet, rat- kaistaan jälleen vain toinen osaongelmista eli rank(B:A) –Olkoon b i satunnainen B:n elementti

Ositus –Koska A on järjestetty, löydetään b i A:sta bi- näärisellä etsintäalgoritmilla eli verrataan b i :tä A:n keskimmäiseen elementtiin ja edetään sen mukaan onko A:n alkio liian suuri vai pieni –Peräkkäinen etsintä vie ajan O(log n). –Kun algoritmia sovelletaan rinnakkaisesti kaikkiin B:n elementteihin, saamme tuloksen ajassa O(log n) O(n log n) operaatiolla ei kustannusoptimaalinen (Seq. O(n))

Liukuhihnoitus •Liukuhihinoitus -menetelmä noudattaa sa- moja periaatteita kuin tietokoneiden sisäi- nen liukuhihnoitus •Liukuhihnoituksella mahdollistetaan usei- den käskyjen samanaikainen suoritus (eri vaiheissa) •Liukuhihnoituksessa ongelma jaetaan ali- ongelmiin, joita suoritetaan järjestyksessä, mutta yhtäaikaisesti muiden kanssa

Liukuhihnoitus •2-3 puun käsittely liukuhihnoituksella: –2-3 puu on puu, jossa jokaisella sisäisellä solmulla on kaksi tai kolme lasta ja jokainen polku juuresta lehtiin on saman mittainen –h korkuisessa puussa lehtien lukumäärä on välillä 2 h - 3 h –Jos lehtien lukumäärä on n, niin puun korkeus on  (log n).

Liukuhihnoitus –2-3 puulla voidaan esittää järjestetty lista siten, että lehdet sisältävät listan elementit järjestyk- sessä vasemmalta oikealle –Välisolmuilla on muuttujat L, M ja R, jotka kertovat solmun alipuiden suurimmat elementit –Esimerkki: •A = (1,2,3,4,5,6,7) Tämä voidaan esittää 2-3 puuna. •Notaatiolla i:j:k voidaan esittää sisäisen solmun  suurimmat elementit

Liukuhihnoitus •2-3 puun perusoperaatiot –Etsintä, lisäys poisto voidaan suorittaa ajassa O(log n), kun elementtejä on n kappaletta –Etsintä voidaan helposti toteuttaa binaarisella etsinnällä –Elementin b lisäys voidaan aloittaa sen kohde- paikan etsinnällä •Etsitään lehti u siten, että tähän lehteen talletetulle a i :lle pätee a i < b < a i+1

Liukuhihnoitus –b:n arvosta riippuu tarvittavat toimenpiteet: •Jos b = a i, niin mitään ei tarvitse tehdä •Muussa tapauksessa luodaan solmu u’ –u’ asetetaan välittömästi u:n oikealle puolelle •Jos puussa on operaation jälkeen kolme alipuuta, niin voimme lopettaa •Jos alipuita on neljä, täytyy puu jakaa kahteen osaan –Lisäyksen aikana L, M ja R muuttujia päivite- tään vastaavasti

Liukuhihnoitus •Usean elementin lisääminen puuhun: –Oletetaan, että puussa on n elementtiä ja halu- amme lisätä k elementtiä, missä k < n –Jos käytetään edellistä lisäysoperaatiota peräk- käisesti, niin k elementin lisäys vie O(k log n) ajan peräkkäisesti –Liukuhihnoitusta käyttämällä voidaan sama teh- tävä suorittaa rinnakkaisesti O(log n) ajassa O(klog n) operaatiolla (kustannusoptimaalinen)

Liukuhihnoitus •Esivalmistelu: –Esivalmisteluna voidaan pitää ensimmäisen ja viimeisen elementin b 1 ja b k sijoitusta puuhun –Tällä varmistetaan, että sijoitettavat elementit mahtuvat aina kahden elementin väliin – Esivalmistelu vie ajan O(log n)

Liukuhihnoitus –Etsitään rinnakkaisesti kaikki b elementtien paikat puusta –Tämä vaihe vie O(log n) ajan ja O(k log n) operaatiota –Ryhmitellään b elementit sarjoihin, joiden tulee mahtua kahden peräkkäisen lehden väliin – Merkitään näitä sarjoja B i :llä |B i | = k i, 1 < i < n-1

Liukuhihnoitus –Luodaan alkuun lehti l i, joka sisältää b i :n ja liitetään se vanhempansa yhteyteen –1 tason välisolmuilla voi olla nyt max. 6 lasta –Kaikille 1 tason solmuille v, joilla on yli 3 lasta muodostetaan uusi välisolmu v’ ja jaetaan lap- set v:n ja v’:n välillä –Prosessia jatketaan ylöspäin kunnes saavutetaan juuri – Juuressa peräkkäiskäsittely

Liukuhihnoitus –k elemettiä voidaan lisätä puuhun O(log n) ajas- sa käyttämällä O(klog n) operaatiota, kun k i < 1 –Yleisessä tapauksessa, k i voi olla > 1, edellistä algoritmia toteutetaan ryhmien B i keskimmäi- sille elementeille –Näiden elemettien lisääminen voidaan suorittaa O(log n) ajassa. Samalla ketjun pituus puolittuu –O(log k) iteraation jälkeen kaikki elementit on saatu lisättyä puuhun. Kokonaisajaksi saadaan O(log k log n)

Liukuhihnoitus –Liukuhihnoituksella tätä aikaa voidaan parantaa –Ajatellaan yhtä askelta aina yhtenä vaiheena –Kun ensimmäisen vaiheen elementit on lisätty 1-tasolla, voidaan aloitaa toinen vaihe, … –Kukin vaihe etenee puussa ylöspäin taso kerrallaan ja muuttaa tarvittaessa puun muotoa –Algoritmi vie O(log n + log k) ajan ja O(klog n) operaatiota

Hitaan ja nopean menetelmän yhdistäminen •Accelerated cascading •Menetelmä perustuu kahden erillisen algo- ritmin yhdistämiseen: –Hidas ja kustannusoptimaalinen –Nopea ja ei-optimaalinen

Hitaan ja nopean menetelmän yhdistäminen •Joukon maksimin etsintä: –Olkoon X = {x 1, x 2, … x n } sarja elementtejä, joiden maksimi x i on tarkoitus etsiä –Peräkkäinen ratkaisu on triviaali ja voidaan ratkaista lineaarisesti ajassa O(n) •Käydään läpi kaikki elementit ja verrataan aina kulloinkin suurimpaan

Hitaan ja nopean menetelmän yhdistäminen •Oletuksia: –Oletetaan, että x i :t ovat erillisiä •Muussa tapauksessa voimme korvata x i :t parilla (x i,i) ja laajentaa relaation > seuraavasti (x i,i) > (x j,j) joss x i > x j tai x i = x j ja i > j •Maksimielementti voidaan ratkaista helposti tasapainotetulla puulla ajassa O(log n) käyttä-mällä O(n) operaatiota –Kustannusoptimaalinen ratkaisu

Hitaan ja nopean menetelmän yhdistäminen •Tasapainotetun puun käyttö muodostaa tässä menetlmässä hitaan ja optimaalisen algoritmin •Nopeampi ratkaisu saadaan käyttämällä tuplalogaritmista puurakennetta –Oletettavasti tämä ei kuitenkaan ole kustannus- optimaalinen

Hitaan ja nopean menetelmän yhdistäminen •Tuplalogaritminen puurakenne: –Puu muodostetaan siten,että solmun u alipui- den lukumäärälle pätee  n u , missä n u on puun u alipuiden lehtien määrä –Puun välisolmut sisältävät alipuidensa maksi- mielementin –Edellä esitetty ehto solmun alipuille pakottaa rakenteen tuplalogaritmiseksi

Hitaan ja nopean menetelmän yhdistäminen •Tuplalogaritmisen puurakenteen käyttökel- poisuus perustuu pitkälti vakioaikaiseen maksimin etsintään –riippumatta elementtien määrästä •Oletetaan, että tällainen algoritmi on olemassa –vie ajan O(1) ja O(p 2 ) operaatiota

Hitaan ja nopean menetelmän yhdistäminen •Oletetaan, että tuplalogaritmiselle puulle lehtien lukumäärälle pätee n = 2 2 k, missä k on jokin kokonaisluku –Puun juurella on 2 2 k-1 lasta (=  n) –Juuren lapsilla on kullakin 2 2 k-2 lasta –Yleisesti: i:nnellä tasolla välisolmulla on 2 2 k-i-1 lasta (0 < i < k-1) –Kullakin k tason solmulla on kaksi lehteä

Hitaan ja nopean menetelmän yhdistäminen •Tuplalogaritmista puuta voidaan käyttää maksimin etsintään –Kukin välisolmu sisältää alipuidensa maksimin –Algoritmi käy läpi tason kerrallaan käyttäen vakioaikaista O(1) maksimin etsintäalgoritmia  Koko puun maksimi voidaan laskea ajassa T(n) = O(log log n) Eksponentiaalisesti nopeampi kuin aiempi tasapainotettua puuta käyttävä algoritmi

Hitaan ja nopean menetelmän yhdistäminen •Operaatioiden määrälle i:nnellä tasolla saadaan: –O(( 2 2 k-i-1 ) 2 ) per solmu, 0 < i < k –Yhteensä siis O(( 2 2 k-i-1 ) 2  2 2 k -2 k-i ) = O( 2 2 k ) = O(n) per taso  W(n) = O(n log log n) Ei kustannusoptimaalinen

Hitaan ja nopean menetelmän yhdistäminen •Nopean algoritmin tekeminen kustannus- optimaaliseksi: –Koska nopea menetelmä on ei-optimaalinen ja hidas menetelmä optimaalinen, pyritään yhdistämään näiden menetelmien parhaat puolet (accelerated cascading) –Kaksi-vaiheinen lähestyminen

Hitaan ja nopean menetelmän yhdistäminen 1Aloitetaan ongelman ratkaisu optimaalisella menetelmällä ja jatketaan siihen asti kunnes saavutetaan tietty raja-arvo ongelman koossa 2Suoritetaan ongelma loppuun käyttämällä nopeaa menetelmää

Hitaan ja nopean menetelmän yhdistäminen •Maksimin laskenta: –Aloitetaan binaarisella puulla ja edetään  logloglog n  tasoa ylöspäin •koska elementtien määrä puolittuu aina tasolta ylöspäin tultaessa binääripuussa, maksimi on n’ = O(n/loglog n) elementin joukossa •Aikaa kuluu O(logloglog n) ja operaatioita O(n) –Toisessa vaiheessa tarvitaan O(loglog n’) = O(loglog n) aika O(n’ loglog n’) = O(n) operaatiota

Hitaan ja nopean menetelmän yhdistäminen •Myös peräkkäistä algoritmia voidaan käyttää vaiheessa 1 –Jaetaan joukko n/loglog n lohkoon {B i }, jotka ovat kukin n. loglog n kokoisia –Käytetään peräkkäistä algoritmia rinnakkaisesti lohkoille –Sovelletaan tuplalogaritmista algoritmia lohkoille

Symmetrian rikkominen •Symmetrian rikkomismenetelmä perustuu jonkin rakenteen muokkaamiseen rinnak- kaistukselle soveltuvaksi •Esitetään menetelmä ns. k-väritys ongelman avulla –k-värityksessä halutaan jokin alue/joukko värittää mahdollisimman vähillä väreillä tietyillä reunaehdoilla

Symmetrian rikkominen •k-väritys –Olkoon G = (V,E) suunnattu rengas, missä kustakin solmusta lähtee yksi ja kuhunkin solmuun saapuu yksi linkki –Solmujen u,v  V välillä on olemassa suunnat- tu polku –G:n k-väritys on kuvaus c:V  {0,1, …, k-1}, c(i)  c(j), jos  E

Symmetrian rikkominen •3-väritys –Halutaan määrittää edellä esitettyyn renkaaseen 3-väritys, missä vierekkäisillä solmuilla on eri värit –Peräkkäinen tapa solmujen värittämiseen on yksinkertainen, mutta ei johda nopeaan rinnakkaiseen algoritmiin •käydään läpi solmuja ja annetaan niille väri {0,1}, viimeiselle solmulle voidaan joutua antamaan väri 3

Symmetrian rikkominen –Suurin ongelma tehtävässä on renkaan symmet- ria –Värien määritys solmuille rinnakkaisesti vaatii niiden erottamista muista, mutta kaikki solmut ovat samanlaisia –Tarvitaan jokin menetelmä, jolla solmut voi- daan jakaa luokkiin ja luokat sitten värjätään eri väreillä

Symmetrian rikkominen –Määritellään renkaan linkit vektorilla S(i) S(i) = j, kun  E, 1 < i,j < n –Määritellään kullekin solmulle edeltäjä P P(S(i)) = i, 1 < i < n –Oletetaan, että solmuilla on alustava väritys Esim. kullekin oma värinsä c(i) = i –Esitetään värit binäärisessä muodossa –Värejä voidaan vähentää yksinkertaisella algoritmilla (2.9) rinnakkaisesti

Symmetrian rikkominen –Algoritmi suorituu vakioajassa O(1) tehden O(n) operaatiota –Käytetään edellisen algoritmin antamaa tulosta perustana nopean 3-väritys algoritmin suunnittelussa •Eli edellinen algoritmi antaa aloitusvärit renkaalle –Olkoon t > 3 alkuperäisessä värityksessä c värien määrittelyyn käytettyjen bittien määrä

Symmetrian rikkominen –Uudessa värityksessä c’ värit voidaan määrittää  log t  + 1 bitillä –Jos värien määrä c:ssä on q, niin q:lle pätee 2 t-1 < q < 2 t •c’:ssa värejä käytetään maksimissaan 2  log t  + 1 = O(t) = O(log q) •Värien määrä vähenee eksponentiaalisesti –Perusväritysalgoritmia voidaan toistaa useasti • Toistot pienentävät värien määrää niinkauan kuin bittien määrälle pätee t >  log t  + 1 eli t > 3

Symmetrian rikkominen –Jos t=3, niin tällöin saavutetaan väritys, joka käyttää 6 väriä •Uusille väreille on määritelty c’(i) = 2k + c(i) k ja siis 0 < c’(i) < 5, kun 0 < k < 2 –Määritellään log (i) x = log(log (i-1) x) •log*x = min{i | log (i) x <= 1} •log*x kasvaa hitaasti (rajana 5, x < ) –Värien määrää voidaan useilla iteraatioilla pudottaa ja O(log*n) iteraatiolla päästään kuuteen väriin

Symmetrian rikkominen –Värien määrä saadaan pudotettua kolmeen seuraavasti: •Ylimääräinen väritys koostuu kolmesta iteraatiosta, joista kukin käsittelee erivärisiä solmuja •Kaikille väreille 3 <= l <= 5 tehdään seuraavaa: –Kaikille solmuille i, joka on l värinen, väritetään se pienimmällä mahdollisella värillä {0,1,2} (siten, että se eroaa naapureistaan) –Kukin iteraatio vie vakioajan O(1) ja käyttää O(n) operaatiota –3-väritys vie O(log*n) ajan ja O(n log*n) ope- raatiota

Symmetrian rikkominen •Optimaalinen 3 väritys algoritmi: –Edellä esitetty 3-väritys algoritmi rikkoo symmetrian suunnatussa renkaassa nopeasti, mutta käyttää ei-optimaalisen (epälineaarisen) määrän operaatioita –Algoritmi toimii yksinkertaisesti mutta jos halutaan optimaalinen suoritus, täytyy käyttää hieman muunneltua algoritmia

Symmetrian rikkominen –Oletetaan, että n kokonaisluvun lajittelu voi- daan suorittaa O(log n) ajassa lineaarisella määrällä operaatioita –Optimaalinen algoritmi: •solmujen väritys perusalgoritmilla •solmujen järjestämisestä niiden värin mukaan (eli lopputuloksena saadaan kaikki samanväriset solmut peräkkäin •Soveltamalla uudelleenväritysalgoritmia kaikkiin samanvärisiin solmuihin

Symmetrian rikkominen –Algoritmin lopputuloksena saamme väritettyä renkaan solmut kolmella värillä O(log n) ajassa ja O(n) operaatiolla •Vaiheet 1 ja 2 vievät ajan O(1) ja O(n) operaatiota •Vaihe 2 vie lajittelulle määrätyn ajan ja operaatiot •Lajittelun jälkeen samaa väriä olevat elementit ovat peräkkäisissä paikoissa, joten näiden uudelleen- värjäys vie ajan O(1) ja O(n i ) operaatiota, missä n i on värillä i värjättyjen somujen lukumäärä – Näinollen 4. vaihe vie ajan O(log n) ja O(  i n i ) = O(n) operaatiota