Datastructuren en Algoritmen

Transcriptie

1 Datastructuren en Algoritmen Tentamen Vrijdag 6 november Toelichting Bij dit tentamen mag je gebruik maken van een spiekbriefje van maximaal 2 kantjes. Verder mogen er geen hulpmiddelen gebruikt worden. Probeer de antwoorden zo precies mogelijk te geven, wanneer gevraagd wordt naar een aantal hoeft dit niet altijd per se een getal te zijn. Wiskundige operaties zoals bijvoorbeeld of log mogen in het antwoord blijven staan, maar probeer deze wel zoveel mogelijk te simplificeren. Het tentamen bestaat uit 6 vragen met in totaal 15 deelvragen. Tussen haakjes is aangegeven hoe zwaar elke deelvraag meeweegt voor het cijfer, er zijn in totaal 100 punten te verdienen. 1. Mirrored insertion sort Insertion sort (Figure 1) is een vergelijkingsgebaseerd sorteeralgoritme waarbij de elementen één voor één in de gesorteerde prefix van de lijst worden ingevoegd. Om te bewijzen dat het algoritme correct sorteert, kun je de loop-invariant gebruiken dat na i iteraties de eerste i elementen in oplopende volgorde staan. In deze opgave kijken we naar mirrored insertion sort, waarbij we de elementen van rechts naar links behandelen, en één voor één op de juiste plek invoegen in de gesorteerde suffix. We spiegelen het algoritme dus door niet aan de linkerkant van de lijst een gesorteerde sublijst op te bouwen, maar juist aan de rechterkant. Hiermee sorteren we nog wel steeds in oplopende volgorde. (10) (a) Geef, in pseudocode, een implementatie van mirrored insertion sort. insertion-sort(a) 1 for j = 2 to A.length 2 key = A[j] 3 / Voeg A[j] aan de gesorteerde rij A[1.. j 1] toe 4 i = j 1 5 while i > 0 and A[i] > key 6 A[i + 1] = A[i] 7 i = i 1 8 A[i + 1] = key Figure 1: Insertion sort zoals in het college behandeld. 1

2 mirrored-insertion-sort(a) 1 for j = A.length 1 downto 1 2 key = A[j] 3 i = j while i A.length and A[i] < key 5 A[i 1] = A[i] 6 i = i A[i 1] = key (5) (b) Bewijs met behulp van een loop invariant de correctheid van het algoritme. Schrijf in elk geval de invariant op, een bewijs voor de initialization en maintenance stappen, en de conclusie. (beknopt, maximaal 15 zinnen) Loop invariant: aan het begin van iteratie j is de subarray A[j + 1..A.length] gesorteerd Initialization: j begint bij A. length 1, dus de subarray A[A. length A. length] = A[A. length..a. length] bestaat uit één element en is dus altijd gesorteerd. Maintenance: de index i gaat van j + 1 tot aan A.length, wat precies het gesorteerde deel van de lijst is. Elk element wordt 1 positie naar links geschoven wanneer het element kleiner is dan de waarde op positie j. Na de loop is i de positie van het eerste element dat groter is, en het element van positie j wordt dan dus op i 1 ingevoegd, waardoor de subarray A[j + 1..A.length] weer gesorteerd is. Termination: de loop termineert gegarandeerd na het vastgelegde aantal iteraties. Dat is bij j = 0, waardoor de loop invariant geeft dat A[ A.length] = A[1..A. length] gesorteerd is. De conclusie is dus dat het algoritme werkt zoals verwacht. (5) (c) Geef de asymptotische looptijd van dit algoritme en vergelijk dit met de looptijd van de normale variant van insertion sort. In het slechtste geval doet de binnenste for-loop n j stappen, dus in totaal doet het algoritme dan n j=1 n j = n2 n j=1 j = n2 (n (n 1))/2 = n 2 (n 2 n)/2 = n 2 n 2 /2 + n/2 = n 2 /2 + n/2 = O(n 2 ). Dit is hetzelfde als de normale variant van insertion sort. In het beste geval (een gesorteerde lijst) wordt de binnenste for-loop nooit uitgevoerd, en doet het algoritme dus O(n) stappen, net als de normale variant van insertion sort. Het is dus incorrect om te stellen dat het algoritme Θ(n 2 ) is. 2. Eén-tegen-100 Eén-tegen-100 is een spelshow op televisie waarbij een kandidaat het opneemt tegen 100 tegenspelers. Bij elke vraag moeten zowel de kandidaat als de tegenspelers die nog in het spel zitten een meerkeuzevraag beantwoorden. Als de kandidaat deze fout heeft ligt hij direct uit het spel. Als de kandidaat deze goed heeft, speelt hij alle tegenspelers die het fout hadden weg. Pagina 2 van 6

3 Wanneer de kandidaat alle tegenspelers heeft weggespeeld wint hij het totaal opgebouwde geldbedrag. Bij elke vraag zijn alle tegenspelers die nog in het spel zitten gezamenlijk e waard. Wanneer er nog n spelers in het spel zitten is elke speler dus e50 000/n waard, en voor elke tegenspeler die er bij die vraag uit gaat krijgt de kandidaat dat bedrag erbij. Het totaal gewonnen bedrag hangt dus af van hoeveel spelers er bij elke vraag uit gaan. Als bijvoorbeeld bij de eerste vraag 37 tegenspelers eruit gaan en bij vraag 2 de overige 63, dan wint de kandidaat dus / /63 = e (4) (a) Neem aan dat de kandidaat alle vraag goed heeft, en dus sowieso een geldbedrag wint. Dit bedrag hangt dan af van wanneer de tegenspelers eruit gaan. Wat is het slechtste geval voor de kandidaat (dus: wanneer wint hij het minst)? Wanneer hij alle spelers er in 1 ronde uit speelt wint hij /100 = e (8) (b) En wat is het beste geval (dus: wanneer wint hij het meest)? Hij wint het meest als hij elke ronde er precies 1 speler uitspeelt. Na i rondes zitten er dan nog 100 i tegenspelers in, en wint hij dus in totaal: 99 i= i = i= i 100 = i=1 1 i = H ln 100 e De speler wint dan dus ruim 2 ton (en als je het precies uitrekent en elke ronde afrondt zoals in het echte spel gebeurt kom je op e uit). (8) (c) Stel dat elke tegenspeler elke vraag met kans 1/3 fout heeft, en dat de kandidaat alle vragen goed heeft. Wat is het verwachte aantal rondes wat er gespeeld wordt voordat alle tegenspelers uit het spel zijn? We verwachten dat bij elke vraag 1/3 van de overgebleven tegenspelers de vraag fout heeft en afvalt. Er blijft bij elke ronde dus 2/3 van de tegenspelers over, dus na n rondes verwachten we dat er nog 100 ( 2 3 )n tegenspelers over zijn. De vraag is dus wat is de kleinste n waarvoor 100 ( 2 3 )n < 1. Beide kanten delen door 100 geeft 2 n 3 < Het logaritme nemen geeft n = log 2/ We verwachten dus ongeveer 11 rondes te spelen. 3. Som-product Gegeven is de volgende pseudocode: Pagina 3 van 6

4 som-product(a, p, r) 1 if p == r 2 return A[p] 3 q = (p + r)/2 4 v 1 = som-product(a, p, q) 5 v 2 = som-product(a, q + 1, r) 6 if v 1 < v 2 7 return v 1 v 2 8 else 9 return v 1 + v 2 (10) (a) Stel een recurrente betrekking op voor de looptijd van dit algoritme. Je mag gebruiken dat n = r p + 1. T (n) = { O(1) als n = 1 2T (n/2) + O(1) als n > 1 (10) (b) Los deze recurrente betrekking op met de Master theorem en geef daarmee de looptijd van dit algoritme. Uit de recurrente betrekking halen we dat a = 2, b = 2, en f(n) = 1. Dit geeft log b a = log 2 2 = 1, dus we hebben geval 1 met ɛ = 1, want f(n) = 1 = n 0 = n log b a 1. De master theorem geeft dan de looptijd Θ(n log b a ) = Θ(n 1 ) = Θ(n). 4. Hashtabel Bij deze opgave bekijken we een hashtabel van grootte m met daarin n elementen. Om botsingen te voorkomen maken we gebruik van ketens (chaining). Je mag aannemen dat de hashfunctie die gebruikt wordt perfect is. (5) (a) Hoeveel tijd kost het om alle elementen uit de hashtabel op te sommen (volgorde maakt niet uit)? Geef je antwoord in Θ notatie. Θ(n + m), want elk vakje in de hashtabel moet worden bekeken (m stappen) en elk element wat in de hashtabel moet worden bekeken (n stappen). Een andere oplossing is om te kijken naar het verwacht aantal stappen per vakje, dat is Θ(1 + α), en dat doen we voor elk vakje: Θ(m (1 + α)) = Θ(m + m α) = Θ(m + n) (want α = n/m). Meta opmerking: Enkele studenten hebben bij het woord opsommen gedacht aan sommeren. Opsommen betekent echter het één voor één opnoemen (of uitprinten) van de elementen, en heeft dus niks te maken met het berekenen van de som. Dat maakt overigens voor de looptijd niet uit, want je moet hoe dan ook elk element eenmaal bekijken. (5) (b) Is het slim om hiervoor een hashtabel te gebruiken als je een verzameling elementen hebt die je wilt opsommen? Zo ja, leg uit waarom. Zo nee, geef een voorbeeld van een datastructuur waarmee dat beter kan. Pagina 4 van 6

5 Nee, want als we bijvoorbeeld een hele grote hashtabel hebben (m = 1000) met maar 1 element erin (n = 1), dan moeten we nu in het slechtste geval alle m vakjes bekijken om het element te kunnen opsommen. Vrijwel elke andere dynamische verzameling ondersteunt het opsommen van n elementen in Θ(n), zoals bijvoorbeeld een stack, queue, linked list, of zelfs een zoekboom (zie vraag 5). 5. Zoekbomen Deze vraag gaat over gebalanceerde zoekbomen. Hierbij kun je bijvoorbeeld denken aan rood-zwart-bomen of ALV bomen; welke precies maakt voor deze vraag niet uit. (5) (a) Alle elementen uit een gebalanceerde zoekboom van grootte n kunnen op oplopende volgorde worden opgesomd door door eerst tree-minimum aan te roepen en vervolgens n 1 keer tree-successor. Hoeveel tijd kost dit? Kies een van de volgende antwoorden. A. Θ(n 2 ) B. Θ(n) C. Θ(n log n) D. Θ(n n) Θ(n) (5) (b) Leg je antwoord voor (a) kort uit. Bij het aflopen van de zoekboom op deze volgorde bezoeken we eerst het kleinste elementen ( helemaal links ), en gaan dan op volgorde steeds naar grotere elementen. Voor elke subboom (dus: voor elk van de n elementen) komen we eenmaal de subboom in, bezoeken dan eerst de volledige linker subboom, sommen we het huidige element op, bezoeken dan de volledige rechter subboom, en zijn dan klaar. Er wordt dus een constant aantal stappen per knoop gedaan, dus in totaal is dit algoritme Θ(n). Merk op dat tree-successor in het slechtste geval O(log n) stappen doet, maar dat dat slechtste geval niet alle n de keren kan voorkomen, dus een looptijd van Θ(n log n) is incorrect. 6. Spelgrafen De verschillende spelsituaties van veel bordspellen (bijvoorbeeld: vier-op-een-rij, boter-kaasen-eieren, ganzebord, dammen, schaken) kunnen worden gepresenteerd in een graaf. Elke knoop stelt dan een bepaalde stand op het bord voor (bijvoorbeeld de plekken waar de damstukken staan), en elke kant stelt een zet voor die een van de spelers doet, waarmee het bord dus in een andere stand komt. (5) (a) Zou je voor het representeren van de meeste spellen (zoals de genoemde voorbeelden) een gerichte of juist ongerichte graaf gebruiken? Leg uit waarom. Pagina 5 van 6

6 Gerichte graaf, want zetten zijn lang niet altijd omkeerbaar. (5) (b) Of de graaf cyclisch kan zijn hangt af van het type spel. Geef een voorbeeld van een spel waarbij de graaf cyclisch kan zijn en een voorbeeld van een spel waarbij de graaf geen cycles bevat. Cyclisch: mens-erger-je-niet, ganzebord (als je dood gaat begin je opnieuw), dammen (wanneer beide spelers een dam hebben kunnen zeheen en weer tussen dezelfde stand), schaken, etc. Niet-cyclisch: vier-op-een-rij, boter-kaas-en-eieren, etc. (10) (c) Twee bekende representaties voor grafen zijn de matrixrepresentatie en de lijst-vanburen-representatie. Een derde mogelijkheid is de zogenaamde impliciete representatie, waarbij de buren van elke knoop worden uitgerekend op het moment dat die nodig zijn. In het geval van spelgrafen werkt dit goed, doordat voor elke stand op het bord snel uitgerekend kan worden welke geldige zetten er zijn (en in welke stand die uitkomen). Bij het doen van een berekening over de graaf, bijvoorbeeld een breadth first search waarbij de knopen een voor een zwart gekleurd worden, levert dit echter een extra moeilijkheid op in de implementatie. Leg uit wat het probleem is en hoe dit opgelost kan worden. Het probleem is dat er geen expliciete representatie van een knoop is, en we kunnen dus ook niet zomaar een knoop zwart kleuren (want: waar slaan we op dat de knoop zwart is?). We moeten dus een andere manier hebben om te bepalen of een bepaalde stand al geweest is ( zwart gekleurd is ), dit kan bijvoorbeeld door de zwarte knopen in een hashset op te slaan (en een goede hashfunctie te verzinnen voor onze stand-op-het-bord-representatie). Pagina 6 van 6