Divide & Conquer: Verdeel en Heers vervolg. Algoritmiek

Transcriptie

1 Divide & Conquer: Verdeel en Heers vervolg Algoritmiek

2 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 2

3 Matrix multiplicatie A, B n bij n matrices. Bepaal C = A. B. C i, j = n k = 1 A i, k 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. B k, j 3

4 Splitsen in matrices half zo groot [ ] 1,1 1,2 1,1 1,2 C = A A 2,1 2,2 B B 2,1 2,2 A A B B En een trucje om 2 by 2 matrices te vermenigvuldigen met minder vermenigvuldigen 4

5 m 1 = (a 21 + a 22 a 11 )(b 22 b 12 + b 22 ) m 2 = a 11 b 11 7 vermenigvuldigingen m 3 = a 12 b 21 in plaats van 8 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 Reken 22 maar m 7 = a 22 (b 11 + b 22 b 12 b 21 ) na m 1 + m m m + m 3 4 m 7 m m m m m m m m 6 5 = a a 1,1 2,1 a a 1,2 2,2 b b 1,1 2,1 b b 1,2 2,2 5

6 Divide en conquer vermenigvuldigen [ ] 1,1 1,2 1,1 1,2 C = A A 2,1 2,2 B B 2,1 2,2 A A B B 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 6

7 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 7

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

9 Recursief Schema Function SIMPLIFICATION (Input I) Kan iteratief met stack. 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 Conquer 9

10 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 ) 10

11 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) 11

12 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) 12

13 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 13

14 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 14

15 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 Heeft O(n) Implementatie Details later 15

16 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) 16

17 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. 17

18 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] en een stuk A[l+1 j] 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) Gebruikt Simplification strategie Else RandomizedSelection(A[l+1 j], s (l i + 1)) 18

19 Zoek 5 e elt Zoek 2 e elt. Zoek 2 e elt Zoek 1 e elt. 19

20 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. 20

21 Plan Maak een algoritme dat een pseudomediaan zoekt. Deze zit `in de buurt van de mediaan. Selection gebruikt nu Pseudo-mediaan voor de pivot. 21

22 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 22

23 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 en een stuk A[l+1 j] 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)) 23

24 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 ) 24

25 = pseudomediaan 25

26 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. 26

27 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 27

28 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 28

29 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. 29

30 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 30

31 Simplification als een vorm van preprocessing Simplification Zolang mogelijk Als simplificatie niet meer mogelijk Solve Undo Simplification 31

32 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? 32

33 Samenvatting Divide & Conquer techniek Simplification Algoritmen met deze technieken voor een aantal problemen 33