CS-A1140 Tietorakenteet ja algoritmit

Transkriptio

1 CS-A1140 Tietorakenteet ja algoritmit Kierros 6: Dynaaminen ohjelmointi ja ahneet algoritmit Tommi Junttila Aalto-yliopisto Perustieteiden korkeakoulu Tietotekniikan laitos Syksy 2016

2 Materiaalia kirjassa Introduction to Algorithms, 3rd ed. (online via Aalto lib): Dynaaminen ohjelmointi: kappaleet 15.0, 15.1 ja 15.4 Ahneiden algoritmien perusteet: kappaleet 16.1 ja 16.2 Materiaalia muualla ja linkkejä: wikipedia-artikkeli dynaamisesta ohjelmoinnista wikipedia-artikkeli ahneista algoritmeista MIT Open Courseware video (videon toisen puoliskon lyhimpien polkujen algoritmeihin palataan myöhemmin kurssilla) 2/50

3 Dynaaminen ohjelmointi 3/50

4 Huom! Dynaaminen ohjelmointi on yleinen algoritmien suunnitteluperiaate Se soveltuu monien optimointiongelmien ratkaisemiseen; näissä on tavoitteena löytää paras ratkaisu ongelmaan Lyhyesti ja karkeasti kuvattuna se on täydellinen rekursiivinen haku osaongelmien ratkaisujen tallentamisella täydennettynä Termi dynaaminen ohjelmointi johtuu historiallisista syistä, lue lisää esim. tästä wikipedia-artikkelista Dynaaminen ohjelmointi saattaa olla aluksi hieman vaikea sisäistää. Jos näin on, hyvä lukumetodi kalvoille on ehkäpä seuraava: Yritetään ensin ymmärtää ideat Sitten voi tarkastella koodia Ja lopuksi tutustua ajoaika- ja muistin käytön analyyseihin 4/50

5 Esimerkki I: Fibonaccin luvut Aloitetaan erittäin yksinkertaisella esimerkillä (tuttu jo edellisiltä kursseilta) Fibonaccin lukujono F n = 0,1,1,2,3,5,8,... määritellään rekursiivisesti kaavoilla F 0 = 0, F 1 = 1 ja F n = F n 1 + F n 2 for n 2 Lukujen laskeminen helppoa rekursiivisesti def f i b ( n : I n t ) : B i g I n t = { r e q u i r e ( n >= 0) i f ( n == 0) 0 else i f ( n == 1) 1 else f i b ( n 1) + f i b ( n 2) 5/50

6 Kutsupuu laskettaessa arvoa fib(6): fib(6) fib(5) fib(4) fib(4) fib(3) fib(3) fib(2) fib(3) fib(2) fib(2) fib(1) fib(2) fib(1) fib(1) fib(0) fib(2) fib(1) fib(1) fib(0) fib(1) fib(0) fib(1) fib(0) fib(1) fib(0) Moni funktiokutsu esiintyy useasti kutsupuussa Toisin sanoen sama aliongelma fib(i) ratkaistaan monta kertaa Tämä heijastuu ajoaikaan: scala > measurecputime { f i b (45) res2 : ( BigInt, Double ) = ( , ) 6/50

7 Mikä on tämän rekursiivisen algoritmin ajoaika? Rekursioyhtälö jos oletetaan lukujen yhteenlaskun olevan vakioaikaista: T(n) = T(n 2) + T(n 1) +O(1) ja T(1) = T(0) = O(1) Saadaan helposti alarajoja: T(n) F n = ϕn ( 1 ϕ )n 5 = ϕn 5 ( ϕ 1 )n 5 = Ω(ϕ n ), missä ϕ = on kultainen leikkaus T(n) 2T(n 2) +O(1) ja siten T(n) = Ω(2 n/2 ) Algoritmin ajoaika on vähintään eksponentiaalinen 7/50

8 Tarkennetaan vielä hiukan analyysiä Itse asiassa lukujen yhteenlasku tässä ei ole vakioaikaista koska lukujen F n binääriesityksen pituus kasvaa lineaarisesti suhteessa arvoon n termin O(1) rekursioyhtälössä pitäisi olla Ω(n) Huomataan myös: n on funktion argumentin arvo, ei sen binääriesityksen pituus Jos funktiota fib kutsutaan m-bittisellä arvona n, niin ajoaika on Ω(ϕ 2m ) suhteessa syötteen kokoon m 8/50

9 Fibonaccin luvut dynaamisella ohjelmoinnilla Sen sijaan, että laskettaisiin arvoja fib(i) uudelleen ja uudelleen, tallennetaan jo lasketut arvot assosiatiiviseen kuvaukseen ja käytetään näitä aina kun mahdollista (engl. memoization) def f i b ( n : I n t ) : B i g I n t = { r e q u i r e ( n >= 0) val m = scala. c o l l e c t i o n. mutable.map[ I n t, B i g I n t ] ( ) def i n n e r ( i : I n t ) : B i g I n t = m. getorelseupdate ( i, { i f ( i == 0) 0 else i f ( i == 1) 1 else i n n e r ( i 1) + i n n e r ( i 2) ) i n n e r ( n ) Ajoaika parantuu huomattavasti scala > measurecputime { f i b (1000) res14 : ( BigInt, Double ) = ( <A number with 209 d i g i t s >, ) Tämä osatulosten tallentaminen on dynaamisen ohjelmoinnin avainkomponentti 9/50

10 Kutsupuu arvolle fib(6) osatulosten tallentamisella: fib(6) fib(5) fib(4) fib(4) fib(3) fib(3) fib(2) fib(3) fib(2) fib(2) fib(1) fib(2) fib(1) fib(1) fib(0) fib(2) fib(1) fib(1) fib(0) fib(1) fib(0) fib(1) fib(0) fib(1) fib(0) Vihreät solmut kuvaavat kutsuja, joiden arvo löytyy jo tallennettuna ja joiden alikutsupuita (punaisella) ei siis käydä läpi lainkaan 10/50

11 Uuden version ajoaika? Erilaisten kutsukertojen lukumäärä kerrottuna kussakin kuluvalla ajalla Oletetaan vakioaikainen lukujen yhteenlasku ja haku/päivitys-operaatiot kuvauksilla 1 : n O(1) = O(n) Ei tarvetta rekursioyhtälöille tällöin Otettaessa huomioon kahden Θ(n)-bittisen luvun yhteenlaskuun kuluva lineaarinen aika saadaan rekursioyhtälö Muistin käyttö? Θ(n 2 ) T(n) = T(n 1) + Θ(n) = Θ(n 2 ) 1 Kuten ollaan aiemmin nähty, haku/päivitys-operaatiot ovat kuvauksille itse asiassa O(logn) tai keskimäärin O(1) 11/50

12 Rekursiivinen verio ei ole häntärekursiivinen ja voi siis kuluttaa kaiken pinomuistin ( stack overflow error ) Sama laskenta voidaan tehdä helposti myös iteratiivisesti alhaalta ylös (engl. bottom-up), alkaen arvosta fib(0) ja tallentaen tulokset taulukkoon def f i b ( n : I n t ) : B i g I n t = { r e q u i r e ( n >= 0) val m = new Array [ B i g I n t ] ( n+1 max 2) m( 0 ) = 0 m( 1 ) = 1 for ( i < 2 to n ) m( i ) = m( i 2) + m( i 1) m( n ) scala > measurecputime { f i b (1000) res17 : ( BigInt, Double ) = ( <A number with 209 d i g i t s >, E 4) Taulukoille haku- ja päivitysoperaatiot ovat vakioaikaisia Muistin käyttö? Θ(n 2 ) 12/50

13 Itse asiassa tarvitsee muistaa vain kaksi edellistä arvoa saadaan muistin käyttöä pienemmäksi Aloitetaan arvoista F 0 ja F 1 ja jatketaan arvoon F n def f i b ( n : I n t ) : B i g I n t = { r e q u i r e ( n >= 0) i f ( n == 0) return 0 var fprev = B i g I n t ( 0 ) var f = B i g I n t ( 1 ) for ( i < 1 u n t i l n ) { val fnew = fprev + f fprev = f f = fnew return f scala > measurecputime { f i b (1000) res48 : ( BigInt, Double ) = ( <A number with 209 d i g i t s >,6.0929E 4) Muistin käyttö? Θ(n) 13/50

14 Sama funktionaalisella tyylillä def f i b ( n : I n t ) : B i g I n t = { r e q u i r e ( n >= 0) i f ( n == 0) 0 else (1 u n t i l n ). f o l d L e f t [ ( B i g I n t, B i g I n t ) ] ( 0, 1 ) ( { case ( ( fprev, f ), i ) => ( f, fprev+ f ) ). _2 14/50

15 Ongelman ratkaiseminen dynaamisella ohjelmoinnilla 1. Määritellään (optimaalinen) ratkaisu (optimaalisten) osaratkaisujen avulla Tuloksena (optimaalisen) ratkaisun rekursiivinen määritelmä Fibonaccin lukujen esimerkissä ei ole optimaalisuuden vaatimusta ja rekursiivinen määritelmä oli jo valmiiksi annettuna 2. Tarkastellaan, esiintyvätkö osaratkaisut useaan kertaan rekursiivisessa kutsupuussa 3. Jos esiintyvät, käytetään osaratkaisujen tallentamista tai tehdään iteratiivinen versio, joka tuottaa osaratkaisut taulukkoon 2 2 Jos eivät esiinny, niin osaongelmat eivät limity ja dynaaminen ohjelmointi ei toimi. Joskus voi olla mahdollista tehdä ongelmalle toisenlainen rekursiivinen määritelmä, jossa osaongelmat limittyvät. 15/50

16 Esimerkki II: Tangon leikkaaminen Nyt rekursiivista määritelmää ei ole annettu valmiina vaan se joudutaan keksimään Tarkastellaan seuraavaa optimointiongelmaa: Annettuna materiaalitanko, jonka pituus on n yksikköä sekä taulukko (p 1,...,p n ) hintoja, jossa jokainen hinta p i määrää rahasumman, joka saadaan myymällä i yksikön mittainen pala tangosta. Tangon leikkaaminen paloihin on ilmaista. Mikä on paras tapa leikata tanko paloihin niin, että saadaan paras kokonaistuotto? 16/50

17 Esimerkki: Jos tangon pituus alussa on 4 ja hinnat ovat 2 rahayksikköä tangonpaloille, joiden pituus on 1, 4 rahayksikköä tangonpaloille, joiden pituus on 2, 7 rahayksikköä tangonpaloille, joiden pituus on 3 ja 8 rahayksikköä tangonpaloille, joiden pituus on 4. Tuottavin tapa leikata tanko paloihin on tehdä yksi 1 yksikön pala ja yksi 3 yksikön pala. Näiden myyminen tuottaa 9 rahayksikköä. 17/50

18 Optimaalisen ratkaisun rekursiivinen määrittely Kuinka leika n yksikön tanko paloihin parhaalla tavalla? Olkoon maksimituotto s(n) s(n) on suurin seuraavista: Leikataan pois 1 yksikön pala ja sen jälkeen leikataan jäljelle jäävä n 1 mittainen tanko parhaalla tavalla tuotto on p 1 + s(n 1) Leikataan pois 2 yksikön pala ja sen jälkeen leikataan jäljelle jäävä n 2 mittainen tanko parhaalla tavalla tuotto on p 2 + s(n 2)... Leikataan pois n 1 yksikön pala ja sen jälkeen leikataan jäljelle jäävä 1 mittainen tanko parhaalla tavalla tuotto on p n 1 + s(1) Ei tehdä leikkauksia, tuotto on p n s(n) on siis s(n) = max i=1,...,n (p i + s(n i)) missä s(0) = 0, jotta saadaan viimeinen ei leikkauksia -tapaus hoidettua yhtenäisellä tavalla 18/50

19 Rekursiivisen määrittelyn avulla ongelman ratkaisevan ohjelman toteutus on suoraviivaista Scala-kielellä def cut ( n : I n t, p r i c e s : Array [ I n t ] ) = { r e q u i r e ( prices. length >= n+1) r e q u i r e ( p r i c e s ( 0 ) == 0 && p r i c e s. f o r a l l ( _ >= 0) ) def i n n e r ( k : I n t ) : Long = { i f ( k == 0) 0 else { var best : Long = 1 for ( i < 1 to k ) best = best max ( p r i c e s ( i ) + i n n e r ( k i ) ) best i n n e r ( n ) 19/50

20 Sama funktionaalisella tyylillä def cut ( n : I n t, p r i c e s : Array [ I n t ] ) = { r e q u i r e ( prices. length >= n+1) r e q u i r e ( p r i c e s ( 0 ) == 0 && p r i c e s. f o r a l l ( _ >= 0) ) def i n n e r ( k : I n t ) : Long = { i f ( k == 0) 0 else (1 to k ). i t e r a t o r.map( i => p r i c e s ( i ) + i n n e r ( k i ) ). max i n n e r ( n ) Miksi yllä on käytetty iteraattoria? 20/50

21 Kutsupuu kun n = 4 cut(4, prices) inner(4) inner(3) inner(2) inner(1) inner(0) inner(2) inner(1) inner(0) inner(1) inner(0) inner(0) inner(1) inner(0) inner(0) inner(0) inner(0) 21/50

22 Ajoaika? Kun tangon pituus on n, niin leikkauksia voidaan tehdä n 1 kohdasta on olemassa 2 n 1 tapaa leikata tanko koska algoritmi käy läpi jokaisen, sen ajoaika on Θ(2 n ) Voitaisiin parantaa rekursiivista ratkaisua ottamalla ensin kaikki yhden yksikön leikkaukset, sitten kahden yksikön jne. Tällä menettelyllä eri tapoja leikata tanko on sama määrä kuin tapoja osittaa luonnollinen luku n yhteenlaskettaviin. Tämä määrä kasvaa asymptoottisesti nopeammin kuin mikä tahansa muuttujan n polynomi (katso esim. partition function). 22/50

23 Dynaamisen ohjelmoinnin ratkaisu tallentamisella Koska osaongelmat esiintyvät useasti kutsupuussa, voidaan jälleen käyttää niiden ratkaisujen tallentamista def cut ( n : I n t, p r i c e s : Array [ I n t ] ) = { r e q u i r e ( prices. length >= n+1) r e q u i r e ( p r i c e s ( 0 ) == 0 && p r i c e s. f o r a l l ( _ >= 0) ) val m = scala. c o l l e c t i o n. mutable.map[ I n t, Long ] ( ) def i n n e r ( k : I n t ) : Long = m. getorelseupdate ( k, { i f ( k == 0) 0 else { var best : Long = 1 for ( i < 1 to k ) best = best max ( p r i c e s ( i ) + i n n e r ( k i ) ) best ) i n n e r ( n ) 23/50

24 Kutsupuu osaongelmien ratkaisujen tallentamisella kun n = 4 cut(4, prices) inner(4) inner(3) inner(2) inner(1) inner(0) inner(2) inner(1) inner(0) inner(1) inner(0) inner(0) inner(1) inner(0) inner(0) inner(0) inner(0) Jälleen vihreiden solmujen ratakaisut löytyvät tallennettuina ja niiden punaisia alipuita ei käydä ikinä läpi Ajoaika: T(0) = O(1) and T(n) = O(n) + T(n 1) = O(n 2 ) 24/50

25 Ratkaisun konstruointi Tangonleikkausongelmassa pelkkä maksimituotto ei välttämättä riitä vaan tahdotaan tietää myös kuinka se saadaan aikaiseksi eli millaisiin paloihin tanko tulee leikata sen aikaansaamiseksi Tämä tieto saadaan talteen yksinkertaisesti muistamalla jokaisella kutsulla inner(k) parhaan tuoton lisäksi myös se, miten se saatiin aikaiseksi 3 3 parhaita tapoja voi olle useita mutta pidetään muistissa vain yhtä koska vastaavia tapoja voi olla erittäin suuri määrä 25/50

26 Idea koodina def cut ( n : I n t, p r i c e s : Array [ I n t ] ) = { r e q u i r e ( prices. length >= n+1) r e q u i r e ( p r i c e s ( 0 ) == 0 && p r i c e s. f o r a l l ( _ >= 0) ) val m = scala. c o l l e c t i o n. mutable.map[ I n t, ( Long, L i s t [ I n t ] ) ] ( ) def i n n e r ( k : I n t ) : ( Long, L i s t [ I n t ] ) = m. getorelseupdate ( k, { i f ( k == 0) ( 0, N i l ) else { var best : Long = 1 var bestcuts : L i s t [ I n t ] = null for ( i < 1 to k ) { val ( subvalue, subcuts ) = i n n e r ( k i ) i f ( subvalue + p r i c e s ( i ) > best ) { best = subvalue + p ric es ( i ) bestcuts = i : : subcuts ( best, bestcuts ) ) i n n e r ( n ) Ajoaika on edelleen O(n 2 ) 26/50

27 Sama iteratiivisella alhaalta ylös -tyylillä ja taulukoilla: def cut ( n : I n t, p r i c e s : Array [ I n t ] ) = { r e q u i r e ( prices. length >= n+1) r e q u i r e ( p r i c e s ( 0 ) == 0 && p r i c e s. f o r a l l ( _ >= 0) ) val m = new Array [ ( Long, L i s t [ I n t ] ) ] ( n+1) m( 0 ) = ( 0, N i l ) / / The base case for ( k < 1 to n ) { var best : Long = 1 var bestcuts : L i s t [ I n t ] = null for ( i < 1 to k ) { val ( subvalue, subcuts ) = m( k i ) i f ( subvalue + p r i c e s ( i ) > best ) { best = subvalue + p rice s ( i ) bestcuts = i : : subcuts m( k ) = ( best, bestcuts ) m( n ) Muistin käyttö: Θ(n) Miksi parhaiden ratkaisujen tallentaminen ei nosta muistinkäyttöä neliölliseksi eli Θ(n 2 )? 27/50

28 Kertaus: milloin dynaaminen ohjelmointi toimii? Yleisesti ottaen, dynaamista ohjelmointia voidaan käyttää kun 1. (optimaalinen) ratkaisu voidaan määritellä käyttämällä pienempiä (optimaalisia) osaongelmien ratkaisuja ja 2. osaongelmat limittyvät eli saman osaongelman ratkaisua tarkastellaan useasti 28/50

29 Esimerkki III: Pisin yhteinen osamerkkijono Vielä yksi esimerkki... Tarkastellaan kahta merkkijonoa X = (x 1,...,x n ) ja Y = (y 1,...,y m ) Nämä voisivat olla vaikkapa DNA-sekvenssejä, tekstejä tms Tällaisten jonojen samankaltaisuudelle on monta erilaista määritelmää Tarkastellaan seuraavassa erästä: merkkijonojen X ja Y yhteinen osamerkkijono on merkkijono Z = (z 1,...,z k ), jonka merkit esiintyvät tässä järjestyksessä kummassakin merkkijonossa X ja Y pisin yhteinen osamerkkijono (engl. longest common subsequence, LCS) on yhteinen osamerkkijono, jolla on suurin mahdollinen pituus Mitä pidempiä pisimmät yhteiset osamerkkijonot ovat, sitä samankaltaisempia merkkijonot ovat Pisimmän yhteisen osamerkkijonon ongelma on: annettuna kaksi merkkijonoa, etsi yksi niiden pisimmistä yhteisistä osamerkkijonoista 29/50

30 Esimerkki: Tarkastellaan merkkijonoja X = (A, C, G, T, A, T) ja Y = (A, T, G, T, C, T). Niiden (yksikäsitteinen) pisin yhteinen osamerkkijono on (A,G,T,T). Esimerkki: Pisimpiä yhteisiä osamerkkijonoja voi olla useita; merkkijonojen X = (C,C,C,T,T,T) ja Y = (T,T,T,C,C,C) pisimmät yhteiset osamerkkijonot ovat (C,C,C) ja (T,T,T) Yksinkertainen ratkaisu pisimpien yhteisten osamerkkojonojen löytämiselle olisi tuottaa ( pisin ensin -järjestyksessä) toisen merkkijonon kaikki osamerkkijonot ja tarkastaa, löytyvätkö ne toisesta merkkijonosta Tämä olisi tehotonta koska osamerkkijonoja on eksponentiaalinen määrä 30/50

31 Rekursiivinen määritelmä Jotta voitaisiin käyttää dynaamista ohjelmointia, määritellään optimiratkaisu pienempien optimaalisten osaratkaisujen avulla Merkitään merkkijonjen X ja Y alkuosia seuraavasti: X i = (x 1,...,x i ) kun 0 i n ja Y j = (y 1,...,y i ) kun 0 j m Idea: tarkastellaan merkkijonojen X n = (x 1,...,x n ) ja Y m = (y 1,...,y m ) viimeisiä merkkejä Jos x n = y m, niin saadan merkkijonjen X n ja Y m eräs LCS ottamalla merkkijonojen X n 1 ja Y m 1 mikä tahansa LCS ja lisäämällä sen loppuun merkki x n Jos x n y m ja merkkijonojen X n ja Y m LCS Z ei sisällä merkkiä x n viimeisempänä, niin Z on merkkijonojen X n 1 ja Y m LCS Jos x n y m ja merkkijonojen X n ja Y m LCS Z ei sisällä merkkiä y m viimeisempänä, niin Z on merkkijonojen X n ja Y m 1 LCS Perustapauksessa n = 0 tai m = 0; tällöin LCS on tyhjä merkkijono pituudeltaan 0 31/50

32 Esimerkki: Esitellään määritelmän eri tapauksia: 1. Jos X 6 = (A,C,G,T,A,T) ja Y 5 = (A,G,C,C,T), niin niiden pisimmät yhteiset osamerkkijonot ovat (A, C, T) ja (A, G, T). Nämä molemmat saadaa kahdesta merkkijonojen X 5 = (A,C,G,T,A) ja Y 4 = (A,G,C,C) pisimmästä yhteisestä osamerkkijonosta (A, C) ja (A, G) lisäämällä niiden loppuun merkki T 2. Jos X 5 = (A,G,C,A,C) ja Y 6 = (A,C,G,T,A,T), niin niiden pisimmät osamerkkijonot ovat (A, C, A) ja (A, G, A). Kumpikaan ei sisällä merkkiä C viimeisenä merkkinä ja molemmat ovat merkkijonojen X 4 = (A,G,C,A) ja Y 6 = (A,C,G,T,A,T) pisimmät yhteiset osamerkkijonot 3. Kolmas tapaus on symmetrinen edellisen tapauksen kanssa 32/50

33 Jälleen kerran toteutuksen tekeminen rekursiivisen määrittelyn avulla on helppoa: def l c s ( a : String, b : S t r i n g ) = { def i n n e r ( n : I n t, m: I n t ) : S t r i n g = { i f ( n < 0) " " else i f (m < 0) " " else i f ( a ( n ) == b (m) ) i n n e r ( n 1, m 1) + a ( n ) else Seq ( i n n e r ( n 1, m), i n n e r ( n, m 1) ). maxby( _. length ) i n n e r ( a. length 1, b. length 1) Huom: indeksointi alkaa indeksistä 0, ei 1 kuten matemaattisessa määritelmässä Ajoaika on jälleen eksponentiaalinen pahimmassa tapauksessa... mutta aika hyvä joillekin syötteille, esim. lcs("abcab","cab"). Miksi? Merkkien lisääminen merkkijonojen loppuun ei myöskään ole tehokasta eli myös tässä suhteessa ensimmäinen toteutus jättää parantamisen varaa 33/50

34 Eräs kutsupuu lcs('abac','acab') inner(3,3) inner(2,3) inner(3,2) inner(1,3) inner(2,2) inner(2,2) inner(3,1) inner(0,2) inner(1,1) inner(1,1) inner(2,0) inner(-1,1) inner(0,1) inner(1,0) inner(0,1) inner(1,0) inner(1,-1) inner(-1,1) inner(0,0) inner(0,0) inner(1,-1) inner(-1,1) inner(0,0) inner(0,0) inner(1,-1) inner(-1,-1) inner(-1,-1) inner(-1,-1) inner(-1,-1) 34/50

35 Toinen kutsupuu lcs('ccc','bbb') inner(2,2) inner(1,2) inner(2,1) inner(0,2) inner(1,1) inner(1,1) inner(2,0) inner(-1,2) inner(0,1) inner(0,1) inner(1,0) inner(0,1) inner(1,0) inner(1,0) inner(2,-1) inner(-1,1) inner(0,0) inner(-1,1) inner(0,0) inner(0,0) inner(1,-1) inner(-1,1) inner(0,0) inner(0,0) inner(1,-1) inner(0,0) inner(1,-1) inner(-1,0) inner(0,-1) inner(-1,0) inner(0,-1) inner(-1,0) inner(0,-1) inner(-1,0) inner(0,-1) inner(-1,0) inner(0,-1) inner(-1,0) inner(0,-1) 35/50

36 Osatulosten tallentaminen (vain pituus, ei osamerkkijonoa) def l c s ( a : String, b : S t r i n g ) = { val mem = scala. c o l l e c t i o n. mutable. HashMap [ ( I n t, I n t ), I n t ] ( ) def i n n e r ( n : I n t, m: I n t ) : I n t = mem. getorelseupdate ( ( n, m), { i f ( n < 0) 0 else i f (m < 0) 0 else i f ( a ( n ) == b (m) ) i n n e r ( n 1, m 1) + 1 else Seq ( i n n e r ( n 1, m), i n n e r ( n, m 1) ). max ) i n n e r ( a. length 1, b. length 1) Perustele seuraava väite: Algoritmin ajoaika on O(nm), missä n on merkkijonon a pituus ja m merkkijonon b 36/50

37 Osatulosten tallentaminen ja parhaan osamerkkijonon konstruointi def l c s ( a : String, b : S t r i n g ) = { val mem = scala. c o l l e c t i o n. mutable. HashMap [ ( I n t, I n t ), I n t ] ( ) def i n n e r ( n : I n t, m: I n t ) : I n t = mem. getorelseupdate ( ( n, m), { i f ( n < 0) 0 else i f (m < 0) 0 else i f ( a ( n ) == b (m) ) i n n e r ( n 1, m 1)+1 else Seq ( i n n e r ( n 1, m), i n n e r ( n, m 1) ). max ) i n n e r ( a. length 1, b. length 1) def r e c o n s t r u c t ( n : I n t, m: I n t ) : L i s t [ Char ] = { i f ( n < 0) N i l else i f (m < 0) N i l else i f ( a ( n ) == b (m) ) a ( n ) : : r e c o n s t r u c t ( n 1, m 1) else i f (mem( ( n, m) ) == mem( n 1, m) ) r e c o n s t r u c t ( n 1, m) else reconstruct ( n,m 1) r e c o n s t r u c t ( a. length 1, b. length 1). reverse. mkstring ( " " ) 37/50

38 Iteratiivinen versio Rekursiivisten toteutusten suurin haitta, myös osatulosten tallentamisen yhteydessä, on suurten rekursiosyvyyksien aiheuttama pinomuistin loppuminen ( stack overflow error ) järjestelmissä, joissa rekursiopinolle on varattu vain kiinteä määrä muistia Esimerkiksi edellä annetun Scala-ohjelman ajaminen tuhansien merkkien pituisilla merkkijonoilla, joilla on pitkä LCS, saa aikaan pinomuistin loppumisen tyypillisesti konfiguroidussa Java-virtuaalikoneessa Esitellään siis iteratiivinen versio, joka tallentaa merkkijonojen X i ja Y j pisimmän yhteisen osamerkkijon pituuden 2-uloitteisen taulukon table alkioon table[i,j] ja työskentelee alhaalta ylöspäin alkaen perustapauksista i = 0 ja j = 0 sekä laskien arvot table[i-1,j], table[i,j-1] ja table[i-1,j] ennen arvoa table[i,j] lopputulos on alkiossa table(n,m) 38/50

39 def l c s ( x : String, y : S t r i n g ) : S t r i n g = { val ( n, m) = ( x. length, y. length ) val t a b l e = Array. t a b u l a t e [ I n t ] ( n+1,m+1) ( { case ( i, j ) => 0 ) for ( i < 1 to n ; j < 1 to m) { i f ( x ( i 1) == y ( j 1) ) t a b l e ( i ) ( j ) = t a b l e ( i 1) ( j 1) + 1 else i f ( t a b l e ( i 1) ( j ) >= t a b l e ( i ) ( j 1) ) t a b l e ( i ) ( j ) = t a b l e ( i 1) ( j ) else t a b l e ( i ) ( j ) = t a b l e ( i ) ( j 1) / / Reconstruct a s o l u t i o n var i = n var j = m var s o l u t i o n : L i s t [ Char ] = N i l while ( i > 0 && j > 0) { i f ( x ( i 1) == y ( j 1) ) { s o l u t i o n = x ( i 1) : : s o l u t i o n i = 1 j = 1 else i f ( t a b l e ( i 1) ( j ) >= t a b l e ( i ) ( j 1) ) i = 1 else j = 1 s o l u t i o n. mkstring ( " " ) 39/50

40 Muodostetaan taulukko merkkijonoille X = (A, G, C, T, C, T) ja Y = (A,C,G,T,A,T) A G C T C T A 0 1 C 2 G 3 T 4 A 5 T Nuolet kuvaavat suuntaa/suuntia, jotka tuottavat pisimmän yhteisen osamerkkijonon 40/50

41 Ahneet algoritmit 41/50

42 Edellisissä esimerkeissä dynaamisen ohjelmoinnin piti tutkia monia osaongelmia: minkä kokoinen pala leikataan ensin tangosta? kaksi tapausta kun x n y m pisimmän yhteisen osamerkkijonon ongelmassa Joskus on mahdollista valita ahneesti vain yksi tapaus ja täten käytännössä redusoida ongelma yhdeksi pienemmäksi osaongelmaksi Tarkastellaan seuraavassa yhtä yksinkertaista ahnetta algoritmia Verkkoja käsittelevällä kierroksella nähdään muita ahneita algoritmeja kun tarkastellaan pienimmän virittäjäpuun ongelmaa 42/50

43 Esimerkki IV: Toimintojen valinta -ongelma Annettuna äärellinen joukko toimintoja A = {a 1,...,a n Jokaiseen toimintoon a i on liitetty aloitusaika s i ja lopetusaika f i siten, että s i < f i Toiminto suoritetaan puoliavoimena ajanjaksona [s i,f i ) Kaksi toimintoa, a i ja a j kun i j, ovat yhteensopivia jos niitä ei suoriteta yhtä aikaa eli jos joko f i s j tai f j s i Tehtävänä on löytää (jokin) maksimaalinen osajoukko A A siten, että kaikki toiminnot osajoukossa ovat keskenään yhteensopivia 43/50

44 Esimerkki: Tarkastellaan seuraavaa toimintojen joukkoa A = {a 1,...,a 11, missä i s i f i Eräs maksimaalinen keskenään yhteensopivien toimintojen joukko on {a 2,a 4,a 9,a 11. a 4 a 5 a 6 a 10 a 3 a 9 a 1 a 2 a 7 a 8 a 11 44/50

45 Dynaamiseen ohjelmointiin perustuva ratkaisu Olkoon toimintojen joukko A = {a 1,...,a n Olkoon A l,u = {a i A l s i f i u niiden toimintojen joukko, joiden suoritus (i) alkaa ajanhetkenä l tai myöhemmin ja (ii) loppuu ennen ajanhetkeä u Tällöin A = A L,U, missä L = min i {1,...,n s i ja U = max i {1,...,n f i Jokaisella (osa)ongelmalla A l,u on seuraava optimaalisen osaongelman ominaisuus: Olkoon a i A l,u mikä tahansa toiminto Olkoot A l,s i ja A f i,u mitä tahansa maksimaalisia keskenään yhteensopivia toimintojen joukkoja osaongelmilla A l,si and A fi,u Tällöin A l,u at i = A l,s i {a i A f i,u on (eräs) sellainen suurin keskenään yhteensopivien toimintojen osajoukko (osa)ongelmalle A l,u, joka sisältää toiminnon a i Saadaan siis osaongelman A l,u maksimaalinen keskenään yhteensopivien toimintojen osajoukko A l,u ottamalla suurin joukosta {A l,u at j a j A l,u Ratkaisu alkuperäiseen ongelmaan on A L,U 45/50

46 On saatu rekursiivinen määritelmä ongelmalle ja tästä saadaan dynaamisen ohjelmoinnin algoritmi ongelmalle Huomaa, että riittää tarkastella (n + 1) (n + 1) kappaletta osaongelmia A l,u Täten dynaamisen ohjelmoinnin algoritmi saadaan helposti toimimaan polynomisessa ajassa Tämä ei päde suoraviivaiselle ratkaisulle, jossa listataan kaikki joukon A osajoukot, tarkastetaan jokaisen keskinäinen yhteensopivuus ja muistetaan suurin löydetty keskenään yhteensopiva osajoukko. Koska osajoukkoja on eksponentiaalinen määrä, myös tämän ratkaisun ajoaika olisi eksponentiaalinen. 46/50

47 Ahne algoritmi ongelmalle Toimintojen valinta -ongelmalla on eräs ominaisuus, jota voidaan käyttää vielä yksinkertaisemman ja nopeamman algoritmin tekemiseen Ei nimittäin tarvitse tarkastella kaikkia kulloisen osajoukon toimintoja vaan riittää valita toiminto, joka päättyy mahdollisimman aikaisin ja tämän jälkeen tarkastella osaongelmaa, josta tämä toiminto ja kaikki sen kanssa epäyhteensopivat toiminnot on poistettu Tämä optimointi perustuu havaintoon, että jos on olemassa maksimaalinen keskenään yhteensopivien toimintojen osajoukko, joka ei sisällä aikaisimmin päättyvää toimintoa a i, niin voidaan korvata osajoukon toinen toiminto toiminnolla a i ja saada aikaan yhtä suuri maksimaalinen keskenään yhteensopivien toimintojen joukko 47/50

48 Teoreema Olkoot A A maksimaalinen keskenään yhteensopivien toimintojen osajoukko, a i aikaisimman lopetusajan omaava toiminto joukossa A ja a j aikaisimman lopetusajan omaava toiminto joukossa A. Nyt (A \ {a j ) {a i on myös maksimaalinen keskenään yhteensopivien toimintojen osajoukko. Todistus Jos i = j, niin kaikki on kunnossa. Jos i j, niin täytyy päteä, että f i f j. Koska a j on aikaisimman lopetusajan omaava toiminto joukossa A, A ei sisällä yhtään a k, k j, jolle s k f i. Täten voidaan korvata toiminto a j toiminnolla a i joukossa A ja saadaan yhtä suuri maksimaalinen keskenään yhteensopivien toimintojen osajoukko. 48/50

49 Esimerkki: Tarkastellaan taas toimintojen joukkoa A = {a 1,...,a 11, missä i s i f i Eräs maksimaalinen ratkaisu on {a 2,a 4,a 9,a 11 Tämä ei sisällä joukon A aikaisimmin päättyvää toimintoa a 1 Vaihdetaan a 1 joukon aikaisimmin päättyvän toiminnon a 2 tilalle ja saadaan uusi maksimaalinen ratkaisu {a 1,a 4,a 9,a 11 {a 4,a 9,a 11 on karsitun osaongelman {a 4,a 6,a 7,a 8,a 9,a 11, josta siis poistettu a 1 ja kaikki sen kanssa epäyhteensopivat toiminnot, eräs maksimaalinen ratkaisu a 4 a 5 a 6 a 10 a 3 a 9 a 1 a 2 a 7 a 8 a 11 49/50

50 Ahneen algoritmin Scala-toteutus def a c t i v i t y S e l e c t o r ( acts : Seq [ ( I n t, I n t ) ] ) = { val sorted = acts. sortby ( _. _2 ) val s o l = scala. c o l l e c t i o n. mutable. A r r a y B u f f e r [ ( I n t, I n t ) ] ( ) var time = I n t. MinValue for ( act < sorted ) { i f ( act. _1 >= time ) { s o l += act time = act. _2 s o l. t o L i s t Esimerkkiongelman ratkaiseminen sillä: scala > val acts = L i s t ( ( 1, 4 ), ( 3, 5 ), ( 0, 6 ), ( 5, 7 ), ( 3, 9 ), ( 5, 9 ), ( 6, 1 0 ), ( 8, 1 1 ), ( 8, 1 2 ), ( 2, 1 4 ),(12,16) ) acts : L i s t [ ( I n t, I n t ) ] = L i s t ( ( 1, 4 ), ( 3, 5 ), ( 0, 6 ), ( 5, 7 ), ( 3, 9 ), ( 5, 9 ), (6,10), (8,11), (8,12), (2,14), (12,16) ) scala > a c t i v i t y S e l e c t o r ( acts ) res0 : L i s t [ ( I n t, I n t ) ] = L i s t ( ( 1, 4 ), ( 5, 7 ), (8,11), (12,16) ) 50/50