Divide & Conquer: Verdeel en Heers vervolg Algoritmiek

Algoritmiek: Divide & Conquer2 Algoritmische technieken Vorige keer: –Divide and conquer techniek –Aantal toepassingen van de techniek –Analyse met Master theorem en substitutie Vandaag: –Extra toepassing: matrix vermenigvuldigen, … –Simplificatie Techniek, aantal voorbeelden Selectie

Algoritmiek: Divide & Conquer3 Matrix multiplicatie A, B n bij n matrices. Bepaal C = A. B. Geeft O(n 3 ) algoritme: 2n-1 bewerkingen per element van C. Kan sneller: algoritme van Strassen. Hier: neem aan n is macht van 2.

Algoritmiek: Divide & Conquer4 Splitsen in matrices half zo groot En een trucje om 2 by 2 matrices te vermenigvuldigen met minder vermenigvuldigen …

Algoritmiek: Divide & Conquer5 m 1 = (a 21 + a 22 – a 11 )(b 22 – b 12 + b 22 ) m 2 = a 11 b 11 m 3 = a 12 b 21 m 4 = (a 11 – a 21 )(b 22 – b 12 ) m 5 = (a 21 + a 22 )(b 12 – b 11 ) m 6 = (a 12 – a 21 + a 11 – a 22 ) b 22 m 7 = a 22 (b 11 + b 22 – b 12 – b 21 ) 7 vermenigvuldigingen in plaats van 8 Reken maar na…

Algoritmiek: Divide & Conquer6 Divide en conquer vermenigvuldigen Basisgeval: 1 bij 1 vermenigvuldigen Splits als boven; vermenigvuldig via schema m 1 t/m m 7 7 vermenigvuldigingen van n/2 bij n/2 matrices en  (n 2 ) optellingen van twee getallen

Algoritmiek: Divide & Conquer7 Tijdsanalyse T(n) = 7 * T(n / 2) +  (n 2 ) Mastertheorem: T(n) = O(n lg 7 ) : ongeveer O(n 2.81 ). (Strassen, 196*) Coppersmith & Winograd, 1986:  (n ) Ik bedoel: `O’, maar met een nare constante factor

Algoritmiek: Divide & Conquer8 Simplification Speciaal geval D&C: splitsen in 1 kleinere instantie: d.w.z.: probleem makkelijker maken maar het wel helemaal correct oplossen.

Algoritmiek: Divide & Conquer9 Recursief Schema Function SIMPLIFICATION (Input I) If probleem klein of eenvoudig genoeg Then los het probleem voor I direct op; return deze oplossing Else Pas simplification op I toe; verkrijg I2 H = SIMPLIFICATION(I2); Gebruik H om de oplossing voor I te krijgen; return deze oplossing Kan iteratief met stack. Conquer

Algoritmiek: Divide & Conquer10 Voorbeeld 1 Sorteren met simplification Sort(A[i … j]) –Zoek het kleinste element a k in A[i … j] –Verwissel a i en a k –Recursie: Sort(A[i+1 … j]) –Klaar (Conquerstap is triviaal) Simplication T(n) = T(n – 1) +O(n) = O(n 2 )

Algoritmiek: Divide & Conquer11 Voorbeeld 2: Binary search Bepaal of x in A[i … j] zit: BinarySearch(A[i … j], x) If (i==j) then return (A[i] == x) Else k = (i+j)/2 afgerond; If (x <= A[k]) then return BinarySearch(A[i … k],x) else return BinarySearch(A[k+1 … j],x)

Voorbeeld 3 Boom Gegeven: Graaf G=(V,E) Vraag: is G een boom (samenhangend en zonder cycle)? Er zijn verschillende manieren om dit op te lossen: –Exploratie (“depth first search”) –Simplificatie (nu) Algoritmiek: Divide & Conquer12

Grafen: terminologie Graad: aantal kanten dat aan een knoop grenst G-v: graaf die je krijgt door v en alle kanten met v als een eindpunt weg te laten uit G Algoritmiek: Divide & Conquer13

Simplificatie algoritme Observatie 1: als G een boom is dan is een van de volgende twee het geval: –G heeft 1 knoop en geen kanten (triviaal geval) –G heeft minstens 2 knopen, en minstens 1 knoop met graad 1 Observatie 2: Stel v heeft graad 1. G is een boom dan en slechts dan als G-v is een boom Algoritmiek: Divide & Conquer14

Simplificatie algoritme Herhaal zolang G een knoop met graad 1 heeft: –Kies een knoop v van graad G –Zet G = G-v If G heeft 1 knoop en geen kanten then return YES Else return NO Algoritmiek: Divide & Conquer15 Heeft O(n) Implementatie Details later Heeft O(n) Implementatie Details later

Algoritmiek: Divide & Conquer16 Selectie probleem: Vind het s-kleinste element Gegeven: array A[1…n] Neem even aan (niet echt nodig): alle elt in A zijn verschillende (bijv.) integers. Gegeven ook: getal s, tussen 1 en n. Gezocht: element x uit A zodat er precies s – 1 elementen kleiner dan x in A zitten. Belangrijk geval: mediaan: n/2 (afgerond, bijv. naar boven)

Algoritmiek: Divide & Conquer17 Hoeveel tijd kost het om dit Selection probleem op te lossen? In  (n log n) tijd met sorteren. Nu: –O(n) verwachtte tijd met simplificatie-strategie: Deels Herhaling; gebruikt ideeën van quicksort –O(n) tijd worst case met ingewikkelder algoritme voor vinden benadering van mediaan, plus daarna weer simplificatie.

Algoritmiek: Divide & Conquer18 Randomized Selection Function RandomizedSelection(A[i…j], s) If (i == j) then … Else: Kies een (random) element A[k] uit A[i…j] als pivot Gebruik Partition (van Quicksort) om A te verdelen in een stuk A[i…l] van elementen = A[k]. (beide niet leeg.) If s <= l – i + 1 then (gezocht elt. zit in 1 e stuk) RandomizedSelection(A[i…l],s) Else RandomizedSelection(A[l+1 … j], s – (l – i + 1)) Gebruikt Simplification strategie

Algoritmiek: Divide & Conquer Zoek 5 e elt Zoek 2 e elt Zoek 2 e elt Zoek 1 e elt.

Algoritmiek: Divide & Conquer20 Tijdsanalyse Slechtste geval (Worst case):  (n 2 ) Verwacht: O(n) Probleem bij worst case: pivot kan `scheef zitten’. Idee voor nieuw algoritme: zorg dat de pivot `redelijk in het midden zit…’.

Algoritmiek: Divide & Conquer21 Plan Maak een algoritme dat een pseudo- mediaan zoekt. Deze zit `in de buurt van de mediaan’. Selection gebruikt nu Pseudo-mediaan voor de pivot.

Algoritmiek: Divide & Conquer22 Hulproutine Mediaan van 5 elementen Function MiddleOfAtMostFive(A[i…i+4]) –Geeft mediaan van deze verzameling van maximaal 5 elementen. –Kost natuurlijk O(1) tijd per aanroep. Of 0, 1, 2, of 3

Algoritmiek: Divide & Conquer23 Selection met Pseudo-median Function Selection(A[i…j], s) If (i == j) then … Else: Pivot = Pseudomedian(A[i…j]). Gebruik Partition (van Quicksort) om A te verdelen in een stuk A[i…l] van elementen = Pivot. (beide niet leeg.) If s <= l – i + 1 then (gezocht elt. zit in 1 e stuk) RandomizedSelection(A[i…l],s) Else RandomizedSelection(A[l+1 … j], s – (l – i + 1))

Algoritmiek: Divide & Conquer24 Pseudo-mediaan Function Pseudomedian(A[i…j]) n = j – i + 1 If n <= 5 then return MiddleOfAtMostFive(A[i…j]) Else z = n/5, omlaag afgerond Maak Array Z[0…z – 1] For k=0 to z-1 do Z[k] = MiddleOfAtMostFive(A[i+5k … i+5k+4]) Return Selection(Z[0…z-1],  z/2  )

Algoritmiek: Divide & Conquer25 = pseudomediaan

Algoritmiek: Divide & Conquer26 Stelling Stel p is de output van Pseudomedian(A[1…n]) (i)Er zijn minstens 3n/10 – 13 elementen in A[1…n] kleiner dan p. (ii)Er zijn minstens 3n/10 – 13 elementen in A[1…n] groter dan p.

Algoritmiek: Divide & Conquer27 Argument (i) Er zijn minstens 3n/10 – 13 elt < p. –n/5 –1 groepjes van 5 elementen –n/10 – 3 van die groepjes hebben mediaan kleiner dan p. –Elk van die groepjes heeft tenminste 3 elt kleiner dan p: 3n/10 – 15 elementen. –En nog 2 elt uit het groepje van de pseudomediaan zelf. (ii) Net zo. p

Algoritmiek: Divide & Conquer28 Dus: Selection algoritme gaat in recursie op array met ten hoogste n – (3n/10 – 13) = 7n/ elementen. Natuurlijk nooit meer dan n-1. Tijdsanalyse blijft lastig: we gaan op twee verschillende plekken in recursie… ‘t Gaat goed omdat 1/5 + 7/10 < 1…

Algoritmiek: Divide & Conquer29 Recurrente betrekking voor de tijd van Selection algoritme T(n)  dn+ T(  n/5  ) + max{T(m) | m  7n/10+13} voor constante d, n > 5. (Ruwweg: T(n) = O(n) + T(n/5) + T(7n/10+13).) Met inductie: T(n)  c n.

Algoritmiek: Divide & Conquer30 Stelling Selection kan in O(n) tijd. Randomized algoritme vaak praktischer, en gemiddeld veel sneller (constante factoren!) maar soms wil je garantie op tijd… Op meerdere plekken gebruiken we Simplification / D&C strategie

Algoritmiek: Divide & Conquer31 Simplification als een vorm van preprocessing Simplification Solve Undo Simplification Zolang mogelijk Als simplificatie niet meer mogelijk

Algoritmiek: Divide & Conquer32 Ontwerp van algoritmen met D&C of simplificatie Gebruik `schema’ Welke structuur zit er in het probleem? Zijn er mogelijkheden om het probleem te `splitsen’? Of vereenvoudigen?

Algoritmiek: Divide & Conquer33 Samenvatting Divide & Conquer techniek Simplification Algoritmen met deze technieken voor een aantal problemen