Greedy algorithms Algoritmiek.

Presentatie over: "Greedy algorithms Algoritmiek."— Transcript van de presentatie:

1 Greedy algorithms Algoritmiek

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 Algoritmiek

3 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

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 Algoritmiek

5 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

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

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

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

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

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

11 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

12 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

13 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

14 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

15 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

16 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

17 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

18 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

19 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

20 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

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

22 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

23 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

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

25 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

26 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

27 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

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

29 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

30 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

31 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

32 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

33 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

34 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

35 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

36 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

37 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

38 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

39 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

40 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

41 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

42 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

43 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

44 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

45 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

46 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

47 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

48 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

49 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

50 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

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

52 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

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 Algoritmiek

54 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

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

56 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

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

58 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

59 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

60 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

61 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

62 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

63 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

64 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

65 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

66 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

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

68 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

69 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

70 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

71 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

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