Greedy algorithms Algoritmiek

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 Algoritmiek

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 Algoritmiek

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 Algoritmiek

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,B-rijtje We zagen een DP, maar … het kan slimmer Zoals in het college besproken. Ik neem even aan dat A>=1; A=0 geeft een extra geval Algoritmiek

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: … Algoritmiek

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 Algoritmiek

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)); Algoritmiek

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: IB-A is langer dan IB/2-AD: tegenspraak Geval 2: rijtje heeft vorm sDIr. r is even, want getal is altijd even na een D. Neem nu rijtje sIr/2D : dit is korter: tegenspraak Altijd tegenspraak, dus optimale sequence eindigt op D Algoritmiek

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

Greedy vs Dynamisch Programmeren DP Deelproblemen met zelfde structuur als originele problem We bekijken alle keuzes Slim tabelleren voorkomt extra werk Langzamer dan Greedy i.h.a. Exact Greedy Deelprobleem met zelfde structuur als originele problem We bekijken steeds maar 1 keuze Heeft een bewijs nodig voor optimaliteit, anders niet-exacte heuristiek Algoritmiek

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?) Algoritmiek

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 Veel bewijzen gaan met uitwissel-argumenten Algoritmiek

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

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 Algoritmiek

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

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

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

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 Algoritmiek

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

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

Oliepijpen probleem Gegeven: 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? l1 l2 ln Algoritmiek

Oplossingsstrategie 1: Dynamisch programmeren O(n2 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 Algoritmiek

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: … Algoritmiek

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

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 Of reken eerst alle sommaties uit over alle deelstukken, en doe dan binary search op die collectie van waardes. Dit geeft O(n^2) Algoritmiek

Knapsack met fractionele oplossingen n Voorwerpen met Waardes w1, … wn (positief) Gewichten g1, … , gn (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*wj waarde en 2/3*gj 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.) Algoritmiek

Wiskundige formulering Kies reële getallen x1 … xn Î [0,1] zodat en zodat zo groot mogelijk is. Algoritmiek

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

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

Over schema voor greedy algoritme voor knapsack Hooguit 1 voorwerp wordt voor een deel (0<xi <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 wi / gi Algoritmiek

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++; Algoritmiek

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 niet-stijgend 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. Algoritmiek

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). W(X) is dus de som van de termen w[i]*x[i] waar i van 1 tot n loopt. Algoritmiek

In elk van de drie gevallen (i < j, i=j, i>j) geldt Dus Je kan dit ook met een uitwisselargument bewijzen. Dat heeft wat gevalsonderscheid; langer maar geeft wel de intuitie beter weer. Iedere oplossing heeft waarde hooguit die van X; X is dus optimaal. QED Algoritmiek

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

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

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

Scheduling with deadlines n taken Iedere taak kost evenveel (1) tijd Taken hebben een deadline di Taken hebben een opbrengst gi Een taak brengt gi op dan en slechts dan als de taak uitgevoerd is op tijd di of eerder Welke taken voeren we uit, en in welke volgorde, zodat Taken uitgevoerd uiterlijk op deadline Totale opbrengst zo groot mogelijk Algoritmiek

Voorbeeld Taak 1 2 3 4 Opbrengst 50 10 15 30 Deadline Tien mogelijkheden, beste is: Eerst taak 4, dan taak 1: opbrengst 80. Algoritmiek

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

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 d1 £ d2 £ … £ dn geeft geen kloppend schema. Stel taak dk 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. Het kan ook anders: kies een taak met maximale deadline, en doe die op het laatste tijdstip dat vrij is voor zijn deadline. Algoritmiek

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 Algoritmiek

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.) p y q x r I Schuif de gemeen- schappelijke taak naar achteren, en dus de andere naar voren. J r s t p u v q w Greedy is optimaal voor het probleem voor scheduling met deadlines. I x y p r q J u s t p r v q w Algoritmiek

Greedy is optimaal (2) Kijk naar het eerste moment dat de schema’s verschillend zijn. Er zijn drie gevallen: Schema J heeft een gat, en schema I voert een job uit. Schema I heeft een gat, en schema J voert een job uit. Ze voeren een verschillende job uit, zeg job a door ‘t schema van I (greedy) en job b door ‘t schema van J (optimaal). Algoritmiek

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

Geval 2. Schema I (greedy) heeft een gat 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. Algoritmiek

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

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

Implementatie Helpt voor snellere implementatie Sorteer de taken op niet-stijgende opbrengst: g1 ³ g2 ³ … ³ gn. 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]; Job 1 kan altijd gekozen Zoek de plaats van job i Job i kan worden ingevoegd Schuif job i ertussen Algoritmiek

Tijd van algoritme Sorteren kost Q(n log n). Dubbele loop: Q(n2) Kan sneller: gebruik efficientere test voor mogelijkheid van verzameling taken. Algoritmiek

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

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 Algoritmiek

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 Algoritmiek

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

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 Algoritmiek

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

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 Algoritmiek

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

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

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 … 1 ? ? Algoritmiek

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 Algoritmiek

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 Algoritmiek

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 c Kosten stijgen precies met f(a)+f(b) 1 a b Algoritmiek

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 1 Kosten dalen precies met f(a)+f(b) c a b Algoritmiek

Algoritme Herhaal tot we 1 symbool over hebben: Zoek de twee symbolen met laagste frequentie, zeg ai en aj . Kies een nieuw symbool ar Haal ai en aj uit alphabet, voeg ar toe met f(ar) = f(ai)+f(aj) 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 ar in de boom door een knoop met kinderen ai en aj Algoritmiek

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

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 Algoritmiek

Het Handelsreizigersprobleem 1 2 3 4 5 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 4 1 2 1 2 3 3 2 2 5 Wordt in 2015/16 overgeslagen 5 2 2 3 3 4 2 4 2 13 11 Algoritmiek

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

Geeft optimale oplossing 8 1 2 3 2 5 2 Geeft optimale oplossing als we bij 2 beginnen, maar geen optimale oplossing als we in 1 beginnen 3 1 4 Algoritmiek

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