Greedy algorithms Algoritmiek. 2 Vandaag Greedy algorithms: wat zijn dat? Voorbeelden: –gepast betalen met euromunten –AB-rijtje –… Knapsack probleem.

Presentatie over: "Greedy algorithms Algoritmiek. 2 Vandaag Greedy algorithms: wat zijn dat? Voorbeelden: –gepast betalen met euromunten –AB-rijtje –… Knapsack probleem."— Transcript van de presentatie:

1 Greedy algorithms Algoritmiek

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

3 Algoritmiek3 Greedy algorithms Greed = hebzucht 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

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

5 Kortste A,B-rijtje Nog eens: A,B-rijtje is rij getallen met: –1e getal is A –Laatste getal is B –Ieder getal is vorige getal +1 (I) of *2 (D) Vraag: gegeven A en B, wat is het kortste A,B- rijtje We zagen een DP, maar … het kan slimmer Algoritmiek5

6 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: … Algoritmiek6

7 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 =2A en B even Algoritmiek7

8 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)); Algoritmiek8

9 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 sr i/2 D : dit is korter: tegenspraak –Altijd tegenspraak, dus optimale sequence eindigt op D Algoritmiek9

10 Idee Optimale keuze voor laatste element Heeft een bewijs nodig… We hoeven niet te kiezen – kunnen 1 kant opgaan! Noemen we … greedy … Algoritmiek10

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

12 Algoritmiek12 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!

13 Algoritmiek13 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 Dit doet zich niet voor bij Euro’s

14 Algoritmiek14 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. Als M = { 1, 10, 25} dan is dit niet waar: Kijk naar n = 30.

15 Algoritmiek15 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;

16 Algoritmiek16 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.

17 Algoritmiek17 Schema voor greedy algoritme function Greedy(C:set) {C is de verzameling van beschikbare elementen / keuzes die je kan magen} S=  ; {S is de oplossingsverzameling} while C   and not solution(S) do x = select(C); C = C\{x}; if feasible(S  {x}) then S = S  {x}; if solution(S) then return S; else return “er is geen oplossing”; Muntwissel past in schema Muntwissel past in schema

18 Algoritmiek18 Greedy algoritmen: optimaal of niet? Soms geven greedy algoritmen optimale antwoorden, bijv.: –Muntwisselprobleem met euro-munten –Dijkstra’s algoritme met niet-negatieve pijllengtes –Meer voorbeelden volgen Soms geven greedy algoritmen geen optimale antwoorden, bijv.: –Muntwisselprobleem met munten 1, 10, 25 –Dijkstra’s algoritme met pijllengtes die negatief mogen zijn Dan is greedy een heuristiek. Soms kan je bewijzen dat greedy in de buurt van het beste antwoord komt.

19 Oliepijpen in Rusland Pijplijn Kan lekken Waar plaatsen we kleppen (valves)? DP of greedy? Algoritmiek19

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

21 Algoritmiek21 Wiskundige formulering Kies reële getallen x 1 … x n  [0,1] zodat en zodat zo groot mogelijk is.

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

23 Algoritmiek23 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?

24 Algoritmiek24 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. –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

25 Algoritmiek25 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 dalend 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++;

26 Algoritmiek26 Greedy met waarde/gewicht geeft optimale oplossing Stelling. Als de voorwerpen gekozen worden in volgorde van niet-dalende waarde w[i]/g[i], dan geeft het greedy algoritme een optimale oplossing. Bewijs. Stel voorwerpen genummerd op niet-dalend 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.

27 Algoritmiek27 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: Schrijf W(X) is totale waarde van X, net zo W(Y).

28 Algoritmiek28 In elk van de drie gevallen (i j) geldt Dus Iedere oplossing heeft waarde hooguit die van X; X is dus optimaal. QED

29 Algoritmiek29 Scheduling: minimizing average waiting time Een balie met klanten. 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?

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

31 Algoritmiek31 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.

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

33 Algoritmiek33 Voorbeeld Taak1234 Opbrengst50101530 Deadline2121 Tien mogelijkheden, beste is: Eerst taak 4, dan taak 1: opbrengst 80.

34 Algoritmiek34 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…

35 Algoritmiek35 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.

36 Algoritmiek36 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 Kan getest worden met zojuist behandeld algoritme

37 Algoritmiek37 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.) rxqyp vquptsrw qrpyx vqrptsuw Schuif de gemeen- schappelijke taak naar achteren, en dus de andere naar voren. Schuif de gemeen- schappelijke taak naar achteren, en dus de andere naar voren. I J J I

38 Algoritmiek38 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).

39 Algoritmiek39 Geval 1: Schema J (opt) heeft gat qrpyx vqrptxw I J Taak y kan worden toegevoegd aan schema J, dus J was niet optimaal. Tegenspraak.

40 Algoritmiek40 Geval 2. Schema I (greedy) heeft een gat qrpsx vqrptyxw I J De verzameling I  {y} is mogelijk, dus greedy zou y toevoegd hebben; tegenspraak.

41 Algoritmiek41 Geval 3: I en J voeren een andere job uit 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. qrpsax vqrptbxw I J

42 Algoritmiek42 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.

43 Algoritmiek43 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; while d[job[r]] > d[i] and d[job[r]] > r do r = r-1; if r+1  d[i] 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 Job 1 kan altijd gekozen Zoek de plaats van job i Job i kan worden ingevoegd Schuif job i ertussen

44 Algoritmiek44 Tijd van algoritme Sorteren kost  (n log n). Dubbele loop:  (n 2 ) Kan sneller: gebruik efficientere test voor mogelijkheid van verzameling taken.

45 Algoritmiek45 Een lemma 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. Ander greedy algoritme

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

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

48 Algoritmiek48 Als taken al gesorteerd 2e stap kan sneller met behulp van slimme union- find datastructuur Wordt behandeld in later college

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

50 Voorbeeld abcaaaacabaabaaabaaaac a komt vaak voor, b en c weinig dus: –a wordt 0 –b wordt 10 –c wordt 11 01011000011010001000010000011 Algoritmiek50

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

52 Prefix-vrije codes te representeren als boom Algoritmiek52 c c d d b b a a e e 0 0 0 0 1 1 1 1 c: 00 d: 01 a: 100 e: 101 b: 11 c: 00 d: 01 a: 100 e: 101 b: 11

53 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)| Algoritmiek53

54 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 … nl.: de twee symbolen met de laagste frequentie … Algoritmiek54 ? ? ? ? 01

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

56 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 Huffman- boom voor het nieuwe alfabet is gelijk aan de minimale kosten van een Huffman-boom voor het oude alfabet Algoritmiek56

57 Bewijs simplificatiestap Bewering: de minimale kosten van een Huffman- boom 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 Algoritmiek57 c c a a b b 01 Kosten stijgen precies met f(a)+f(b) Kosten stijgen precies met f(a)+f(b)

58 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 Algoritmiek58 c c a a b b 01 Kosten dalen precies met f(a)+f(b) Kosten dalen precies met f(a)+f(b)

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

60 Voorbeeld op bord Letter a b c d e f Freq % 45 13 12 16 9 5 Algoritmiek60

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

62 Algoritmiek62 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? 12 34 4 5 2 2 3 2 12 34 4 5 2 2 3 2 12 34 4 5 2 2 3 2 13 11

63 Algoritmiek63 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.

64 Algoritmiek64 12 34 8 5 1 2 3 2 Geeft optimale oplossing als we bij 2 beginnen, maar geen optimale oplossing als we in 1 beginnen

65 Conclusies Greedy geeft soms handige snelle algoritmen Bewijs nodig voor optimaliteit Soms redelijke heuristiek Algoritmiek65