Algoritmen, Datastructuren en Complexiteit (214020/5)

Transcriptie

1 Universiteit Twente Semester 2006/1 Afdeling Informatica 2 e huiswerkserie 10 januari 2007 Uitwerking Algoritmen, Datastructuren en Complexiteit (214020/5) Er zijn 4 opgaven. Er zijn 90 punten te behalen. Het cijfer voor deze serie is (het aantal behaalde punten gedeeld door 10) plus 1. Veel succes! Opgave 1 We beschouwen vier voorbeelden van hashing met open adressering. Daarvoor introduceren we de volgende functies h p (k) = k mod p h (k) = 2k mod 101 h (k) = 1+k mod 31 In alle vier gevallen zijn we geïnteresseerd in het plaatsen van de volgende rij van 9 keys in de gebruikte hashtabel, in deze volgorde: 10807, 3624, 18009, 18020, 3649, 39639, 3628, 25203, pt 1. De hashtabel heeft 61 slots en de hashfunctie (quadratic probing) is: h(k,i) = (h 61 (k) + 3i 2 + i) mod 61 Op welke indices in de tabel komen de elementen van de gegeven rij terecht (aannemende dat de tabel bij aanvang leeg is)? 2. De hashtabel heeft 59 slots en de hashfunctie (quadratic probing) is: h(k,i) = (h 59 (k) + 3i 2 + i) mod 59 Op welke indices in de tabel komen de elementen van de gegeven rij terecht (aannemende dat de tabel bij aanvang leeg is)? 3. De hashtabel heeft 59 slots en de hashfunctie (double hashing) is: h(k,i) = (h 59 (k) + i h (k)) mod 59 Op welke indices in de tabel komen de elementen van de gegeven rij terecht (aannemende dat de tabel bij aanvang leeg is)? 4. De hashtabel heeft 61 slots en de hashfunctie (double hashing) is: h(k,i) = (h 61 (k) + i h (k)) mod 61 Op welke indices in de tabel komen de elementen van de gegeven rij terecht (aannemende dat de tabel bij aanvang leeg is)? 1

2 5. Sommige van de vier hashfuncties hierboven zijn theoretisch niet adequaat. Welke zijn dat, en wat is hun probleem? Uitwerking van opgave Voor onderdelen 1 t/m 4 is een Excel bestand bijgevoegd, met tabellen waarin de oplossingen van de vragen te vinden zijn. 5 Het enige volledig correcte antwoord op onderdeel 5 is het volgende: De hashfuncties uit de onderdelen 1, 2 en 3 zijn niet correct. Alleen de laatste hashfunctie voldoet aan alle eisen. Het probleem in de drie foute gevallen is, dat de probing niet of niet altijd een permutatie van alle indices uit de tabel oplevert. Voor onderdeel 3 is dat vrij duidelijk. Wanneer 2k 0 mod 101, dan is h(k,i) = h 59 (k) voor alle i. Als voorafgaand aan al 600 op index 10 in de tabel geplaatst zou zijn (bij wijze van voorbeeld), dan was er voor geen plaats gevonden. Voor de onderdelen 1 en 2 is dat erg moeilijk in te zien. Wie hier een correcte opmerking over maakt, krijgt bonuspunten, wie dit niet heeft gezien, wordt daarvoor niet gestraft. Voor wie het precies wil weten (geen tentamenstof), hierbij speelt het volgende. Quadratric probing van de vorm 3i 2 +i mod p is alleen goed, als voor verschillende probes i en j geldt 3i 2 +i mod p 3j 2 +j mod p. Dat is hier niet het geval. Als i+j 20 mod 61, dan is 3i 2 +i 3j 2 +j mod 61 Als i+j 39 mod 59, dan is 3i 2 +i 3j 2 +j mod 59 Hieruit volgt dat de probing sequence bij onderdelen 1 en 2 slechts de helft van de indices in de tabel onderzoekt, en dat is niet volgens de regels. Opgave 2 In deze opgave beschouwen we een algoritme op een binaire boom. U moet uitgaan van gegeven klassen bintree, node en elt met de volgende features : node root voor bintree-objecten, node left, right, parent en elt value voor node-objecten. 20 pt 1. Schrijf een algoritme dat van een binaire boom de padlengte bepaalt. De padlengte pl(t) van een boom T is gedefinieerd door de volgende formule: pl(t) = v T d(v,r T) waarbij v T staat voor de knopen v van de boom T, R T voor de wortel van boom T en d(v,w) voor het aantal kanten in het pad van v naar w. 2

3 2. Beschrijf de (asymptotische) tijdscomplexiteit van uw algoritme. 3. Wat is de relatie tussen de padlengte van een binaire zoekboom (niet noodzakelijk gebalanceerd) en de tijdscomplexiteit van een succesvolle zoekactie in die zoekboom? Uitwerking van opgave 2 1. De meest eenvoudige uitwerking (wat mij betreft) loopt via een generalisatie van de opgave. Een dergelijke generalisatie is bij recursie heel vaak een probaat middel om tot een gemakkelijker oplossing te komen. De gegeneraliseerde padlengte voor een subboom van level k is gedefineerd door: gpl(k,v) = w T v (k + d(w,v)), waarbij w T v staat voor de knopen w van de subboom van T met als wortel de knoop v T. Het is duidelijk dat gpl en pl als volgt samenhangen: pl(t) = gpl(0,r T ). gpl kan worden gedefinieerd door de volgende recursieve clausules: gpl(k, null) = 0 //een som over een lege verzameling is per definitie 0 gpl(k,v) = k+gpl(k + 1,v.left)+gpl(k + 1,v.right) Deze recursieve clausules laten zich onmiddellijk in pseudocode vertalen. 2. Bij het beoordelen van dit onderdeel worden alle opmerkingen gewaardeerd die iets corrects zeggen over de complexiteit van de bij onderdeel 1 gegeven oplossing, ook als die oplossing zelf niet of maar gedeeltelijk correct is. De (worst-, best- en average-case) complexiteit van het algoritme is lineair in het aantal knopen van de boom. Het argument uit de losse pols hiervoor is: iedere knoop (inclusief de externe knopen, d.w.z. de null-kinderen van de bladeren) van de boom is precies eenmaal parameter de recursieve methode, en buiten deze recursieve aanroepen vinden geen acties plaats. Bij iedere aanroep van de methode op een inwendige knoop vinden een null-test en 2 optellingen plaats, bij een externe knoop alleen een nulltest. Tezamen leidt dat tot de conclusie: 2N + 1 null-tests, en 2N optellingen, waarbij N het aantal inwendige knopen is (dan is het aantal externe knopen N + 1). Een formeler argument bereikt deze conclusies met inductie over de structuur van de boom. 3. Het gemiddeld aantal vergelijkingen dat nodig is om een sleutel K in een binaire zoekboom te vinden, onder de aanname dat in de boom N sleutels zijn opgeslagen, v T d(v,r T). is 1 N 3

4 De gevraagde relatie is dus: De gemiddelde tijdscomplexiteit van een succesvolle zoekactie naar een sleutel K in een binaire zoekboom T, onder de aanname dat alle sleutels met dezelfde kans gezocht worden, is pl(t)/n, waarbij N het totaal aantal in T opgeslagen sleutels is. Opgave 3 In deze opgave wordt gevraagd een algoritme te ontwerpen dat werkt op een ongerichte graph. De graph is gegeven door een (symmetrische) adjacency matrix. We noemen een knoop v in een ongerichte graph G een centrum in G als hij de volgende eigenschappen heeft: 25 pt v heeft tenminste twee verschillende buren, Voor ieder tweetal verschillende buren w en w van v geldt dat elk pad van w naar w via v loopt. 1. Schrijf een algoritme dat vaststelt wat de centra van een gegeven graph G zijn. 2. Beschrijf de (asymptotische) complexiteit van uw algoritme, zowel in tijd als in ruimte. Uitwerking van opgave 3 1. De eisen die een centrum v definiëren laten zich ook formuleren als: v heeft tenminste twee verschillende buren, Er is geen cykel door v, behalve mogelijk een zelf-cykel (een kant vv). Een oplossing van het probleem is dus: Kleur alle knopen van de graph, maak ze rood als ze op een cykel liggen en groen als dat niet zo is. De centra zijn de groen gekleurde knopen met 2 of meer buren. Het kleuralgoritme is (gebaseerd op) een depth-first-search. Vier zaken verdienen daarbij speciale aandacht: Hoeveel searches hebben we nodig om alle centra te vinden? We kunnen natuurlijk vanuit elke knoop een DFS starten, en als die niet tot terugkeer in de startknoop leidt, de knoop groen kleuren, anders rood. Dat is correct, maar complex (n maal de complexiteit van een DFS, waarbij n het aantal knopen is). De DFS met startknoop v is tegelijkertijd ook een DFS voor alle knopen die we onderweg tegenkomen, en we zouden al deze knopen dus in een doorloop willen kleuren. Dat vergt wel extra administratie. Hoe gaan we om met zelf-cykels? Die negeren we. 4

5 Hoe gaan we om met een DFS op een ongerichte graph (standaard is een gerichte graph)? Iedere keer als we in een DFS langs een kant van knoop v naar knoop w gaan, zullen we de kant wv moeten verwijderen. We kunnen nooit bij voorbaat besluiten alle kanten een richting te geven, want dat doet geen recht aan het ongerichte karakter, daarmee kunnen we cykels opheffen die er wel zijn. Hoe gaan we om met de adjacency matrix (standaard is het array van adjacency lists)? We zouden kunnen besluiten om te beginnen met een conversie van de matrix naar de adjacency lists. Dat maakt het algoritme niet gemakkelijker, het verwijderen van omgekeerde kanten is dan een stuk lastiger. Complexiteitswinst in tijd is niet te halen, de conversie zelf is van orde n 2, en dat is uiteindelijk ook de complexiteit van het gehele algoritme gebaseerd op de matrix. We presenteren hier een algoritme dat behoorlijk uitgeoptimaliseerd is. Maar dat is niet geëist. Ook minder optimale algoritmen kunnen gewoon goed zijn. Als de complexiteitsanalyse in onderdeel 3 dan ook maar deugt. (Dit is een algemeen principe voor de beoordeling van ADC. Op een correcte oplossing met een correcte analyse worden in principe geen punten in mindering gebracht, ook al zijn er oplossingen mogelijk met een betere tijds- of ruimtecomplexiteit. Met een slimmere oplossing zijn soms wel bonuspunten te verdienen. Wat wel altijd meetelt: is de oplossing inzichtelijk en goed gepresenteerd, en zijn de oplossing en de analyse met elkaar in overeenstemming.) Het algoritme is in essentie een DFS. Deze wordt (uiteraard) voorafgegaan door de relevante initialisaties. De DFS wordt bovendien herhaald ingezet (voor het geval de graph niet samenhangend is): in een sweep langs alle knopen worden alle kandidaat roots voor de DFS bezocht en afgewerkt. Het algoritme maakt gebruik van twee hulpmiddelen. Het gebruikelijke hulpmiddel voor een DFS is een een array van kleuren color. Dit array dient om vast te leggen welke knopen al eerder zijn bezocht, en welke nog niet. Ook in dit algoritme wordt het daarvoor gebruikt, maar de manier van kleuren is wat afwijkend (zie verderop). Naast het kleurenarray is er een stack van knopen s, waarop tijdens de DFS alle knopen terechtkomen die op het pad van de huidige knoop naar de root (het startpunt) van de DFS liggen, inclusief dat startpunt en de huidge knoop zelf. Knopen blijven niet noodzakelijk op die stack liggen zolang zij nog in behandeling zijn. Dat is wat vreemd, en vraagt de nodige handigheid. Knopen verdwijnen van de stack zodra is gedetecteerd dat zij onderdeel van een cykel zijn. Om het beheer van de stack en de efficiënte cykeldetectie mogelijk te maken, hanteren we een bijzondere manier van kleuren van knopen die we bezocht hebben. 5

6 In de kleur brengen we niet alleen tot uitdrukking wat de status van een knoop is, we leggen er ook in vast hoe ver de knoop af ligt van het startpunt van de DFS. (Dit is een keuze, en niet een noodzaak, we zouden kleur an afstandsinformatie ook gescheiden kunnen houden). De DFS krijgt een integer parameter depth mee, die initieel 1 is (voor het startpunt) en bij iedere diepere recursieve aanroep wordt verhoogd. Een knoop die nog niet bezocht is, heeft kleur 0. Zodra een knoop bereikt wordt krijgt hij de kleur 3 depth. 3-vouden groter dan 0, noemen we dus groen. Zodra ontdekt wordt dat een knoop in een cykel ligt, wordt er 1 van zijn kleur afgetrokken. Kleuren die -1 zijn modulo 3, noemen we rood. Als we een knoop vinden die niet op een cykel ligt (groen), maar maar 1 echte buurman heeft, dan wordt er 2 van zijn kleur afgetrokken. Zijn kleur wordt 1 modulo 3, die kleuren noemen we geel. De methode cyclecolordfs heeft als parameters de adjacencymatrix van de graph (AdjM), de rij color, de startknoop v, de stack s, het aantal bekende buren van v (nbc), en het rangnummer van v op het pad van het startpunt naar v (depth, de telling begint bij 1). De DFS start vanuit de sweep langs alle knopen steeds met een lege stack, een knoop waarvan de kleur 0 is, met een diepte 1 (het rangnummer van de knoop op het wortelpad), en een aantal gedetecteerde buren 0. De iedere recursieve aanroep liggen op de stack alle knopen uit het wortelpad waarvoor geldt dat hun kleur groen is, de nieuwe knoop voor deze aanroep heeft nog de kleur 0, van de nieuwe knoop is al bekend dat hij 1 buur heeft (de knoop van waaruit deze aanroep komt), en de diepte is 1 hoger dan in de omvattende aanroep. Bij het uitvoeren van de acties in cyclecolordfs gebeurt het volgende. v wordt groen gemaakt, en wel zo dat zijn diepte daarin herkenbaar is, en op de stack gelegd. Alle buren van v worden bezocht. Iedere echte buur leidt tot het verhogen van de telling van het aantal buren. Heeft de gevonden buur nog geen kleur, dan wordt de DFS recursief voortgezet. Heeft hij wel een kleur, dan hebben we een kant in de graph ontdekt die terugwijst naar een knoop w op het wortelpad. Er is dus een cykel door v en de onderzochte buurman w. Alle knopen op het wortelpad van v die tussen v en w in liggen (inclusief deze knopen zelf) halen we van de stack, en we veranderen hun kleur in rood. Om te zien of een knoop tussen v en w ligt is het cruciaal dat in de 6

7 kleur het rangnummer op het wortelpad verborgen zit. Dat hebben we met het 3*n schema gerealiseerd. Als we alle potentiële buren van v gezien hebben, besluiten we of v misschien een gele knoop is (te weinig buren om een centrum te zijn). Tenslotte halen we v van de stack, tenzij hij natuurlijk rood is gekleurd, en niet meer op de stack ligt. [ ]int color; foreach vcolor[i] = 0 foreach v if (color[i] == 0) {stack s = new stack ( );colorcycledfs(adjm,color,v,s,0,1)} voidcolorcycledfs(bool [ ][ ]AdjM, int [ ]color, int v, stack s, int nbc, depth) {int nbcount = nbc; color[v] = 3 depth;s.push(v); foreach w if (AdjM [v,w]&&v w) {AdjM [w,v] = false;nbcount++; if (color[v] = 0)colorCycleDFS(Adj,color,v,s,1,depth + 1) else processcyclefound }; if nbcount < 2)color[v] = color[v] 2; if (s.top( ) == v)s.removetop( ) } processcyclefound while (!s.isempty( )&&color[s.top( )] color[w]) {int t = s.pop( );color[t] }; De groene knopen (kleur = 0 mod 3, kleur is niet 0) zijn centra. Door de rode knopen (kleur = -1 modulo 3) loopt een cykel. De gele knopen (kleur = 1 modulo 3) hebben minder dan twee buren. 2. De complexiteitsanalyse moet aansluiten bij het gegeven algoritme, dat is de eerste en belangrijkste eis. Het gaat om de volgende zaken: De consequenties van het werken met een matrix (n 2 entries) i.p.v. adjacency lists (m entries) zijn goed begrepen De inspecties van knopen, veranderingen in de status van knopen, zijn goed geteld. 7

8 De tijdscomplexiteit van het hierboven gegeven algoritme is Θ(n 2 ), n het aantal knopen in de graph. We beargumenteren dit door per knoop te kijken naar de acties die kunnen vorkomen. We inspecteren voor iedere knoop (in de DFS) alle andere knopen (een rij in de adjacency matrix) om te zien wie een buurknoop is, en wat de kleur van die buurknoop is, dat levert n inspecties per knoop We geven iedere knoop tenminste twee en ten hoogste drie maal een kleur (eerst 0, dan groen, en daarna misschien rood of misschien geel) We zetten iedere knoop eenmaal op een stack en halen hem er maximaal ook een keer vanaf. Voor alle n knopen is het aantal acties van ordegrootte n, het gehele algoritme is van orde n 2. Er is bij dit alles geen sprake van worst- of average- of best-case. De ruimtecomplexiteit wordt bepaald door de omvang van de adjacencymatrix n n. De diepte van de recursie is maximaal n, en de extra structuren color en s hebben een omvang evenredig aan n. Opgave 4 We willen weten of het mogelijk is de kanten van een ongerichte graph G met een beperkt aantal (bijvoorbeeld 4) kleuren zo te kleuren dat in geen enkele knoop twee kanten met dezelfde kleur samen komen. Deze vraag naar het kleuren van de kanten van G is eigenlijk hetzelfde als de vraag naar het kleuren van de knopen van een uit G afgeleide graaf G, waarbij dan de eis wordt gesteld dat een kant in G nooit twee knopen met dezelfde kleur mag verbinden. 25 pt 1. Beschrijf nauwkeurig hoe u de bedoelde G uit G zou construeren. 2. Wat is de tijdscomplexiteit van uw transformatie van G naar G? 3. Kunt u het aantal knopen en kanten van G uitdrukken on het aantal knopen en kanten van G? Uitwerking van opgave 4 Er worden geen algoritmen gevraagd, het gaat om een nauwkeurige beschrijving van een aanpak. Ook zonder pseudocode kan deze opgave dus opgelost worden. 1. Het is duidelijk dat de kanten van G de knopen van G moeten zijn. Tussen twee knopen van G is een kant, als de twee oorspronkelijke kanten in G in een knoop samen komen. De vertaling van een knoop in de oorspronkelijke G is dus niet eenduidig. Een knoop v is verntwoordelijk voor een hele verzameling kanten, de 8

9 kanten die samen zorgen dat er een volledige deelgraph (een clique) onststaat op de knopen in G die afstammen van de kanten die samen komen in v (in G). Het algoritme dat de conversie van G naar G uitvoert, uitgaande van de adjacency matrix voor G is het volgende. Als voorbeeld gebruiken we een matrix met 5 knopen en 8 kanten. Het is een vierkant met een punt in het midden. De hoekpunten zijn genummerd 1,2,3,4. Het middelpunt is nummer 5. Het middelpunt is met alle vier hoekpunten verbonden. De bijbehorende adjacency matrix is: (a) Nummer rij voor rij de posities waar een 1 (true) staat in het bovendiagonaal deel van de adjacency matrix van G opeenvolgend met getallen van 1 tot m, en geef steeds de symmetrische (onderdiagonaal) positie het zelfde nummer. We noemen het resultaat de knopenmatrix voor G, de knopen van G zijn {1,...,m}. Merk op dat iedere andere volgorde van nummering even goed is, als op symmetrische posities in de knopenmatrix maar dezelfde knoop staat. In ons voorbeeld: (b) Vul een m m adjacency matrix A G voor G. Doe dat door alle posities in de matrix te initialiseren op 0, en vervolgens rij voor rij door de knopenmatrix te gaan. Iedere keer dat een nieuw knoopnummer v in deze matrix wordt gevonden, wordt rij v van A G aangepast. Op positie (v,j), v j, in deze matrix komt een 1 dan en slechts dan als in de knopenmatrix de knoop j voorkomt in dezelfde rij of dezelfde kolom als knoop v. Dan immers staan v en j voor kanten die in G in een knoop samen komen. Op alle andere posities blijft een 0. In ons voorbeeld zien we dat knoop 5 in de knopenmatrix in dezelfde kolom staat als 3, 7 en 8, en in dezelfde rij als 1 en 4. In de adjacency matrix die we construeren voor G zal op de posities (5,1),(5,3),(5,4),(5,7),(5, 8) dus een 1 staan. De volledige adjacency matrix voor ons voorbeeld is: 9

10 Dit is een graph met 8 knopen. In het midden een vierkant met de knopen 3, 5, 7 en 8 (tegen de klok in) als hoekpunt, ook de diagonalen hierin zijn kanten van de graph. Daarbuiten een groot 45 o gedraaid vierkant, met hoekpunten 1, 2, 4 en 6. Ieder hoekpunt van het grote vierkant boven een zijde van het binnenvierkant. 1 boven (5,3); 2 boven (3,8); 4 boven (7,5) en 6 boven (8,7). Ieder hoekpunt van het buitenvierkant is verbonden met de uiteinden van de zijde van het binnenvierkant waar het boven ligt. 2. De complexiteit van dit algoritme is Θ(n 2 + mn + m 2 ), n het aantal knopen, m het aantal kanten. De essentiële actie is het invullen van de adjacency matrix. Daarvoor zijn m 2 stappen nodig in de intialisatiefase (alle posities de waarde 0 geven), en vervolgens n 2 +mn stappen voor het bepalen van de posities waar een 1 staat. Daarvoor moeten alle posities in een helft van de knopenmatrix worden geïnspecteerd ( 1 2 n2 ), overal waar een knoop voorkomt (m posities) moeten de bijbehorende rij en kolom worden bekeken (2n posities). Het zou uit complexiteitsoverwegingen beter zijn geweest niet de adjacency matrix van G, maar de adjacency lists voor G op te leveren. Dan blijft de complexiteit beperkt tot Θ(n 2 + mn). 3. Dit is een onderdeel dat moeilijk precies te beantwoorden is. De vraag is dan ook erg open gesteld (kunt u...?) In een dergelijke situatie worden alle relevante opmerkingen gewaardeerd. Ook opmerkingen die betrekking hebben op bijzondere gevallen, maar hoe algemener hoe beter. In ieder geval moet worden opgemerkt dat V = E, het aantal knopen van G is het aantal kanten van G. De scherpste opmerking die over het aantal kanten van G gemaakt kan worden is de volgende: E = v V 1 2 E v(e v 1), waarbij E v het aantal buren van v in G is E v = #{w V w v,vw E} Deze formules drukken uit dat ieder knoop in G zorgt voor een volledige subgraph (clique) in G op de kanten die in die knoop samenkomen. Het aantal kanten in een dergelijke volledige graph met k knopen is 1 2k(k 1). 10

11 Inspectie van het beschreven algoritme laat zien dat het aantal kanten altijd beperkt is tot 2mn. Je vindt namelijk het aantal kanten door bij iedere positie in de adjacency matrix die niet 0 is (en dat zijn er m) de bijbehorende rij en kolom te doorlopen (en daarin komen 2n waarden voor). 11