Tweede Toets Datastructuren 27 juni 2018, , Olympos Hal 2.

Transcriptie

1 Tweede Toets Datastructuren 27 juni 2018, , Olympos Hal 2. Motiveer je antwoorden kort! Stel geen vragen over deze toets; als je een vraag niet duidelijk vindt, schrijf dan op hoe je de vraag interpreteert en beantwoord de vraag zoals je hem begrijpt. Cijfer: Vraag 1, 4 en 6 zijn 2pt, vraag 2, 3 en 5 zijn 3pt. Te behalen 15pt, T2 is totaal plus een half gedeeld door 1,5 (max 10). Maak 1 en 2 op de voorkant, 3 en 4 op 2 en 5 en 6 op Utrechters in bier: Bob koopt tien flesjes alcoholvrij bier waar als reclameactie foto s van bekende Nederlanders inzitten. Het is bekend dat voor elk flesje de kans op een Utrechter 1 3 is en dat de plaatjes per flesje onafhankelijk zijn gekozen. (a) Wat is de kans dat Bob in zijn biertjes exact vier Utrechters aantreft? (b) Wat is de verwachting van het aantal Utrechters dat Bob aantreft? Oplossing: ( (a)) Bij n tests met succeskans ( p (en ) faalkans q = 1 p) is de kans op k successen n gelijk aan p k q n k 10. Dat is hier dus ( 1 k 4 3 )4 ( 2 3 )6 (rekenmachine, beuk beuk) is 0,2276. (b) Bij n tests met succeskans p is de verwachting van het aantal successen n.p, hier Beoordeling/Toelichting: Voor elk goed antwoord (0,2276 en ) een punt. Codes: A = De verwachting niet Afronden! Voor alleen ( antwoord ) 3 krijg je 0pt. 10 D = Een flink aantal antwoorden vergat de factor. Getal ( )4 ( 2 3 )6 is de kans op een bepaalde reeks van Utrechters en niet-utrechters in die volgorde. U = Een Utrechtenaar is iets heel anders, beter dit niet verwarren!

2 2. Heap inlezen en bouwen: Dirk moet een heap maken van n getallen van de invoer. Hij maakt een List<int> Heap aan, voegt n maal een getal toe met x =...; Heap.Add(x);, en doet eenmaal Heap.BuildHeap(). (a) Wat is de complexiteit van BuildHeap en hoe werkt die? (b) Dirk maakt zich zorgen over de herhaalde Add(x), omdat telkens wanneer de array in Heap vol is, een langere wordt aangemaakt en alle waarden overgestapeld, wat lineaire tijd kost. Wat is de totale complexiteit van de n Add-operaties? Motiveer kort! (c) Ineke zegt dat hij beter elk ingelezen getal direct kan invoegen met Heap.Insert(x). Wat is de complexiteit van Ineke s idee, en is het beter of slechter dan Dirks plan? Oplossing: (a) BuildHeap bestaat uit herhaald Heapify, op de halve array van hoog naar laag: for (int i = n/2; i >= 1; i--) Heapify(i); (Heapify vergelijkt plek i met z n kinderen, eventeel wordt gewisseld met 1 kind en wordt dat kind geheapified.) Hoewel Heapify(i) tot lg n tijd kan kosten, zijn hier de meeste aanroepen heel snel en is de totale tijd van BuildHeap() lineair, O(n). (b) De overstapelingen zijn gelukkig relatief zeldzaam omdat de omvang van de array steeds verdubbelt. Als er k getallen moeten worden overgezet, was de vorige overzetting van k/2 getallen en sinds die overstapeling zijn er k/2 getallen toegevoegd. Gemiddeld worden er dus hoogstens twee getallen overgestapeld per Add(x), waardoor de gemiddelde complexiteit constant is en het totaal lineair, O(n). (c) Invoegen in een heap kost Θ(lg n) en Ineke s idee kost daarom Θ(n lg n). Dirks plan kost lineaire tijd voor het herhaald Adden, inclusief het verdubbelen, en lineaire tijd voor BuildHeap(). Dat blijft totaal lineair en is daarmee sneller dan Ineke s idee, dat dus niet goed is voor Dirk. Beoordeling/Toelichting: Per deelvraag een punt, totaal 3. Codes: B = Als n vantevoren Bekend is, kan Dirk meteen een List verzinnen die lang genoeg is; goedgerekend alternatief voor (b). C = Complexiteit van BuildHeap niet goed. D = Ook Ineke s idee heeft de verdubbeling nodig. E = Als je de array na een Add(x) steeds Een groter maakt, wordt de totale tijd kwadratisch. Dat is meteen de reden dat dit nooit zo wordt gedaan! J = BuildHeap zet niet een voor een de elementen op de Juiste plaats. De heap-eigenschap is zo soepel dat er niet 1 juiste plek is. Elementen die eerst geheapified zijn, worden later weer verplaatst. L = Je stapelt Logaritmisch vaak over in Lineaire tijd dus totaal O(n lg n) klopt niet! Een overstapeling kost lineair veel tijd in het aantal elementen op dat moment. Tel je dan alle omstapelingen bij elkaar dat kom je (meetkundige reeks) op lineair. M = Of de heap een MinHeap of MaxHeap is maakt voor deze vraag niet uit. N = De complexiteit van 1 operatie is Niet hetzelfde als die operatie n keer toepassen. V = Voor het Vergelijken van de twee ideeën alleen punten als je de goede dingen vergelijkt. W = Werking van BuildHeap niet (goed) vermeld. X = Het is wel slim om met inserts te werken als je tijdens het invoegen al extracts wilt doen. De vraag zegt vrij duidelijk dat dit niet Dirks missie is.

3 3. De SomStack: Steven heeft voor zijn algoritme een SomStack nodig. Behalve de standaard Stack-operaties heeft die ook de SomKeys(), die de som van getallen op de stack oplevert. Steven beschikt over de Stack klasse uit C#, maar weet niet of deze als array of gelinkte lijst gemaakt is. (a) Wat zijn de drie belangrijkste methoden van een Stack, en wat is hun complexiteit? (b) Geef een efficiente implementatie van SomStack, die de Stack gebruikt. Oplossing: (a) De belangrijkste twee zijn de Push(x) en Pop(), en om loop te termineren heb je meestal een Count of isempty() nodig. Elk van deze is constante-tijd, O(1), al heb je bij een pointer-implementatie hiervoor wel een aparte count variabele nodig. (b) Gebruik een Stack S waar de keys op staan, en een aparte t die het totaal bijhoudt: SomStack() SomKeys() S = new Stack(); t = 0; return t; Push(x) Pop() S.Push(x) ; t += x; r = S.Pop(); t-=r; return r; De Count en isempty komen rechtstreeks van S. Beoordeling/Toelichting: Totaal 3pt, 1 voor a en 2 voor b. Codes: C = Als derde operatie mag je ook Create, Peek of Top noemen. D = SomKeys is Destructief; meestal icm. Lineair, dan 0pt. Als t probleem gesignaleerd, mogelijk 1/2. Omkering van de stack (mislukte reparatiepoging) telt ook als destructie. E = isempty is niet hetzelfde als (t==0) want er kunnen nullen staan. F = Niet-bestaande operatie of Foute complexiteit, 1/2. De Count is constant! Als je lineaire tijd zegt voor Push en Pop, 0pt. G = Je moest een implementatie Geven, dwz., code, niet alleen beschrijven in woorden. L = Som berekenen met loop is Lineaire tijd, niet efficient! Max 1pt. M = Push op lege stack gaat mis omdat je van hulpstack Popt. N = Een complete Nieuwe implementatie maken was niet de bedoeling, je moest Stack gebruiken, max 1pt. S = Sla niet bij elk element een som op, dit kost overbodig veel geheugen. T = Noemt maar Twee methoden, 1/2pt bij (a) maar geen aftrek bij (b). V = for(int i=0; i < s.count; i++) tot += s.pop(); sommeert (en vernielt) maar de helft van de stack, daarna is i opgelopen en Count gedaald tot n/2. W = Werking veronderstelt bepaalde Stack-implementatie.

4 4. Recurrentie: Rij S n is gedefinieerd door S 0 = 3, S 1 = 1 en S n = 2S n 1 + 3S n 2. Er bestaat een gesloten formule voor S van de vorm S n = C.α n + D.β n. (a) Hoe kun je de α en β bepalen? Geef de uitkomst. (b) Hoe kun je de C en D bepalen? Geef de uitkomst en de formule voor S. Oplossing: (a) De α en β zijn oplossingen van x n = 2x n 1 + 3x n 2, dus x 2 = 2x + 3. Oplossingen (ABC-formule) zijn α = 3 en β = 1. (b) Gebruik de al gevonden waarden en de twee startwaarden, en zeg S 0 = 3 = C.3 0 +D.( 1) 0 en S 1 = 1 = C D.( 1) 1. Dus C + D = 3 en 3C D = 1, oplossing is C = 1 en D = 2. De S-formule luidt dus S n = 3 n + 2.( 1) n. Beoordeling/Toelichting: Per deelvraag 1pt. Codes: A = Het kan ook Andersom, dus α = 1 en β = 3, dan zijn je C en D ook verwisseld en je S-formule is hetzelfde. R = Alleen een Rekenfoutje? Helaas, alleen goede antwoorden krijgen een punt. S = Stapelopgave? Alleen als je (a) had kon je (b) oplossen. Dit verschijnsel is niet altijd te vermijden. T = Term 2.( 1) n is niet hetzelfde als 2.(1) n! W = Pas de Wortelformule (abc-formule) toe. 5. Dukkel: In een lijst A van n verzamelingen is verzameling A[i] een dukkel als hij deel is van een latere verzameling, dus als er een j > i is met A[i] A[j]. Door de binaire representatie is X Y in constante tijd te checken, maar voor elke i en j apart A[i] A[j] doen is duur (kwadratisch). We volgen deze aanpak: kijk recursief naar de eerste en tweede helft van A afzonderlijk. Als de eerste helft een dukkel bevat, lever die op en klaar. Als de tweede helft een dukkel bevat, lever die op en klaar. Alleen wanneer geen van de helften een dukkel bevat, vergelijk je elke set in de eerste helft met elke in de tweede helft. (a) Geef een recurrente betrekking voor de looptijd van dit algoritme. (b) Geef de oplossing van deze betrekking. (c) Los op: G(n) = 2G(n/3) + n. Oplossing: (a) Noem de tijd voor n verzamelingen D(n). Als er geen dukkel is zijn er twee recursieve aanroepen op halve grootte. Alles in de eerste met alles in de tweede lijst vergelijken kost n 2 n 2 dus O(n2 ). De betrekking is dus D(n) = 2D(n/2) + O(n 2 ). (b) Gevalletje Master Theorem met a = 2 en b = 2 dus b log a = 1. Dwangterm is kwadratisch, dus polynomiaal zwaarder, uitkomst D(n) = O(n 2 ). (c) Gevalletje Master Theorem met a = 2 en b = 3 dus b log a = 0, 63. Dwangterm is wortel, dus n 0,50, polynomiaal lichter, uitkomst D(n) = O(n 0,63 ). Beoordeling/Toelichting: Per deelvraag een punt. Codes: C = De Check of X Y is ((X & ~ Y) == 0). V = Verkeerde vergelijking goed opgelost, soms toch punt.

5 6. Maximum in Hashtabel: In een hashtabel (met chaining) List<int>[m] A van lengte m zijn n integer keys opgeslagen. Geef een methode die de grootste key bepaalt en zeg wat de complexiteit van deze methode is. Oplossing: Hashtabellen staan erom bekend dat je snel kunt zoeken naar een bepaalde key, maar de klos bent als je niet exact weet wat je zoekt. Het maximum kan in elke lijst zitten op elke plek en je kunt het alleen vinden door alles te bekijken: (1) int MaxKey() (2) { int r = Int.MinValue; (3) for (int i = 0; i < m; i++) (4) foreach (int k in A[i]) (5) if (k > r) r = k; (6) return r; } Het doorlopen van de array van lijsten (regel 3) kost O(m) tijd en het doorlopen van de lijsten samen O(n). De complexiteit is dus weer te geven als O(n + m). Beoordeling/Toelichting: Tot 2pt voor methode en complexiteit. Codes: A = Achteraan beginnen is weinig zinvol omdat grotere keys echt niet perse achteraan staan. Stoppen zodra je een key hebt is zeker fout. Een geordende hashfunctie, die grote keys een hoge h geeft, doorkruist het hele idee van hashen. B = Je Berekent gewoon de grootste in een integer lijst/array, zonder je te realiseren dat hier elke A[i] zelf al een lijst is, 0pt. C = Je moet Code geven! E = Expliciet bijhouden of je al een waarde gezien hebt is een slecht idee, geeft namelijk bij elke key een extra test. F = De dictionary als geheel heeft ook een foreach, beetje flauwe oplossing wel, dit. Zonder uitleg hoe dat werkt max 1pt. G = Als je Geordende lijsten veronderstelt (grootste vooraan) kan het sneller. Bekijk per lijst alleen het eerste element, kost totaal alleen O(m) tijd. Hiervoor moet je wel bij de hele indeling van de datastructuur er al rekening mee houden wat je wilt. L = Lineair in wat? Meestal zijn n en m wel ongeveer vergelijkbaar, zodat je ook O(n) of O(m) kunt schrijven. Maar O(n) zonder deze uitleg geeft toch geen volledig punt. M = Alle lijst-maxima opslaan in een lijst kost (onacceptabel) veel geheugen. N = Als je r met Nul laat beginnen ipv. Int.MinValue, werkt het niet goed voor negatieve getallen. S = Sorteren is een (te) omslachtige manier om het maximum uit een lijst te vinden. U = De Unhash-functie gebruiken kan niet, omdat zo n functie niet bestaat. Z = Max kan in elke lijst Zitten vanwege de % : dit is niet alleen vanwege de modulus, ook de HashCode (hashfunctie) zelf is al niet ordenings-respecterend.