Greedy algorithms
Vandaag Greedy algorithms: wat zijn dat? Voorbeelden: gepast betalen met euromunten AB-rijtje Knapsack probleem Twee scheduling problemen Later: meer voorbeelden, algemene structuur, wanneer wel/niet optimaal 2
Greedy algorithms Greedy: hebzuchtig, gulzig, inhalig Algoritmen voor optimalisatieproblemen Oplossing wordt incrementeel opgebouwd Om van een deeloplossing naar de volgende deeloplossing te gaan wordt een greedy stap gedaan: Best uitziend / meest veelbelovend / grootste directe winst 3
Soms optimaal, soms heuristiek Er bestaan toepassingen waarbij greedy het optimale antwoord vindt Er bestaan toepassingen waarbij greedy niet het optimale antwoord vindt: Soms bewijsbare kwaliteit van approximatie Soms (redelijk) goede heuristiek Soms heel slecht en ver weg van optimum 4
Kortste A,B-rijtje Nog eens: A,B-rijtje is rij getallen met: 1e getal is A (>=1) Laatste getal is B (>=1) Ieder getal is vorige getal +1 (I) of *2 (D) Vraag: gegeven A en B, wat is het kortste A,Brijtje We zagen een DP, maar het kan slimmer 5
DP formulering S(A,B) = 0 als A==B S(A,B) = MAXINT als B<A S(A,B) = min {S(A+1,B),S(A*2,B)} +1 anders Of: 6
Laatste keuze Als B oneven is, moet het rijtje op I eindigen Als B < 2A, moet het rijtje op I eindigen Je kan laten zien (komt zometeen): Als B>= 2A en B even, dan eindigt een kortste rijtje op een D S(A,B) = S(A,B-1) als B oneven en A < B<2A S(A,B) = S(A,B/2) als A < B, B>=2A en B even 7
Algoritme If B<A then return MAXINT (of oneindig, of foutmelding) Maak lege stack S While B!= A do If B oneven or B<2A, then push(s, I ); B=B-1 Else push (S, D ); B = B/2 While stack niet leeg, do Write(Pop(S)); 8
Stellinkje en bewijs Als we een D als laatste stap kunnen doen, dan geeft dat altijd een kortere rij dan wanneer we een I als laatste stap doen Bewijs: B is even Kijk naar optimale sequence, stel eindigt op I Geval 1: alleen maar I s: I B-A is langer dan I B/2-A D: tegenspraak Geval 2: rijtje heeft vorm sdi r. r is even, want getal is altijd even na een D. Neem nu rijtje si r/2 D : dit is korter: tegenspraak Altijd tegenspraak, dus optimale sequence eindigt op D 9
Idee Optimale keuze voor laatste element Heeft een bewijs nodig We hoeven niet te kiezen kunnen 1 kant opgaan! Noemen we greedy 10
DP 11 Greedy vs Dynamisch Deelproblemen met zelfde structuur als originele problem We bekijken alle keuzes Slim tabelleren voorkomt extra werk Langzamer dan Greedy i.h.a. Exact Programmeren Greedy Deelprobleem met zelfde structuur als originele problem We bekijken steeds maar 1 keuze Heeft een bewijs nodig voor optimaliteit, anders niet-exacte heuristiek
Greedy: wat vraag je je af Wat is de eerste / laatste keuze die gemaakt wordt Is er een mogelijkheid voor die keuze die optimaliteit niet verstoort: er bestaat een optimale oplossing die die mogelijkheid gebruikt (greedy choice property?) Bewijs van greedy choice property: uitwisselargumenten Greedy algoritme (slimme implementatie?) 12
Greedy choice property Strategie voor top choice (laatste keuze) Heeft de greedy choice property, als Wanneer de strategie voor een instantie keuze a geeft, dan bestaat er een optimale oplossing met keuze a Hoeft niet te gelden; moet bewezen worden Zonder GCP is Greedy een heuristiek: niet precies 13
Euromunten Muntwisselprobleem met Euro s Munten met waardes 1, 2, 5, 10, 20, 50, 100, 200 En bankbiljetten met waardes 500, 1000, 2000, 5000, 10000, 20000, 50000 Hoe betalen we een bedrag van n cent met zo weinig mogelijk munten? Voor euromunten kan dit optimaal met een greedy algoritme! 14
Greedy algoritme voor muntwisselprobleem Procedure BetaalGreedy (integer n, verzameling M) rest = n; While (rest > 0) Do Kies de grootste muntwaarde w uit M zodat w rest; Als alle munten in M waarde groter dan rest hebben, return `Niet mogelijk. Geef een munt met waarde w terug; rest = rest w; Dit doet zich niet voor bij Euro s 15
Stelling BetaalGreedy geeft altijd het minimum aantal munten als M = { 1, 2, 5, 10, 20, 50, 100, 200}, Ook als M = {1, 5, 10, 25, 100, 250}. Formeel wiskundig bewijs is niet eenvoudig Als M = { 1, 10, 25} dan is dit niet waar: Kijk naar n = 30. 16
Methode anders opgeschreven function make-change(n) {Bereken S bestaande uit zo weinig mogelijk muntjes} const Euro s={200,100,50,20,10,5,2,1}; S= ; {S is de verzameling van geselecteerde muntjes} sum=0; {sum is de totale waarde van de muntjes} while sum n do x = grootste waarde uit Euro s met sum+x n if er is niet zo n waarde return geen oplossing S = S {munt met grootste waarde uit Euro s} sum = sum + x; return S; 17
Ingredienten voor greedy algoritme Werkt voor optimaliseringsprobleem. Een doelfunctie (objective function) geeft elke oplossing een waarde; we willen een oplossing met beste (kleinste / grootste) waarde vinden. De oplossingsverzameling wordt incrementeel opgebouwd. Een functie solution test of de oplossingsverzameling een oplossing is. Een functie feasible (doenbaar / mogelijk), die test of een element aan de oplossingsverzameling toegevoegd kan worden. Een functie select selecteert het meest veelbelovende element. 18
Greedy algoritmen: optimaal of niet? Soms geven greedy algoritmen optimale antwoorden, bijv.: Muntwisselprobleem met euro-munten Meer voorbeelden volgen Soms geven greedy algoritmen geen optimale antwoorden, bijv.: Muntwisselprobleem met munten 1, 10, 25 Dan is greedy een heuristiek. Soms kan je bewijzen dat greedy in de buurt van het beste antwoord komt. 20
Oliepijpen in Rusland Pijplijn Kan lekken Waar plaatsen we kleppen (valves)? DP of greedy? 21
Oliepijpen probleem Gegeven: l 1 l 2 l n We kunnen K kleppen neerzetten Bij lekkage gaan de kleppen dicht, en lekt het stuk weg vanaf de lekkage tot aan de klep links en de klep rechts Hoe zorgen we dat de maximale lekkage zo klein mogelijk is? 22
Oplossingsstrategie 1: Dynamisch programmeren O(n 2 K): deelproblemen wat is de maximale lekkage in het deel 1 q, als we L kleppen neerzetten, met de laatste op plek q Tijdgrens kan door handiger berekenen iets lager 23
Oplossingsstrategie 2: Greedy Los een ander problem op: Stel ik sta L lekkage toe, hoeveel kleppen heb ik nodig Observatie: er is een optimale oplossing, waarbij ik de eerste klep zoveel mogelijk naar rechts zet, zodat het eerste stuk hooguit L lekkage geeft Bewijs: 24
Oplossingsstrategie 2: Greedy Los een ander problem op: Stel ik sta L lekkage toe, hoeveel kleppen heb ik nodig Observatie: er is een optimale oplossing, waarbij ik de eerste klep zoveel mogelijk naar rechts zet, zodat het eerste stuk hooguit L lekkage geeft Bewijs: kijk naar een optimale oplossing. Verschuiven van de eerste klep naar de greedy choice positie is nog steeds een optimale oplossing Greedy choice property 25 topchoice
Oplossing met Greedy Doe binary search op de waarde van de lekkage Voor lekkage L: Zet eerste klep zo rechts mogelijk Herhaal op rest, tot laatste stuk <= L Algoritme kost O(n log L) met L het antwoord 26
Knapsack met fractionele oplossingen n Voorwerpen met Waardes w 1, w n (positief) Gewichten g 1,, g n (positief) Maximum gewicht G. We mogen nu ook een gedeelte van een voorwerp nemen: als we bijvoorbeeld 2/3 van voorwerp j nemen levert dat 2/3*w j waarde en 2/3*g j gewicht op. Hoe kunnen we zoveel mogelijk waarde meenemen als totaalgewicht hooguit G is. (Bij DP mochten we alleen voorwerpen helemaal wel of helemaal niet nemen.) 27
Wiskundige formulering Kies reële getallen x 1 x n [0,1] zodat en zodat n i =1 n i = 1 x g G zo groot mogelijk is. i x w i i i 28
Simpele observaties Als het totaalgewicht van alle voorwerpen hooguit G is, dan is het nemen van alle voorwerpen optimaal. Stel dus dat totaalgewicht >G is. Nu: Een optimale oplossing heeft totaalgewicht precies G: elke andere oplossing kan verbeterd worden. n i =1 xi gi = G 29
Plan voor greedy algoritme function knapsack(g[1..n],w[1..n],g): array x[1..n]; for i=1 to n do x[i]=0; gewicht=0; {greedy loop} while gewicht<g do i = het beste nog niet geselecteerde object ; if gewicht+g[i] G then x[i]=1; gewicht = gewicht+g[i]; else x[i]= (G-gewicht)/g[i]; gewicht=g; return x; Wat kan er nog bij van voorwerp i? 30
Over schema voor greedy algoritme voor knapsack Hooguit 1 voorwerp wordt voor een deel (0<x i <1) genomen. Er zijn verschillende mogelijkheden voor wat het beste nog niet geselecteerde voorwerp is (wat is onze top choice?) Het lichtste Niet altijd optimaal: voorwerpen met waarde/gewicht (1,1), (B, 2B) Het waardevolste Niet altijd optimaal: voorwerpen met waarde/gewicht (B,B), (1, 2B) Het voorwerp met de hoogste waarde van w i / g i 31
Kies steeds voorwerp met hoogste soortelijke waarde function knapsack(g[1..n],w[1..n],g): array x[1..n]; for i=1 to n do x[i]=0; gewicht=0; i = 1; Sorteer de voorwerpen zodat de `soortelijke waardes w[i]/g[i] niet stijgend zijn, d.w.z., w[1]/g[1] w[2]/g[2] w[n]/g[n] while (gewicht < G and i n) do if gewicht+g[i] G then x[i]=1; gewicht = gewicht+g[i]; else x[i]= (G-gewicht)/g[i]; gewicht=g; i++; 32
Greedy met waarde/gewicht geeft optimale oplossing Stelling. Als de voorwerpen gekozen worden in volgorde van niet-stijgende waarde w[i]/g[i], dan geeft het greedy algoritme een optimale oplossing. Bewijs. Stel voorwerpen genummerd op nietstijgend waarde/gewicht. Stel totaalgewicht alle voorwerpen meer dan G. Bekijk oplossing van greedy algoritme. Laat j het eerste voorwerp zijn met x[j] < 1. Als j < j, dan x[j ] = 1. Als j > j, dan x[j ] = 0. 33
Bewijs (vervolg) Schrijf X voor rijtje (x[1],, x[n]). Laat Y = (y[1],, y[n]) een andere oplossing zijn. (Dus, gewicht van Y hooguit G.) Nu: n i = 1 ( x i y i ) g i Schrijf W(X) is totale waarde van X, net zo W(Y). W ( X ) n 0. = = x i w i 1 i 34
35 = = n i i i i w y x Y W X W 1 ) ( ) ( ) ( i i n i i i i g w g y x = =1 ) ( In elk van de drie gevallen (i < j, i=j, i>j) geldt j j i i i i i i g w y x g w y x ) ( ) ( Dus 0. ) ( ) ( ) ( 1 = n i i i i j j g y x g w Y W X W Iedere oplossing heeft waarde hooguit die van X; X is dus optimaal. QED
Scheduling: minimizing average Een balie met klanten. waiting time Klanten hebben verschillende service-tijden: de totale tijd nodig door de balie voor deze klant. In deze versie komen alle klanten tegelijk binnen. In welke volgorde kunnen we klanten afhandelen zodat de totale tijd dat klanten wachten zo klein mogelijk is? 36
Greedy algorithm Minimizing total waiting time Zolang er nog wachtende klanten zijn, kies de wachtende klant met de kleinste service-tijd, en behandel die, d.w.z., behandel klanten in volgorde van stijgende (niet-dalende) service-tijd. Dit algoritme geeft een optimale oplossing, d.w.z., elke oplossing heeft een totale wachttijd minstens die van deze oplossing. 37
Bewijs a b b a Een schema dat niet greedy is is niet optimaal. Er zijn dan klanten a en b, met a geholpen voor b, met s(a) > s(b). Wissel a en b in het schema om, en we krijgen een schema met kleinere totale wachttijd. 38
Scheduling with deadlines 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 39
Voorbeeld Taak 1 2 3 4 Opbrengst 50 10 15 30 Deadline 2 1 2 1 Tien mogelijkheden, beste is: Eerst taak 4, dan taak 1: opbrengst 80. 40
Een eenvoudiger probleem: Mogelijke verzameling taken Noem een verzameling taken S mogelijk (feasible), als er een volgorde van de taken in S is, zodat Elke taak in S wordt uitgevoerd Elke taak in S wordt uitgevoerd voor de deadline. Hoe kan je, voor gegeven verzameling taken S, testen of deze mogelijk is? Met een greedy algoritme 41
Greedy algoritme om te testen of verzameling taken mogelijk is Doe steeds de taak met de vroegste deadline. D.w.z.: voer taken uit in volgorde van stijgende deadline. Test of zo geen taak te laat wordt uitgevoerd. Dit schema geeft een kloppend schema, d.e.s.d. als een verzameling mogelijk is. => : triviaal <= : Stel schema met taken met deadlines d 1 d 2 d n geeft geen kloppend schema. Stel taak d k is de eerste taak die niet op tijd klaar is. Dan zijn er k taken met een deadline hooguit k 1, en daar is nooit een kloppend schema voor. 42
Greedy algoritme voor scheduling met deadlines Begin met verzameling taken S =. N = verzameling van alle taken. While N Do Kies taak t uit N met hoogste opbrengst. If (S {t} is mogelijk) Then S = S {t} Output S Kan getest worden met zojuist behandeld algoritme 43
Greedy is optimaal (1) Stel algoritme vindt verzameling taken I, en stel J is optimale verzameling taken, met kloppende schema s. Eerst transformeren we de schema s zodat de taken die zowel in I als in J zitten tegelijk worden uitgevoerd (er mogen gaten komen.) I p y q x r Schuif de gemeenschappelijke taak J r s t p u v q w naar achteren, en dus de andere naar I x y p r q voren. J u s t p r v q w 44
Greedy is optimaal (2) Kijk naar het eerste moment dat de schema s verschillend zijn. Er zijn drie gevallen: 1. Schema J heeft een gat, en schema I voert een job uit. 2. Schema I heeft een gat, en schema J voert een job uit. 3. Ze voeren een verschillende job uit, zeg job a door t schema van I (greedy) en job b door t schema van J (optimaal). 45
Geval 1: Schema J (opt) heeft gat I x y p r q J x t p r v q w Taak y kan worden toegevoegd aan schema J, dus J was niet optimaal. Tegenspraak. 46
Geval 2. Schema I (greedy) heeft een gat I x s p r q J x y t p r v q w De verzameling I {y} is mogelijk, dus greedy zou y toevoegd hebben; tegenspraak. 47
Geval 3: I en J voeren een andere job uit I x a s p r q J x b t p r v q w Geval 3a: opbrengst (a) > opbrengst (b). J is niet optimaal: J {b} {a} is mogelijk en beter. Geval 3b: opbrengst(b) > opbrengst (a). Kan niet gebeuren: b wordt bekeken voor a en zou door greedy genomen zijn, want I {a} {b} is doenbaar. Geval 3c: opbrengst(a) = opbrengst(b). Enige geval zonder tegenspraak. 48
Greedy is optimaal (slot) Zo kunnen we laten zien: Op elk tijdstip hebben I en J dezelfde taak, of een taak met dezelfde opbrengst. Dus hebben I en J dezelfde opbrengst: het greedy algoritme geeft een optimale oplossing. 49
Implementatie Sorteer de taken op niet-stijgende opbrengst: g 1 g 2 g n. Array job geeft welke job op welk tijdstip wordt gedaan. Gebruik extra taak 0, met d[0]=0; job[0]=0. (Schildwacht. ) job[1] = 1; k = 1; for i = 2 to n do r=k; Job 1 kan altijd gekozen while d[job[r]] > d[i] and d[job[r]] > r do r = r-1; if r+1 d[i] Job i kan worden ingevoegd then for m=k step 1 to r+1 do job[m+1]=job[m]; job[r+1]=i; k=k+1; return k, job[1..k]; Helpt voor snellere implementatie Zoek de plaats van job i Schuif job i ertussen 50
Tijd van algoritme Sorteren kost Θ(n log n). Dubbele loop: Θ(n 2 ) Kan sneller: gebruik efficientere test voor mogelijkheid van verzameling taken. 51
Een lemma Ander greedy algoritme Een verzameling taken is mogelijk, dan en slechts dan als een schema als volgt gemaakt kan worden: Begin met een leeg schema. Schedule de taken een voor een, zet taak op het laatste tijdstip voor zijn deadline, en voor tijd n dat nog vrij is. Bewijs: Stel we willen een job met deadline d toevoegen, maar dit kan niet. Dan zijn alle tijdstippen tussen 1 en r=min(n,d) bezet. Stel s is eerste tijdstip zonder taak. s>r. Alle taken gepland op tijdstippen 1 t/m s-1 hebben deadline hooguit s-1. Samen met job op tijdstip d hebben we s jobs met deadline hooguit s-1: verzameling taken is niet mogelijk. 52
53 Snellere implementatie met jobs rechts aangeschoven Lemma geeft: taak die gepland is hoeft niet meer een ander tijdstip te krijgen. Mogelijke implementatie Houdt bij een gebalanceerde boom met alle nog vrije tijdstippen in {1,, n}. Voor taak met deadline d, zoek in boom grootste key d. Kan in O(log n) tijd. Zet taak op gevonden tijdstip en haal tijdstip weg uit boom. Als geen vrij tijdstip voor d meer beschikbaar, wordt de taak niet uitgevoerd
O(n log n) algoritme Sorteer taken op niet-dalende waarde. Zet in B alle tijdstippen in {1, n} Voor alle taken van meest tot minst waardevolle Doe Zoek grootste key in B deadline taak Als beschikbaar, haal deze key uit B, en plan taak op dat tijdstip 54
Als taken al gesorteerd 2e stap kan sneller met behulp van slimme unionfind datastructuur Wordt behandeld in later college 55
Huffman codes Stel we hebben een tekst die we willen coderen als bitstring Sommige letters komen veel vaker voor dan andere Besparen in lengte door: Slim codes (in {0,1}*) toewijzen aan letters Niet elke letter hoeft een code die even lang is 56
Voorbeeld abcaaaacabaabaaabaaaac a komt vaak voor, b en c weinig dus: a wordt 0 b wordt 10 c wordt 11 01011000011010001000010000011 57
Huffman code Beeld elke letter af op een bitstring Geen enkel symbool heeft een code die een prefix (beginstuk) is van de code van een ander symbool (prefix free) Elk symbool heeft frequentie Som over alle symbolen: frequentie * lengte code moet zo klein mogelijk zijn 58
Prefix-vrije codes te representeren als boom 0 1 0 1 0 1 c d 0 1 b c: 00 d: 01 a: 100 e: 101 b: 11 a e 59
Kosten Elk symbool a heeft frequentie f(a) Voor prefix-vrij mapping m: kosten zijn f(a)* m(a) (.. geeft lengte van string) Totale kosten: som van alle a in alphabet van f(a)* m(a) 60
Broerbladen Als we 1 of 2 symbolen hebben: triviaal Als we minstens 3 symbolen hebben: er zijn twee broer-bladen : We kunnen zien welke symbolen we het liefst als broerbladen zien 0 1?? nl.: de twee symbolen met de laagste frequentie 61
Stelling Stel a en b zijn de twee symbolen met de laagste frequentie. Er is een boom waar a en b bladen zijn die dezelfde ouder hebben (broerbladen zijn). Bewijs. Neem een optimale boom. Kijk naar een blad met grootste diepte. Die heeft een broer (want anders kan je de ouder weglaten, en betere Huffman-code krijgen). Verwissel nu a en b met symbolen in die bladeren: de kosten kunnen gelijk blijven of dalen. QED 62
Simplificatie-stap Stel a en b zijn symbolen met de laagste frequentie. Verander alfabet: Laat a en b weg Neem nieuw symbool, zeg c, met frequentie f(a)+f(b) Bewering: de minimale kosten van een Huffmanboom voor het nieuwe alfabet is gelijk aan de minimale kosten van een Huffman-boom voor het oude alfabet 63
Bewijs simplificatiestap Bewering: de minimale kosten van een Huffmanboom voor het nieuwe alfabet + f(a)+f(b) is gelijk aan de minimale kosten van een Huffman-boom voor het oude alfabet => Neem een boom voor het nieuwe alfabet. Waar c stond, neem nu een deelboompje als volgt c 0 1 Kosten stijgen precies met f(a)+f(b) a b 64
Bewijs vervolg <= We weten: er is een boom waar a en b broederbladen zijn. Vervang het gedeelte van a en b en hun ouder door een knoop voor c 0 1 Kosten dalen c a b precies met f(a)+f(b) 65
Algoritme Herhaal tot we 1 symbool over hebben: Zoek de twee symbolen met laagste frequentie, zeg a i en a j. Kies een nieuw symbool a r Haal a i en a j uit alphabet, voeg a r toe met f(a r ) = f(a i )+f(a j ) Zet het triple (i,j,r) op een stack S Maak een boom met 1 knoop van het resulterende symbool Herhaal tot S leeg is: (i,j,r) = Pop(S); Vervang het symbool a r in de boom door een knoop met kinderen a i en a j 66
Voorbeeld op bord Letter a b c d e f Freq % 45 13 12 16 9 5 67
Huffman Algoritme is correct: gebruikt greedy / simplificatie Hoeveel tijd: met bijv. een heap kan dit in O(n log n) tijd als we n symbolen hebben in het alfabet 68
Het Handelsreizigersprobleem Gegeven: stel steden 1, n. Voor elk paar steden i, j, een afstand d(i,j), getal K. Gevraagd: is er een route die in stad 1 begint, elke stad precies 1 keer bezoekt en weer in stad 1 eindigt, en totale lengte hooguit K heeft? 4 1 2 2 3 5 2 3 2 4 4 4 1 2 1 2 2 3 2 3 5 5 2 2 3 4 3 2 4 2 13 11 69
Een greedy heuristiek De dichtstbijzijnde buur (`nearest neighbor ) heuristiek: een heuristiek die geen optimale maar vaak wel redelijke oplossingen geeft. Begin in een willekeurige plaats, zeg 1. Zolang niet alle plaatsen bezocht zijn, ga vanuit de plaats j waar we zijn naar de onbezochte plaats die het dichtst bij j is. Ga weer terug naar 1. 70
8 1 2 2 3 5 2 Geeft optimale oplossing 3 1 4 als we bij 2 beginnen, maar geen optimale oplossing als we in 1 beginnen 71
Conclusies Greedy geeft soms handige snelle algoritmen Bewijs nodig voor optimaliteit Soms redelijke heuristiek 72