Dinamikus programozás párhuzamosítási lehetőségekkel

8. tavasz Dinamikus programozás párhuzamosítási lehetőségekkel A. Grama, A. Gupta, G. Karypis és V. Kumar: Introduction to Parallel Computing, Addison Wesley, könyv, valamint Michael Goodrich (Univ. California) anyaga alapján Vázlat A dinamikus programozás (DP) áttekintése Soros, egyszerű-argumentumú (Monadic) DP Nem soros, egyszerű-argumentumú DP Soros, összetett-argumentumú (Polyadic) DP Nem soros, összetett-argumentumú DP Dinamikus programozás Dinamikus programozás

8. tavasz A dinamikus programozás áttekintése A dinamikus programozás (DP) széles körben használt optimalizációs problémák megoldására: ütemezés, string-szerkesztés, csomagolási probléma, stb. A problémákat részproblémákra bontjuk és ezek megoldásait kombináljuk, hogy a nagyobb probléma megoldását megtaláljuk. Az oszd meg és uralkodj típusú megoldási módszerrel szemben, itt a részproblémák között kapcsolatok, átfedések állhatnak fent (overlapping subproblems). Az elnevezés matematikai optimailzálásra utal. Dinamikus programozás A dinamikus programozás áttekintése A problémamegoldás menete:. Részproblémákra osztás.. A részproblémák optimális megoldása rekurzívan.. Az optimális megoldások felhasználása az eredeti feladat optimális megoldásának megtalálásához. A dinamikus programozás (DP) során a részmegoldások eredményeit gyakran táblázatokban tároljuk, hogy azokat szemben a rekurzív megközelítésekkel ne kelljen újra és újra kiszámolni (memoization). Dinamikus programozás Dinamikus programozás

8. tavasz Dinamikus programozás: példa Tekintsük a hurokmentes irányított gráfokban két csúcs (csomópont) között a legrövidebb út problémáját. Az i és j csomópontokat összekötő él költsége c(i, j). A gráf n csomópontot tartalmaz:,,, n-, és az i csomópontból a j csomópontba akkor vezethet él, ha i < j. A csomópont a forrás és az n- csomópont a cél. Jelölje f(x) a legrövidebb utat a csomóponttól x-ig. Dinamikus programozás Dinamikus programozás: példa Irányított gráf, melyben a legrövidebb utat számolhatjuk a és csomópontok között. Dinamikus programozás 6 Dinamikus programozás

8. tavasz Dinamikus programozás A DP formátumú probléma megoldását tipikusan a lehetséges megoldások minimumaként vagy maximumaként fejezzük ki. Ha r az x, x,, x l részproblémák kompozíciójából meghatározott megoldás költségét jelenti, akkor r a következő alakban írható Itt g az un. kompozíciós függvény. Ha minden probléma optimális megoldása a részfeladatok optimális megoldásának optimális kompozíciójaként kerül meghatározásra és a minimum (vagy maximum) érték kiválasztásra kerül, akkor DP formátumú megoldásról beszélünk. (Metamódszer, nem konkrét algoritmus.) Dinamikus programozás 7 Dinamikus programozás: példa f(x) f(x) r=g(f(x),f(x)) f(x) f(x8)=min{r,r,r} f(x) f(x) r=g(f(x),f(x)) f(x6) f(x7) r=g(f(x),f(x6),f(x7)) Composition of solutions into a term Minimization of terms Az f(x 8 ) megoldás meghatározásának kompozíciója és számítása részfeladatok megoldásából. Dinamikus programozás 8 Dinamikus programozás

8. tavasz Dinamikus programozás A rekurzív DP egyenletet funkcionális egyenletnek, vagy optimalizációs egyenletnek is nevezzük. A legrövidebb út problémánál a kompozíciós függvény f(j) + c(j, x). Ez egyszerű rekurzív tagként tartalmazza (f(j)). Az ilyen DP megfogalmazású feladatot monadic típusúnak (egyszerű-argumentumúnak) nevezzük. Ha a rekurzív kompozíciós függvény több tagú, akkor a DP feladat megszövegezése polyadic (összetettargumentumú) típusú. Dinamikus programozás 9 Dinamikus programozás A részproblémák közötti kapcsolatokat gráf segítségével fejezhetjük ki. Ha a gráf szintekre bontható és a probléma megoldása egy bizonyos szinten csak az előző szinten megjelenő problémamegoldástól függ, ekkor a megfogalmazást sorosnak nevezzük, egyébként pedig nem sorosnak. A két kritérium alapján a DP feladat megfogalmazásokat osztályozhatjuk: serial-monadic, serial-polyadic, nonserial-monadic, non-serial-polyadic, vagy egyéb. Az osztályozás azért fontos, mert meghatározza konkurenciát és a függőségeket, amely a párhuzamos megoldásokhoz vezethet. Dinamikus programozás Dinamikus programozás

8. tavasz Soros, egyszerű-argumentumú DP Az egész osztályra vonatkozó általános megfogalmazást, mintát nehéz megadni. Két reprezentatív feladat kerül bemutatásra: A legrövidebb út probléma többszintű gráfban (shortest-path problem for a multistage graph), / típusú hátizsák probléma (/ knapsack problem). Célunk a feladatok párhuzamos megfogalmazása és ezek alapján az osztályon belüli közös elvek lefektetése. Dinamikus programozás Legrövidebb út probléma A legrövidebb út problémának speciális osztálya, amikor a gráf súlyozott és többszintű. Jelen esetben a szintek száma r +. Minden szinten n csomópont van és minden csomópont az i. szintről össze van kötve az i + szint minden egyes csomópontjával. A. szint és az r. csak egy csomópontot tartalmaz, ezeket forrás (S) és cél (R) csomópontoknak nevezzük. Célunk legrövidebb utat találni S-től R-ig. Dinamikus programozás Dinamikus programozás 6

8. tavasz Legrövidebb út probléma v v v c c vr- cs v v cr-r cs S R csn- cr-n-r vn- cn-n- cn-n- vn- vn- vr-n- Soros, egyszerű-argumentumú (monadic) DP megfogalmazása a legrövidebb út problémának olyan gráfban, ahol a csomópontokat szintekbe szervezhetjük. Dinamikus programozás Legrövidebb út probléma A gráf l szintjének i. csomópontja:v il és a v il csomópontot v j l+ csomóponttal összekötött él súlya c i l,j. Bármely v il csomópont és az cél csomópont R költsége: C il. Ha n csomópont van egy szinten (l), akkor a költségek (legrövidebb utak R-ig) egy vektorban foglalhatók össze [C l, C l,, C n l - ] T. Ez a vektor C l. Megjegyzés: C = [C ]. Az l szint i eleme a céltól C il = min {(c i l,j + C j l+ ) j az l + szint egy csomópontjának indexe} Dinamikus programozás Dinamikus programozás 7

8. tavasz Legrövidebb út probléma Mivel a v j r- csomópontokat csak egy-egy él köti össze a cél, R csomóponttal az r szinten, a C j r- költsége: c j r, - R. Ezért: A feladat soros és egyszerű-argumentumú (monadic) típusú. Dinamikus programozás Legrövidebb út probléma Az l színt valamely csomópontjától a célcsomópont, R elérésének költsége, ahol ( < l < r ): Dinamikus programozás 6 Dinamikus programozás 8

8. tavasz Legrövidebb út probléma A probléma megoldását egy módosított mátrix-vektor szorzat formájában fejezhetjük ki Helyettesítsük az összeadás operációt minimalizálással és a szorzás műveletet összeadással, az előző egyenletek a következő alakúak lesznek: ahol C l és C l+ n x méretű vektorok a cél csomópont elérésének költségeit reprezentálják az l és l + színt minden egyes csomópontjától mérve. Dinamikus programozás 7 Legrövidebb út probléma Az M l,l+ mátrix n x n méretű, és minden (i, j) eleme az l szint i csomópontjának az l + szint j csomópontjával történő összekötés költségét tartalmazza: A legrövidebb út problémát r mátrix-vektor szorzatok sorozataként definiáltuk: C r-,c r-k- (k =,,, r-), C. Dinamikus programozás 8 Dinamikus programozás 9

8. tavasz Párhuzamos legrövidebb út probléma Az algoritmus úgy párhuzamosítható, mint bármelyik mátrix-vektor szorzást megvalósító algoritmus. n processzor elem számolhat minden C l vektort. Sok gyakorlati esetben az M mátrix elemei ritkák lehetnek. Ilyenkor ritkamátrixokhoz kapcsolódó módszert alkalmazzunk. Dinamikus programozás 9 / hátizsák probléma / knapsack problem A thief is robbing the King s treasury, but he can only carry a load weighing at most W Adott: S halmaz n elemmel és egy súlyhatár c, minden i elemnek p i pozitív egész értéke van (profit) és pozitív egész súlya Cél: úgy válasszuk ki az elemeket, hogy az összérték maximális legyen, de az összsúly kisebb legyen, mint c. T jelölje azokat az elemeket, amit kiválasztunk, T S Cél: összérték maximalizálása i T Feltétel: a súlyhatáron belül kell maradni p i i T C Dinamikus programozás Dinamikus programozás

8. tavasz / hátizsák probléma: példa Adott: n elemű S halmaz, minden elem p i pozitív értékű és pozitív súlyú Cél: válasszunk ki elemeket, hogy az összérték maximális legyen, de az összsúly ne haladja meg c-t. Összesen n eset lehet! Elemek: Súly: Érték: N N N 6 N N $ $ $6 $ $8 knapsack 9 N Megoldás: ( N) ( N) ( N) Összérték: 8+6+ = $6 Dinamikus programozás / hátizsák probléma, első próbálkozás S i : A halmaz elemeinek azonosítója -től i-ig (i < n). Definiálja F[i] = a legjobb kiválasztást S i -ből. Legyen pl. S = {(,),(,),(8,),(,),(,9)} érték-súly párok, c = A legjobb S, ha csak négyet veszünk ki: Összsúly:, érték: A legjobb S : az. benne van, de a. nem Rossz hír: S nem része az S optimális megoldásnak Dinamikus programozás Dinamikus programozás

8. tavasz / hátizsák probléma, más megközelítés S i : Az elemek halmaza -től i-ig, i < n. Definiálja F[i, x] = azs i halmazból a legjobb kiválasztást, ahol a súly legföljebb x további paraméter Ez optimális részprobléma megoldáshoz vezet. Az S i legjobb kiválasztás legföljebb x súllyal, két esetet jelenthet: -Ha > x, akkor az i. elemet nem lehet hozzávenni, mert súlya nagyobb, mint az aktuális határ - Egyébként: ha a legjobb S i- részhalmaz súlya x - és ehhez vagy jön i, vagy nem eredményez nagyobb értéket F[ i, x] if wi > x F[ i, x] = max{ F[ i, x], F[ i, x w ] + p } i i Dinamikus programozás / hátizsák algoritmus F[i, x] rekurzív formula: F[ i, x] F[ i, x] = max{ F[ i, x], F[ i, x wi ] + pi} if w i > x F[i, x] = az -től i-ig tartó elemekből a legjobb kiválasztás, ahol az összsúly legfeljebb x Alapeset: i =, nem került elem kiválasztásra. Összérték. A feladat megoldása: a legnagyobb érték az n. sorban, utolsó (c) oszlopban Futási idő: O(nc). Nem n ideig tart. Dinamikus programozás Dinamikus programozás

8. tavasz / hátizsák algoritmus Algorithm -Knapsack(S, c): Input: S halmaz elemei p i értékkel, súllyal; valamint a max. súly c Output: a legjobb részhalmaz értéke (F[n, c]), hogy teljesül: összsúly c for x to c do F[, x] for i to n do F[i, ] for i to n do for x to c do if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] Mivel F[i, x] csak F[i -,*] értékeitől függ, elég lehet vektorokat használni Dinamikus programozás / hátizsák példa n = az adatok száma c = kapacitás (maximális összsúly) Elemek: i súly ( ), profit (p i ) 6 Dinamikus programozás 6 Dinamikus programozás

8. tavasz Példa i \ x for x to c do F[, x] Dinamikus programozás 7 Példa i \ x for i to n do F[i, ] Dinamikus programozás 8 Dinamikus programozás

8. tavasz Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = - Dinamikus programozás 9 Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = Dinamikus programozás Dinamikus programozás

8. tavasz Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = Dinamikus programozás Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = Dinamikus programozás Dinamikus programozás 6

8. tavasz Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = Dinamikus programozás Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = - Dinamikus programozás Dinamikus programozás 7

8. tavasz Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = - Dinamikus programozás Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = Dinamikus programozás 6 Dinamikus programozás 8

8. tavasz Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = Dinamikus programozás 7 Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x 7 if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = Dinamikus programozás 8 Dinamikus programozás 9

8. tavasz Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x 7 if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x =.. x - = -..- Dinamikus programozás 9 Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x 7 if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = Dinamikus programozás Dinamikus programozás

8. tavasz Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x 7 7 if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = = x = x - = Dinamikus programozás Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x 7 7 if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = 6 = x =.. x - = -..- Dinamikus programozás Dinamikus programozás

8. tavasz Példa ; p i : (; ) : (; ) : (; ) : (; 6) i \ x 7 7 7 if <= x F[i, x] max(f[i -, x], F[i -, x - ] +p i ) F[i, x] F[i -, x] i = p i = 6 = x = x - = Dinamikus programozás Példa Az algoritmus a maximális összsúlyt vette figyelembe úgy, hogy a zsákba tehető F[n, c] érték a lehető legnagyobb legyen. Az elemek kiolvasásához egy visszafele haladó algoritmus szükséges, amely a táblázatot használja: i n, x c while (i, x > ) if F[i, x] <> F[i -, x] Jelöljük meg az i. elemet, hogy a zsákban van i = i -,x = x i = i - Dinamikus programozás Dinamikus programozás

8. tavasz / hátizsák probléma (könyv szerint) Adott a c kapacitású hátizsák és n objektumból álló halmaz,,,n. Minden objektumot súly és p i profit jellemez. Legyen v = [v, v,, v n ] egy megoldás vektor, amelyben v i = ha az i. objektum nincs a hátizsákban v i = ha a hátizsákban van. A cél az objektumok olyan részhalmazát megtalálni, amit a hátizsákba helyezhetünk, azaz (az összsúly nem nagyobb, mint a kapacitás) és a profit maximalizált. Dinamikus programozás / hátizsák probléma Legyen a maximális profit F[i, x] az x kapacitású hátizsákhoz kapcsolódóan ha a következő objektumrészhalmazt használjuk {,,,i}. A DP megfogalmazása: Dinamikus programozás 6 Dinamikus programozás

8. tavasz / hátizsák probléma Konstruáljuk meg az n x c méretű F táblázatot soronként haladva. Egy elem kitöltése két elem ismeretét igényli az előző sorból: egy ugyanabból az oszlopból és egy olyan oszloptávolságnyira, mint amilyen súllyal az objektum a sorhoz tartozik. Minden elem kiszámolása konstans idejű; a soros futási komplexitás Θ(nc). A megfogalmazás soros, egyszerű-argumentumú. Dinamikus programozás 7 / hátizsák probléma Table F n i Fij Weights j-wi j c- c Processors P Pj-wi- Pj- Pc- Pc- A / hátizsák probléma F táblájának számítása. Az F[i,j] meghatározásához szükséges kommunikáció processzorelemekkel, amelyek tartalmazzák F[i-,j] és F[i-,j- ] elemeket. Dinamikus programozás 8 Dinamikus programozás

8. tavasz / hátizsák probléma Ha c processzorelemet használunk (CREW PRAM ideális, közös memóriás modellen), párhuzamos algoritmust készíthetünk az oszlopok processzorokhoz particionálásával és O(n) futási idővel. Ha osztott memóriás modellen minden processzorelem lokálisan tárolja az objektumok súlyait és profitjait a j. iteráció során, F[j, r] számításához a P r- processzoron lokálisan rendelkezésre áll F[j-, r], de F[j-, r-w j ]-t másik processzorelemtől kell megkapni. n iteráció ekkor O(n log c) ideig tart Dinamikus programozás 9 Nem soros, egyszerű-argumentumú DP megfogalmazás: Longest-Common- Subsequence (LCS) Adott egy A = <a, a,, a n > sorozat; az A részsorozatát kapjuk, ha valahány elemet törlünk belőle. Cél: Adott két részsorozat: A = <a, a,, a n > és B = <b, b,, b m >, keressük meg a leghosszabb sorozatot, ami részsorozata egyaránt A-nak és B-nek. Példa: ha A = <c,a,d,b,r,z> és B = <a,s,b,z>, a leghosszabb közös részsorozata A-nak és B-nek <a,b,z>. Dinamikus programozás Dinamikus programozás

8. tavasz Leghosszabb közös részsorozat Jelölje F[i, j] az A első i elemének és B első j elemének leghosszabb közös részsorozat hosszát. Az LCS célja, hogy megtaláljuk F[n, m] értékét (és a sorozat elemeit). Ekkor igaz, hogy: Dinamikus programozás Leghosszabb közös részsorozat Az algoritmus kiszámolja a két-dimenziós F táblát soroszlop sorrendben. Az átlós csomópontok mindegyike két részproblémához kapcsolódik, az előző szinthez és az azt megelőző szinthez. Ezért ez a DP megfogalmazás nem soros, egyszerű-argumentumú típusú. Dinamikus programozás Dinamikus programozás 6

8. tavasz Leghosszabb közös részsorozat m n p p pn- (a) (b) (a) Az LCS táblázat számítási elemei. A számítás a jelzett átlós irányban halad. (b) A táblázat elemeinek leképzése a processzor elemekre. Dinamikus programozás Leghosszabb közös részsorozat Consider the LCS of two amino-acid sequences H E A G A W G H E E and P A W H E A E. For the interested reader, the names of the corresponding amino-acids are A: Alanine, E: Glutamic acid, G: Glycine, H: Histidine, P: Proline, and W: Tryptophan. H E A G A W G H E E P A W H E A E Az LCS: A W H E E. Dinamikus programozás Dinamikus programozás 7

8. tavasz Parallel LCS A táblázat elemeinek kiszámolása átlós irányban történik a bal felső saroktól a a jobb alsó irányban. Ha n processzort használunk (CREW PRAM), minden elem kiszámolása átlósan konstans ideig tart. A két n hosszú szekvenciával az algoritmus n- átlós lépést tesz összesen. Dinamikus programozás Parallel LCS Az algoritmus processzorok lineáris tömbjére is adaptálható: a P i processzor elem az F tábla (i+). oszlopának meghatározásáért felelős. Az F[i,j] kiszámolásához a P j- processzorelemnek szüksége van F[i-,j-] vagy F[i,j-] értékre a tőle balra lévő processzor elemtől, amely kommunikációt jelent. A számítás konstans idejű (t c ) minden elemre. A teljes parallel idő: A hatékonyság felső korlátja.! Dinamikus programozás 6 Dinamikus programozás 8

8. tavasz Soros, összetett-argumentumú DP: Floyd legrövidebb út algoritmusa, minden párra Adott egy súlyozott gráf G(V,E), Floyd algoritmusa a csúcspárok közötti d i,j költségeket határozza meg, hogy a legrövidebb utat célozza meg. Legyen d i k,j a minimum költségű út az i csomóponttól a j csomópontig, és csak a következő csúcsokat használja v,v,,v k-. Így: Csak a,, k- csúcsokat használja i A,, k- csúcsokat használja (nem megy át k-n) k j Csak a,, k- csúcsokat használja Dinamikus programozás 7 Nem soros összetett-argumentumú DP megfogalmazás: Optimális mátrix zárójelezési probléma Amikor mátrixok sorozatát kell összeszorozni, akkor a szorzás sorrendje alapvetően meghatározza a műveletek (szorzások) számát. Legyen C[i,j] (egy résznél N[i,j] a jelölés!) az A i, A j mátrixok optimális szorzásának költsége. A láncszorzást két kisebb lánc szorzására lehet bontani, A i,a i+,,a k és A k+,,a j. Az A i,a i+,,a k eredménye d i x d k+ méretű mátrix, az A k+,,a j lánc eredménye d k+ x d j+ méretű mátrix. A két mátrix összeszorzásának költsége (a szorzások száma) d i d k+ d j+. Dinamikus programozás 8 Dinamikus programozás 9

8. tavasz Mátrixok láncszorzása Emlékeztető: Mátrix-szorzás C = AB A mérete d e, B mérete e f C[ i, j] = e k = A[ i, k] B[ k, j] e B f j O(def )idő e d A i C i,j d f Dinamikus programozás 9 Mátrixok láncszorzása Mátrixok láncszorzása: Számítandó A = A A A n- A i mérete d i d i+ Feladat: hogyan zárójelezzük? Példa B: C: 7 D: 7 (BC)D 7 + 7 = szorzás B(CD) + 7 = szorzás Dinamikus programozás 6 Dinamikus programozás

8. tavasz Felsorolásos megközelítés Mátrixok láncszorzása algoritmus: Próbáljuk minden lehetséges módon zárójelezni A=A A A n- Számoljuk ki minden esetre a szorzások számát A legjobbat vegyük Futási idő: A zárójelezések száma = az n csomópontú bináris fák számával azonos Exponenciálisan nő Gyakorlatban nem megvalósítható Dinamikus programozás 6 Egy mohó algoritmus Ötlet: a legkevesebb műveletet használó szorzatokat válasszuk ki elsőként. Példa: A: B: 9 C: 9 D: 99 Ötlet szerint: A((BC)D) A legjobb (AB)(CD) 9989+99+89=8789 szorzás 9999+8999+89=899 szorzás Dinamikus programozás 6 Dinamikus programozás

8. tavasz Másik mohó algoritmus Ötlet: a legtöbb műveletet használó szorzatokat válasszuk ki elsőként. Példa: A: B: C: D: Ötlet szerint (AB)(CD) Legjobb A((BC)D) ++ = szorzás ++ = szorzás Dinamikus programozás 6 Egy rekurzív megközelítés Definiáljunk részproblémákat: Keressük meg az A i A i+ A j legjobb zárójelezését. Legyen N i,j = a műveletek száma ennél a részfeladatnál. Az egész feladatra optimális megoldás N,n-. A részfeladat optimalizálás: Az optimális megoldás optimális részproblémákként lehet definiálni Kell, hogy legyen néhány legvégül futó szorzás (a kifejezésfa gyökere) az optimális megoldásnál. Mondjuk a végső szorzás az i indexnél van: (A A i )(A i+ A n- ). Ekkor az optimális megoldás N,n- két optimális részfeladat megoldása: N,i és N i+,n-, valamint az utolsó szorzás költsége. Ha a globális optimumnak nem ezek az optimális részproblémái, akkor tudunk definiálni még jobb optimális megoldást. Dinamikus programozás 6 Dinamikus programozás

8. tavasz Karakterisztikus egyenlet A globális optimális megoldást optimális részproblémákként kell definiálni, attól függően, hogy hol van az utolsó szorzás. Tételezzük fel az összes lehetséges helyet a végső szorzatra: Az A i mérete d i d i+. Így a karakterisztikus egyenlet N i,j -re a következő: N i, j = j+ i k< j min{ Ni, k + Nk+, j + didk+ d } Ezek a részfeladatok nem függetlenek, hanem átfedésben vannak egymással. Dinamikus programozás 6 Dinamikus programozási algoritmus Mivel a részfeladatok átfedik egymást, nem használunk rekurziót. Helyette bottomup módon építkezünk. N i,i -k meghatározása egyszerű, ezzel kezdünk. Ezután,, részfeladat. Futási idő: O(n ) Algorithm matrixchain(s): Input: a szorzandó mátrixok S sorozata Output: az S optimális zárójelezésének a száma for i to n- do N i,i for b to n- do for i to n-b- do j i+b N i,j + for k i to j- do N i,j min{n i,j, N i,k +N k+,j +d i d k+ d j+ } Dinamikus programozás 66 Dinamikus programozás

8. tavasz Dinamikus programozás A bottom-up konstrukció átlósan tölti ki az N tömböt. N i,j értékeket kap az előző i. sor és j. oszlop elemeiből. A tábla elemeinek kitöltése O(n) idejű. Teljes futási idő: O(n ) A zárójelezést úgy kaphatjuk meg, ha eltároljuk k -t N minden elemére. N i, j = { Ni, k + Nk+, j + didk+ d j+ i k< j N j n- i n- min } válasz Dinamikus programozás 67 Láncszorzás algoritmus Algorithm matrixchain(s): Input: a szorzandó mátrixok S sorozata Output: az S optimális zárójelezésének száma for i to n- do N i,i for b to n- do //b a műveletek száma for i to n-b- do j i+b N i,j +infinity for k i to j- do sum = N i,k +N k+,j +d i d k+ d j+ if (sum < N i,j ) then N i,j sum O i,j k return N,n- Példa: ABCD A: B: C: D: N A AB A(BC) (A(BC))D B BC (BC)D Dinamikus programozás 68 C CD D Dinamikus programozás

8. tavasz A műveletek visszanyerése Példa: ABCD A: B: C: D: N A AB A(BC) (A(BC))D B BC (BC)D C CD D // return expression for multiplying // matrix chain A i through A j exp(i,j) if (i=j) then // base case, matrix return A i k = O[i,j] // see red values on left S = exp(i,k) // recursive calls S = exp(k+,j) return ( S S ) Dinamikus programozás 69 Optimal Matrix-Parenthesization Problem We have: Dinamikus programozás 7 Dinamikus programozás

8. tavasz Optimális mátrix láncszorzás C[,] C[,] C[,] C[,] C[,] C[,] C[,] C[,] C[,] C[,] Nem soros, összetett-argumentumú DP megfogalmazás mátrixok láncszorzásának optimális meghatározására. A négyzetek a mátrixok láncszorzatának optimális költségét jelentik. A körök lehetséges zárójelezést. C[i, j] jelölés azonos a korábbi N i,j -vel Dinamikus programozás 7 Optimális mátrix láncszorzás P P P P P P P6 P7 (,) (,) (,) (,) (,) (,6) (,7) (,8) (,) (,) (,) (,) (,6) (,7) (,8) Diagonal 7 (,) (,) (,) (,6) (,7) (,8) Diagonal 6 (,) (,) (,6) (,7) (,8) (,) (,6) (,7) (,8) (6,6) (6,7) (6,8) (7,7) (7,8) Diagonal (8,8) Diagonal Diagonal Átlós számítási sorrend http://docs.linux.cz/programming/algorithms/algorithms-morris/mat_chain.html Dinamikus programozás 7 Dinamikus programozás 6

8. tavasz Párhuzamosítási lehetőség Tételezzünk fel egy gyűrűs logikai processzor topológiát. Az l lépésben minden processzor elem egyetlen elemet számol ki, amely az l. átlóhoz tartozik. A C tábla kiszámítása során, minden processzor elküldi broadcasting módon az általa kiszámolt elemeket az összes többi processzornak. A következő érték lokálisan számítható. Dinamikus programozás 7 Az általános dinamikus programozási technika Általában olyan feladatoknál alkalmazzuk, amelyek első ránézésre rengeteg időt vesznek igénybe. Részei: Egyszerű részproblémák: a részproblémákat néhány változó függvényeként kell definiálni. Részprobléma optimalitás: a globális optimum a részproblémák optimumaként definiálható. Átfedő, kapcsolódó részproblémák: a részfeladatok nem függetlenek, hanem átfedőek (ezért bottom-up konstrukcióban kell dolgozni). Dinamikus programozás 7 Dinamikus programozás 7

8. tavasz Parallel dinamikus programozási algoritmusok A számítási menetet gráfként reprezentálva, háromféle párhuzamosítási lehetőséget azonosíthatunk: csomópontokon belüli párhuzamosság; egy szinten a csomópontok közötti párhuzamosítás; és futószalagosított csomópontok (pipelining) eltérő szintű csomópontok között. AZ első kettő soros megfogalmazású, a harmadik nem soros DP. Az adatok helyzete (hová rendeljük) a teljesítmény szempontjából kritikus. Dinamikus programozás 7 Dinamikus programozás 8