Opgaven Binair Zoeken en Invarianten Datastructuren, 4 mei 2016, Werkgroep.

Transcriptie

1 Opgaven Binair Zoeken en Invarianten Datastructuren, 4 mei 2016, Werkgroep. Gebruik deze opgaven, naast die uit het boek, om de stof te oefenen op het werkcollege. Cijfer: Op een toets krijg je meestal zes tot acht opgaven. 1. Verwijder uit ongesorteerd array: Uit een ongesorteerde array A met n elementen wil je het element A[i] verwijderen. Hoe kun je dit zo snel mogelijk doen? (Hint: het kan in constante tijd.) Oplossing: Omdat de volgorde van de elementen mag veranderen, kun je A[i] overschrijven met het laatste element, en die positie wissen: A[i]=A[n--]; A[n]=0;. Dit werkt ook als i de laatste (gebruikte) positie was. Beoordeling/Toelichting: Je kunt alle elementen na i verschuiven, maar dan gebruik je lineaire tijd. 2. Binair Zoeken: Midpoint: Bert en Ernie praten over Binair Zoeken, met name de vraag of het nodig is om voor het te bekijken element m, exact midden tussen i en j te gaan zitten. Bert zegt dat het algoritme ook werkt als je een andere m tussen i en j kiest. Ernie vindt dat je altijd de codevoorbeelden van Gerard zo exact mogelijk moet overnemen (want daar heeft hij goede ervaringen mee). Kun je de theorie van Invariant en Variant gebruiken om Bert en Ernie verder te helpen? Oplossing: Volgens de theorie van de Invariant mag ik de Body van de loop best veranderen, als de nieuwe body maar de invaiant respecteert. Ook met een andere keuze van m (alleen zinvol in het bereik [i..j]) wordt de invariant gerespecteerd, en het veranderde programma is dus nog steeds partieel correct. Of het ook termineert, en hoe snel het is, ligt subtieler. Als m gekozen wordt strikt tussen i en j, zijn zowel m i als j m strikt kleiner dan j i, zodat afname van de Variant j i zeker is. Wanneer de range te groot wordt gekozen en ook de keuze m = i of m = j mogelijk is, kan de Variant blijven steken, oneindige lus! Voor zowel correctheid als terminatie blijkt de midpoint-formule dus vrij onbelangrijk! Het mooie van de keuze van de formule m = (i + j)/2 is, dat als j i 2 t, dan is zowel m i 2 t 1 als j m 2 t 1. Daardoor zorgt de halveringsformule voor een gegarandeerd logaritmische tijd. Maar andere keuzes kunnen ook snel zijn, zoek bv. maar eens Interpolation Search op Wikipedia. Beoordeling/Toelichting: R = Een Random keuze is niet hetzelfde als het invullen van willekeurig welke formule.

2 3. Midpoint: Bij Binair Zoeken kun je het Midpoint m kiezen als m = (i+j)/2. (a) Kan het ook met m = (int)math.floor((i+j)/2) en wat is het voordeel of nadeel hiervan? (b) Kan het ook met m = i+1 en wat is het voordeel of nadeel hiervan? (c) Kan het ook met m = i + (j-i)/2 en wat is het voordeel of nadeel hiervan? (d) Kan het ook met m = (i+j)>>1 en wat is het voordeel of nadeel hiervan? Oplossing: (a) De Math.Floor verzorgt een geheeltallige afronding naar beneden maar de normale integer deling in Java of C# doet dat ook al. De extra toevoegingen zijn dus volkomen overbodig. (b) De berekende waarde van m ligt strikt tussen i en j (het wordt namelijk alleen uitgerekend als j > i + 1) en daarmee levert het een correcte zoekmethode op. Probleem ervan is natuurlijk dat de Variant j i erg langzaam daalt wanneer het i is die door m wordt vervangen. Je zoekt in feite lineair. (c) De uitkomst van deze formule is gelijk aan de korte formule (in alle gevallen van even/oneven i, j of verschil). De simpele formule berekent i + j, wat overflow kan geven als i en j dicht bij de maximale waarde van een int liggen. Ik denk niet dat veel studenten dit probleem in 2016 al hebben meegemaakt, want het treedt pas op bij arrays van 1G lang of meer, maar in 2017 zou het kunnen. (d) Een shift naar rechts is hetzelfde als een deling door 2 op de meeste computers/platforms. Of dat ook echt altijd zo gegarandeerd is weet ik niet. Beoordeling/Toelichting: 4. Sommatie: Je kunt n getallen in A zo optellen: s=0; i=0; while(i<n) { s += A[i]; i += 1; Geef invariant en variant van deze lus. Oplossing: Invariant: s is de som van de eerste i getallen, s = i 1 k=0 A[k]. Variant: n i wordt in elke slag van de lus kleiner. Beoordeling/Toelichting: Je kunt je code ook beginnen met s=a[0]; i=1; met dezelfde Variant en Invariant. Maar dan moet je het geval n = 0 als uitzondering behandelen.

3 5. Kriebels op de Krim: In Simferopol is een straat met n huizen (aan één kant, 0 t/m n 1) waar op nr 0 een Rus woont en op nr n 1 een Oekraiener; ertussenin kunnen allerlei nationaliteiten wonen. Vind na het vragen van hoogstens lg n nationaliteiten twee buren (personen met opeenvolgende huisnummers) van verschillende nationaliteit. Geef een variant en invariant van je algoritme. Oplossing: Dat er Alien Neighbors zijn in een deel i..j van de straat volgt uit land(i) land(j). Dit is gegeven voor (i, j) = (0, n 1) en geeft direct het antwoord als j = i + 1. Je kunt dus dit algoritme maken met invariant land(i) land(j): i = 0; j= n-1 { m = (i+j)/2 if (land(m)!= land(i)) j=m else i=m return i Het verschil j i halveert per stap, dit is je variant, dit doe je dus hoogstens lg(n 1) keer voordat het verschil 1 is. Per ronde vraag je maar 1 nationaliteit op, nl. land(m) omdat je land(i) al weet. Beoordeling/Toelichting: Max 3pt. Voor een goed geformuleerde invariant en variant 1pt; voor een kort en goed algoritme 1pt en als dit ook aansluit bij inv/var nog een punt. E = Een early Stopping variant (die steeds kijkt of m en m + 1 verschillen van nationaliteit en eventueel vanuit de loop direct termineert) kan, maar is meestal niet zinvol. L = Je zoekt Lineair, dus WorstCase Θ(n) personen bekijken. Max 1/2 pt voor het algoritme. M = Midpoint m = i + (j-i)/2 is nodeloos ingewikkeld; geen aftrek. G = Werkt alleen als iedereen van de Genoemde nationaliteiten is, min 1/2. T = Je vraagt Twee nationaliteiten per ronde, dus ongeveer 2 lg n, dit kost 1/2 punt. 6. Machtsverheffen: Om, gegeven x en (int) a, de waarde M = x a te berekenen gebruiken we een variabele R en de invariant inv: M = R x a. (a) Geef een bijpassende initialisatie en een loop-conditie die na afloop de conclusie M = R rechtvaardigt. (Je code kan de variabelen R, x en a wijzigen, maar de gewenste uitkomst M is onbekend en ligt al vantevoren vast.) (b) Geef een Body die inv respecteert en een variant reduceert. Het kan in lg a slagen! Oplossing: (a) Het algoritme wijzigt alleen R, x en a, de contante M blijft ongewijzigd (en is de gewenste uitvoerwaarde). Je introduceert inv met de toekenning R = 1 en de conclusie volgt als a == 0 dus de conditie is (a>0). (b) Kies als variant: a. Doel van de body is dan a te verlagen onder behoud van inv. De code { a--; R *= x; kan altijd maar verlaagt a met maar 1. Als a even is gebruik je { a /= 2; x *= x;. Doe in de body in ieder geval een keer het tweede. Dan halveert a iedere ronde en weet je zeker dat je een logaritmische tijd haalt. Beoordeling/Toelichting: Te halen 3pt, 1 voor (a) en 2 voor (b)

4 7. Invariant: Pizza: Een berg van k pizza s van omvang p 0 t/m p k 1 wordt verdeeld onder n programmeurs. Elk krijgt (i) een stuk uit één pizza (ii) van integer grootte, (iii) ieders stuk is even groot en (iv) ze hebben honger dus ze willen zo veel mogelijk eten. Voorbeeld: Als n = 3 en er zijn twee pizzas van omvang 7 en 8, is de uitkomst 4. Geef een algoritme dat de maximaal mogelijke portie-omvang berekent met binair zoeken. Geef een variant en invariant van je algoritme. Is de rekentijd polynomiaal? Oplossing: Geef mog(i) de betekenis: omvang i is mogelijk. Je zoekt een i met mog(i) mog(i+1). In ieder geval is 0 mogelijk en de maximale pizza plus 1 niet. Of m mogelijk is kun je testen door op te tellen hoeveel stukken je van grootte m kunt snijden uit alle pizza s. Je kunt dus dit algoritme maken met invariant mog(i) mog(j): i = 0; j = p.max + 1; { m = (i+j)/2; v = 0; for (w=1; w<k; w++) v+= p[w]/m; if (v < n) j=m else i=m return i Het verschil j i halveert per stap, dit is je variant. Daaruit volgt een aantal ronden van lg(max(p)) en omdat het optellen van de stukken k tijd kost, is de totale tijd O(k lg(max(p))). Deze tijd is polynomiaal omdat lg(max(p)) overeenkomt met het aantal bits waarmee de getallen worden opgeschreven. Beoordeling/Toelichting: Voor algoritme 1pt en voor (in)variant en rekentijd 2pt (en voor beide samen dan 3pt). I = Initialisatie met j = p.max is fout omdat deze waarde soms kan. Zelfs j = p.sum is fout omdat die waarde kan als portie, nl. wanneer k = n = 1. L = Zoekt Lineair ipv binair, dit kost veel te veel tijd.

5 8. Het Gat: Gegeven is een gesorteerde array A van integers, waarbij A[n 1] A[0] n. Geef de invariant voor een algoritme dat een getal tussen A[0] en A[n 1] vindt, dat niet voorkomt in A. Geef ook het algoritme (het moet logaritmische tijd gebruiken). Oplossing: Dat er een getal niet voorkomt in segment [i..j] volgt uit A[j] A[i] > j i. Dit is gegeven voor i = 0 en j = n 1. Als A[i + 1] A[i] > 1, ontbreekt A[i] + 1. Je kunt dus dit algoritme maken met invariant A[j] A[i] > j i: i = 0; j= n-1 { m = (i+j)/2 if (A[m]-A[i] > m-i) j=m else i=m return A[i]+1 Beoordeling/Toelichting: Voor een goed geformuleerde invariant 2pt; voor een kort en goed algoritme 1pt (en voor beide samen dan 3pt). Centraal punt in deze vraag is, dat je een logisch argument (waaruit volgt het bestaan van een gat) kunt operationaliseren naar een heldere invariant, en van daar uit code kunt genereren. A = Je invariant is wel OK, maar omzetten naar een Algoritme lukt niet. B = Zegt: variant van Binary search dus logaritmisch; pas hier mee op, want ik kan code schrijven die nog veel meer op BS lijkt maar toch niet logaritmisch is. Gelukkig werd het beredeneren van de tijdgrens niet gevraagd. C = Geen invariant, maar wel goede (inzichtelijke, correcte, compacte, logaritmische) Code; toch die 1pt. E = Je kunt niet binair zoeken met Eén variabele. G = Levert een index op; is fout, bv. wanneer alle getallen groter dan n zijn. I = Je vergelijkt tussen een Index en een waarde (als in if (A[m] > m)); dit gaat bv. fout wanneer alle waarden groter zijn dan n. Dan is het altijd true, maar je komt niet altijd goed uit. M = Midpointformule simpeler dan m = (i+j)/2 bestaat niet! Waarom toch m = i + (j-i)/2 zovaak voorkomt is me een raadsel. Het handigst is, deze midpointformule aan het begin van de body te zetten; onhandig is, een midpointformule te zetten op elke plek waar je i of j verandert. R = Je levert A[i+i] op ipv A[i]+1, die waarde komt juist wel voor! S = Dat is geen invariant, maar een Stelling. T = Waarde Teruggeven ontbreekt (of verkeerde waarde). V = Je moet stoppen bij Verschil 1, dus niet bij 0, als in while (j > i). Bij verschil 1 wordt je midpoint gekozen als de ondergrens, mogelijk verandert je ondergrens niet en kom je in een infinite loop. Z = Absoluut Zoeken, je vergelijkt A[m] met A[0]+m. Dit kan een correct algoritme opleveren (maar niet als je op gelijkheid test). Uiteraard is wel een andere invariant nodig, nl A[i] A[0]+i A[j] > A[0] + j.

6 9. Het Duplicaat: Gegeven is een gesorteerde array A van integers, waarbij A[n 1] A[0] < n 1. Geef een algoritme dat een getal tussen A[0] en A[n 1] vindt, dat meervoudig voorkomt in A. Geef ook de invariant van je algoritme. Oplossing: Dat er een getal dubbel voorkomt in segment [i..j] volgt uit A[j] A[i] < j i. Dit is gegeven voor i = 0 en j = n 1. Als A[i + 1] A[i] < 1, is A[i] = A[i + 1], dus dubbel. Je kunt dus dit algoritme maken met invariant A[j] A[i] < j i: i = 0; j= n-1 { m = (i+j)/2 if (A[m]-A[i] < m-i) j=m else i=m return A[i] Beoordeling/Toelichting: Voor een goed geformuleerde invariant 1pt; voor een kort en goed algoritme 1pt (en voor beide samen dan 2pt). Centraal punt in deze vraag is, dat je een logisch argument (waaruit volgt het bestaan van een duplicaat) kunt operationaliseren naar een heldere invariant, en van daar uit code kunt genereren. A = Je invariant is wel OK, maar omzetten naar een Algoritme lukt niet. E = Je kunt niet binair zoeken met Eén variabele. I = Je vergelijkt tussen een Index en een waarde (als in if (A[m] > m)); dit is nooit goed, wat je kunt inzien door een voorbeeld waarin alle waarden groter zijn dan n. Dan is het altijd true, maar je komt niet altijd goed uit. L = Lineaire tijd; hoogstens 1pt totaal. M = Midpointformule simpeler dan m = (i+j)/2 bestaat niet! Waarom toch m = i + (j-i)/2 zovaak voorkomt is me een raadsel. Het handigst is, deze midpointformule aan het begin van de body te zetten; onhandig is, een midpointformule te zetten op elke plek waar je i of j verandert. S = Succestest rond m (if (A[m] == A[m+1])) is overbodig. T = Termineert niet omdat je doorgaat tot j-i == 0; Je moet stoppen bij 1. Bij verschil 1 wordt je midpoint gekozen als de ondergrens, mogelijk verandert je ondergrens niet en kom je in een infinite loop. 10. Interpolation Search: Volgens Wikipedia heeft Interpolation Search een verwachte complexiteit van O(lg lg n) stappen. Kun je dit bewijzen of experimenteel bevestigen? Oplossing: Beoordeling/Toelichting: Dit is een onderzoeksopdrachtje waarvoor geen kort zinvol antwoord bestaat. Wel heel leuk om te doen (correct te krijgen!!) en er een beetje mee te experimenteren. Boeiend om te zien hoe je programma met 5 of 6 vergelijkingen een waarde vindt in een catalogus van miljoenen getallen.