Amorized Analysis en Union-Find Algoritmiek. 2 Vandaag Amortized analysis –Technieken voor tijdsanalyse van algoritmen Union-find datastructuur –Datastructuur.

Presentatie over: "Amorized Analysis en Union-Find Algoritmiek. 2 Vandaag Amortized analysis –Technieken voor tijdsanalyse van algoritmen Union-find datastructuur –Datastructuur."— Transcript van de presentatie:

1 Amorized Analysis en Union-Find Algoritmiek

2 2 Vandaag Amortized analysis –Technieken voor tijdsanalyse van algoritmen Union-find datastructuur –Datastructuur voor operaties op disjuncte verzamelingen –Verschillende oplossingen –Analyse van uiteindelijke oplossing –Toepassing

3 Algoritmiek3 Tijdsanalyse van een algoritme Soms: analyse van controlestructuur –Kijken naar geneste loops, etc. Hier: een data-structuur met operaties –Ge-amortiseerde tijd: hoeveel tijd kost elke operatie gemiddeld over alle operaties. Drie technieken: –Aggregate method –Accounting method –Potential method

4 Algoritmiek4 Probleemstelling Data-structuur Verzameling operaties op een data-structuur Wat is de gemiddelde tijd in het slechtste geval per operatie? –Worst case average time: amortized time

5 Algoritmiek5 Aggregate method Bereken totale tijd T(n) over een serie van n operaties op de data-structuur. Amortized time is T(n)/n. Voorbeelden: –Stack met multipop –Binare teller –Dynamische array

6 Algoritmiek6 Stack met multi-pop Stack met drie operaties: –Push(S,x): zet x bovenop de stack –Pop(S): haal bovenste element van stack en lever dat op –Multipop(S,k): haal de bovenste k elementen van de stack, of maak stack leeg als deze minder dan k elementen heeft: Multipop(S,k) while not(Stack-empty(S)) and k  0 do Pop(S); k = k – 1;

7 Algoritmiek7 Aggregate analysis voor de stack met multipop Worst-case tijd van multipop is O(n). Neem aan dat we beginnen met een lege stack. Amortized tijd van operaties is … O(1), want: –Stel we doen n operaties op de stack. –Dus doen we hooguit n keer een Push –Dus kunnen we hooguit (minder dan) n keer een element Pop-en –Totale tijd over alle Pop- en Multipop-operaties: O(n) –Totale tijd: O(n) –Amortized time van operatie: O(n/n) = O(1)

8 Algoritmiek8 Verhogen van een binaire teller Array A[0…k – 1] van bits Initieel 000…00 Increment(A) i = 0; While i < length(A) and A[i] = 1 Do A[i] = 0; i ++ If i < length(A) then A[i] = 1 00000000 10000011 20000103 3 0000114 40001007 50001018 600011010 700011111 800100015 9 00100116 1000101018 11 00101119 1200110020

9 Algoritmiek9 Amortized analyse van binaire teller Een enkele operatie kan O(k) tijd kosten. Amortized: –Elke operatie zet slechts 1 bit van 0 naar 1, maar misschien meerdere bits van 1 naar 0. –Als we n Increment-operaties doen: Maximaal n keer bit van 0 naar 1. Dus ook maximaal n keer bit van 1 naar 0. Totaal O(n) werk –O(1) amortized tijd van increment.

10 Dynamische array Array: –Start op formaat 10 –Toevoegen van element kan totdat array vol is (meestal O(1) werk, tenzij array vol) –Als array vol: formaat = formaat * 2 Maak nieuwe array met grootte formaat Kopieer oude array naar nieuwe array Kost O(formaat) tijd Algoritmiek10

11 Aggregate voor dynamische array Als we n inserts doen, dan: –O(n) voor gewone inserts: –Stel laatste verdubbeling gebeurde bij formaat k –Totale tijd van verdubbelingen: O(10+20+40+ … + k ) = O(k) n <= 2k Dus O(n) totaal, dus O(1) amortized Algoritmiek11

12 Algoritmiek12 De accounting method Iedere operatie betaalt hypothetische kosten. Daarmee: –Betaalt hij voor de acties die hij doet –Kan hij credit op objecten in de datastructuur plaatsen –Kan hij eventueel betalen met credit dat uit de datastructuur gehaald wordt

13 Algoritmiek13 Accounting method Stack met multipop Operaties kosten: –Push: 1 –Pop: 1 –Multipop: min(k, |S|) Geef geamortiseerde kosten: –Push: 2. Zet 1 credit op element in S. –Pop: 0. Betaal actie met credit. –Multipop: 0. Betaal actie met credit –Invariant: elk element in S heeft 1 credit.

14 Algoritmiek14 Binaire teller met accounting Laat elke increment 2 kosten. Zet 1 credit op de 1 die we gemaakt hebben. Betaal zetten van 1 naar 0 met credits op de 1-en. O(1) amortized. Array A[0…k – 1] van bits Initieel 000…00 Increment(A) i = 0; While i < length(A) and A[i] = 1 Do A[i] = 0; i ++ If i < length(A) then A[i] = 1

15 Dynamische array met accounting Als we een element toevoegen, dan: –Geef 1 credit aan een element dat nog geen credit heeft –Geef 1 credit aan element zelf Als we verdubbelen, dan heeft elk element precies 1 credit Dus O(1) amortized Algoritmiek15

16 Algoritmiek16 Potentiaal methode Potentiaal-functie  : Datastructuur  reals Als D 0 initiele datastructuur en D j datastructuur na j operaties, dan  (D j )  (D 0 ) Geamortiseerde kosten van een operatie i kunnen we nemen als: –Echte kosten c i plus  (D j ) –  (D j –1 ) –Merk op: totale kosten is minstens som van geamortiseerde kosten.

17 Algoritmiek17 Potentiaal methode voor multipop Potentiaal van stack is aantal elementen op stack. Initieel 0; dus altijd minstens potentiaal van initiele datastructuur. Geamortiseerde kosten Push: 2. (1 voor operatie en 1 voor toename potentiaal). Geamortiseerde kosten Pop: 0. (1 voor operatie en –1 wegens potentiaalverschil.) Geamortiseerde kosten Multipop: 0 (min(k,|S|) voor operatie en – min(k,|S|) wegens potentiaalverschil.)

18 Algoritmiek18 Potentiaalmethode voor binaire teller Potentiaal van bitstring: aantal bits dat 1 is. Initieel 0; dus altijd minstens potentiaal van initiele datastructuur. Geamortiseerde kosten van operatie zijn hooguit 2.

19 Potentiaalmethode voor dynamische array Stel we hebben een array met formaat f waarin n elementen zitten Geef deze potentiaal 2n-f Elke gewone invoeging doet potentiaal met 2 stijgen Verdubbeling: we doen dit als n=f, dus potentiaal is 2n-n = n, en na afloop is potentiaal 0, dus we betalen de operatie met het potentiaalverschil Algoritmiek19

20 Algoritmiek20 Union-find datastructuur Probleemstelling: datastructuur voor disjuncte verzamelingen met operaties –Vereniging (Union) –Zoeken (Find) Verschillende datastructuren voor dit probleem Analyse van de verschillende datastructuren Uiteindelijke oplossing: `union by rank’ en padcompressie Toepassingen –O.a. implementatie voor algoritme voor schedulingprobleem

21 Algoritmiek21 Disjuncte verzamelingen Partitie van universum U in aantal disjuncte deelverzameling van U. –Elk element van U zit in precies een verzameling in de collectie a b c d f e g U U = { {a,b,c}, {d,e,g}, {f} }

22 Algoritmiek22 a b c d f e g U’ Een ADT voor disjuncte verzamelingen I: Create Verschillende operaties –Create –Union –Find Create ( v ) Voegt nieuwe verzameling aan de collectie toe met element v Wordt aangeroepen als v niet al in de collectie zit. v a b c d f e g U

23 Algoritmiek23 II: Union Union (S1, S2) –Wordt aangeroepen met naam / objectverwijzing / identificatie van twee verzamelingen –Vervangt de verzamelingen S1 en S2 in de collectie door een verzameling S1  S2 a b c d f e g v S1S1 S2S2 a b c d f e g v h h Vereniging

24 Algoritmiek24 III: Find Find (v) Levert de naam / objectverwijzing / identificatie op van de verzameling waar v in zit. Iedere verzameling heeft dus unieke manier om geïdentificeerd te worden –Bijv. naam van een uniek element uit de verzameling a b c d f e g v S1S1 S2S2 h Find(a) geeft een verwijzing naar S1.

25 Algoritmiek25 Incrementeel samenhangende componenten Graaf G. Operaties: Voeg een kant toe tussen twee knopen x en y Geef de knopen in de samenhangende component van x Zitten x en y in dezelfde samenhangende component Addedge(x,y) S1 = Find(x) S2 = Find(y) if S1  S2 then Union(S1,S2) Toepassing

26 Algoritmiek26 Hoe implementeren we een datastructuur voor `union-find’? Verschillende implementaties Soms willen/kunnen we de datastructuur met extra operaties uitbreiden (zie werkcollege). Operaties moeten vlot gaan

27 Algoritmiek27 Heel simpel idee: array Houdt bij elk element bij de naam van de verzameling waar deze in zit: set(v) Find: O(1). Union (S, T): –Vervelend: Of het hele array langsgaan en voor alle elementen kijken of ze in S en T zitten Of we hebben voor verzamelingen S en T opgeslagen welke elementen erin zitten: –Maar dan hebben we de array niet zo nodig Create: lastig, want hoe lang moet de array worden?

28 Algoritmiek28 Datastructuur met lijsten Een verzameling wordt gerepresenteerd met een lijst van zijn elementen; elk element heeft een pointer naar zijn representatie (bijv.: 1 e element). abcdefg abcdefg

29 Algoritmiek29 Verbetering 1 1e lijst moet doorgelopen worden, alleen om laatste element te vinden om pointer naar 1e element van 2e lijst te maken abcdefg abcdefg Houdt dus ook een pointer naar het laatste element bij O(1) extra werk aan deze pointer O(1) extra werk aan deze pointer

30 Algoritmiek30 Verbetering 2 Als we pech hebben / dom zijn, wordt grote lijst achter kleine lijst gezet abcde eabcd Dus …

31 Algoritmiek31 Union by size Houdt van elke verzameling ook het formaat bij. Bij een vereniging: –Zet de kleinste lijst achter de grootste –Tel de formaten op. Hoeveel tijd kost dit? –Hoeveelheid tijd is O(1) voor find O(1) voor create O(1+ lengte kortste rij) voor union: hoeveel is dat nu precies?

32 Algoritmiek32 Analyse union by size Stel element x zit in verzameling met formaat n 1 en union wordt gedaan met verzameling met formaat n 2. –Als n 1  n 2, dan moet de pointer naar het eerste element worden omgezet, en zit x na afloop in een verzameling met n 1 + n 2  2*n 1 elementen. –Anders wordt de pointer naar het eerste element niet omgezet. Als |U|=n, dan kan een element maar hooguit log n keer in een minstens twee keer zo grote verzameling komen. Dus: totale hoeveelheid werk van het omzetten van pointers over alle union-operaties is O(n log n). –O(log n) gemiddeld per union.

33 Algoritmiek33 Tijdgrenzen lijsten met union by size Find: O(1) Create: O(1) Union: –O(n) worst case –O(log n) geamortiseerd

34 Algoritmiek34 Union-find met snelle union Duur was: omzetten van alle pointers naar het 1e element. Dus, laten we dat dan niet doen. abcdefg abcdefg Zoeken gaat in meerdere stappen

35 Algoritmiek35 Observaties Zoeken: ga een aantal pijlen naar voren af, tot je aan begin van de lijst gekomen bent. De lijst hoeft geen lijst meer te zijn: we gebruiken de lijst niet meer. abcdefg abcdefg

36 Algoritmiek36 Boomstructuur Een verzameling wordt gerepresenteerd door een boom. Pijlen wijzen omhoog, naar wortel. Identiteit van verzameling is / wordt opgeslagen in wortel van boom. abcdefg a b c d e fg

37 Algoritmiek37 Find in boomstructuur Find (x) r = x; while parent(r)  r do r = parent r Return informatie opgeslagen bij r a b c d e fg

38 Algoritmiek38 Union in boomstructuur Hang kleinste boom onder grootste boom Update formaat h n m l i kj a b c d e fg

39 Algoritmiek39 Analyse Union-Find met boomstructuur Diepte van boom O(log n) Dus: Find kost O(log n) tijd. Union kost O(1) tijd, plus evt. tijd voor vinden van wortels (m.b.v. 1 of 2 finds).

40 Algoritmiek40 Diepte van boom bijhouden In plaats van aantal knopen: houdt diepte van boom bij. Noemen we rang. Als rang(S1) < rang(S2) dan hang S1 onder S2 Als rang(S2) < rang(S1) dan hang S2 onder S1 Als rang(S1) = rang(S2) dan hang S2 onder S1 en tel 1 op bij de rang van S1 a b c d e fg h n m l i kj

41 Algoritmiek41 Union by rank Rang = diepte van boom Als wortel rang r heeft, dan zijn er 2 r knopen in zijn verzameling O(log n) tijd voor find O(1) tijd voor Union

42 Algoritmiek42 Padcompressie Observatie: meerdere Finds op hetzelfde element herhalen veel werk. De boom is niet binair – hoeft ook niet! We kunnen elementen direct onder de wortel van de boom hangen: scheelt de volgende keer veel werk.

43 Algoritmiek43 Padcompressie a b c d d cba

44 Algoritmiek44 Padcompressie - pseudocode Findwithpathcompression(x) r = x; while parent(r)  r do r = parent(r); y = x; while y  r do z = parent(y); parent(y) = r; y = z; return(r); Find met padcompressie kost O( find zonder padcompressie ): We gaan 2 keer het pad af Find met padcompressie kost O( find zonder padcompressie ): We gaan 2 keer het pad af

45 Algoritmiek45 Snelle en langzame functies Ackermann; k  0; j  1: –A 0 (j) = j+1 –A k (j) = A k-1 A k-1 …A k-1 (j) als k>0. Inverse Ackermann –  (n) = min{ k>0 | A k (1) > n} Log-ster –log*(n) = min {i | log log … log (n) < 1} Inverse Ackermann in praktijk nooit meer dan 4; log-ster in praktijk nooit meer dan 5. i keer j+1 keer

46 Algoritmiek46 Union-find met union by rank en padcompressie Stelling. Als we n creates en m finds doen, dan kosten de finds samen  (m  (m,n)) tijd. We gaan bewijzen: Stelling. Als we n creates en m finds doen, dan kosten de finds samen O(n+m log* n) tijd.

47 Algoritmiek47 Observaties over rangen Op ieder pad omhoog in de boom stijgen de rangen. De rang van een knoop is initieel 0, kan alleen maar stijgen gedurende de loop van het algoritme, en blijft gelijk nadat de knoop geen wortel meer is. De waarde van de rang(parent(x)) daalt nooit. Als x wortel van een boom is, dan is het formaat van de verzameling van x minstens 2 rang(x). Er zijn hooguit n / 2 r knopen met rang r. Iedere knoop heeft rang hooguit log n.

48 Algoritmiek48 Verdeel de rangen in blokken Rang r zit in blok log* r. Schrijf B(-1)=-1; B(0)=0; B(1) = 1. B(j) = Blok j is {B(j – 1)+1, …, B(j)}. j keer, j>1 B(j) = 2 B(j-1)

49 Algoritmiek49 Kosten van find Indelen in categorieën 1 eenheid kosten per knoop op wortelpad. –Wortel: O(1) per find –Kind van wortel: O(1) per find –Blokkosten: Voor ieder blok: bovenste knoop op wortelpad met rank in blok. –Springkosten: Knopen met een rang anders dan de rang van de wortel, en niet bovenste knoop in blok –Padkosten: Alle andere knopen

50 Algoritmiek50 Blokkosten en springkosten Er zijn O(log* n) blokken. Iedere find heeft hooguit 1 knoop per blok die blokkosten krijgt: –O(log* n) per find blokkosten. Springkosten: –Nadat een knoop springkosten gekregen heeft, zal het daarna alleen nog maar wortel, kind van wortel, of blokkosten krijgen: Nooit meer springkosten en padkosten Want bovenste knoop in blok op elk wortelpad. Dus O(1) per knoop in het totaal: O(n) amortized.

51 Algoritmiek51 Padkosten Als knoop padkosten krijgt, dan –Zit zijn ouder met rang in zelfde blok. –Krijgt hij een nieuwe ouder met een kleinere rang. Knoop in blok j kan B(j) – B(j – 1) – 2 keer padkosten krijgen: daarna zit zijn ouder zeker in een ander blok. (Blok j heeft B(j) – B(j – 1) elementen.) Totale padkosten: som over alle blokken van aantal knopen met rang in dat blok * (B(j)-B(j-1) –2). Aantal knopen met rang in blok j: schrijf dit als N(j)

52 Algoritmiek52 N(j)  3n/2B(j) N(0)  n / 2 0 + n / 2 1 = 3n / 2B(0) Als j>0: Gebruik dat er hooguit n/2 r knopen met rang r zijn

53 Algoritmiek53 Tellen van padkosten

54 Algoritmiek54 Totaal Wortel: O(m) Kind van wortel: O(m) Blokkosten: O(m log* n) totaal Springkosten: O(n) Padkosten: O(m log* n)

55 Algoritmiek55 Union find met padcompressie en union by rank Een enkele find kan veel tijd (O(log n)) kosten. Maar alle finds bij elkaar nauwelijks meer dan lineaire tijd! Nuttig principe: –Extra werk maar niet veel om later tijd te besparen.

56 Algoritmiek56 Toepassing voor schedulingprobleem n taken –Iedere taak kost evenveel (1) tijd –Taken hebben een deadline d i –Taken hebben een opbrengst g i –Een taak brengt g i op dan en slechts dan als de taak uitgevoerd is op tijd d i of eerder Welke taken voeren we uit, en in welke volgorde, zodat –Taken uitgevoerd uiterlijk op deadline –Totale opbrengst zo groot mogelijk Stel we hebben taken al gesorteerd op dalende opbrengst.

57 Algoritmiek57 Disjuncte verzamelingen Neem een verzameling bestaande uit –Tijdstip dat nog niet gebruikt is –Alle latere gebruikte tijdstippen voor het volgende nog niet gebruikte tijdstip. Bijhouden met union-find datastructuur; voor elke verzameling houden we het vrije tijdstip bij.

58 Algoritmiek58 Implementatie van `rechts- aanschuif’ algoritme Zoeken van leeg tijdstip: find operatie Plannen van taak op tijdstip t: –Union van verzameling die t bevat en de verzameling die t – 1 bevat. Totale tijd: –O(n  (2n,n)) : bijna linear!

59 Algoritmiek59 Volgende keer Minimum opspannende bomen. –Bevat ook toepassing van disjuncte verzamelingen datastructuur