TENTAMEN

Institutionen för Kommunikation och Information
Kurs:
Delkurs:
Kurskod:
Datum:
Ansvarig lärare:
Berörda lärare
Hjälpmedel/
Bilagor:
Övrigt:
Anvisningar
TENTAMEN
Algoritmer och Datastrukturer
DA114G
2010-01-14
Gunnar Mathiason
Högskolepoäng: 7.5 hp
Ta nytt blad för varje lärare (endast för lärare på IVN)
Ta nytt blad för varje ny fråga
Skriv endast på en sida av papper.
Använd inte röd penna.
Skriv namn och personnummer på samtliga inlämnade blad.
Numrera lösbladen löpande.
Markera med kryss på omslaget vilka uppgifter som är lösta.
Skrivtid: 14:30-19:30
Poänggränser Examination sker utfrån kursmålen. En fråga på varje mål kan ge max 10 p.
För godkänt krävs minst 5 p på alla frågor utom en.
För betyg 4 krävs minst 7 p på alla frågor utom en.
För betyg 5 krävs minst 9 p på alla frågor utom en.
Skrivningsresultat bör offentliggöras inom 18 arbetsdagar
Lycka till!
Sidan 0(6)

Tentamen har 4+2 sidor (inklusive en bilaga).
Alla svar skall motiveras väl, d.v.s. det räcker inte med ett faktasvar. Enbart en faktauppgift
(exempelvis, ett tal eller en benämning) är aldrig tillräckligt. Om en fråga verkar oklar, ange din
egen tolkning först i ditt svar på frågan.
Denna tentamen examinerar utifrån kursmålen, där det avgivna svaret värderas mot varje
kursmål. Svaret för varje kursmål poängbedöms 1-10.
• Kursmål 1: Användning av komplexitetsteori.
• Kursmål 2: Användning av grundläggande datastrukturer.
• Kursmål 3: Användning sorteringsalgoritmer.
• Kursmål 4: Användning av grafer och tillämpliga algoritmer.
• Kursmål 5: Användning av generella principer för algoritmdesign: giriga algoritmer,
söndra och härska, dynamisk programmering, samt backtracking.
• (Kursmål 6: Examineras i laborationsuppgiften, inte i denna tentamen).
Frågor:
1. [Kursmål 1]
Algoritmanalys.
a. Komplexitetsbegrepp
i. Beskriv vad O() ‐begreppet (Big‐Oh) innebär i algoritmanalys. Varför är detta
begrepp så viktigt vid konstruktion av en algoritm?
ii. Hur skiljer sig O() från Ω() (dvs. Big‐Omega) och Θ() (dvs. Big‐Theta)?
iii. Som komplexitetsuttryck används ofta en grov uppskattning. Vilka två grova
antaganden gör man ofta för att få fram ett enklare komplexitetsuttryck?
Varför gör man detta? Tips: Man är ute efter att veta hur komplexiteten
växer med problemets storlek.
1

. Grenanders problem (“Maximum Sub Sequence Problem”). Se följande
implementation av algoritmen, vilken har logaritmisk tidskomplexitet.
2. [Kursmål 2]
int grenander4(int a[], int l, int h) {
if (l > h) return 0;
if (l == h) return max(0, a[l]);
int m = (l + h) / 2;
int sum = 0;
int maxLeft = 0;
for (int i = m; i >= l; i‐‐) {
sum += a[i];
maxLeft = max(maxLeft, sum);
}
sum = 0;
int maxRight = 0;
for (int i = m + 1; i

. Köer
i. Jämför två olika implementationer av köer, dels som array och dels som
länkad lista. Motivera skillnaden i deras komplexitet för de följande
operationerna:
insert(a), (insättning av element a i kö:n)
remove(a), (hämta ut och ta bort element a ur kö:n)
n=lookupElementIndex(a), (returnera element a på position n)
där a är ett element och n är en position i kö:n.
c. Binära sökträd
i. Beskriv ett allvarligt problem med binära träd och vad konsekvenserna blir
när det uppträder.
ii. Beskriv angreppssättet hur man ofta löser detta. Ge exempel på två kända
algoritmer som försöker lösa detta problem och principen för hur detta görs.
d. Sentinels
i. Vad är meningen med en sentinel?
ii. Vad är en sentinel‐nod och när används detta?
3. [Kursmål 3]
Sorteringsalgoritmers komplexitet.
a. Jämför en sorteringsalgoritm med tidskomplexiteten O(n log n) med en
sorteringsalgoritm med tidskomplexiteten O(n 2 ).
Detta är en essäfråga, besvara frågan utförligt och noggrant.
i. Basera analysen på komplexiteten för de olika operationerna som ingår.
ii. Vilken del bidrar med största beräkningskomplexiteten?
iii. Jämför hur enkelt/svårt de båda sorteringsalgoritmerna realiseras.
Hur påverkas beräkningstiden av indatas beskaffenhet?
Vad är värsta och bästa fallet?
iv. Stabilitet, behålls en underliggande sorteringsordning?
4. [Kursmål 4]
Traversering av grafer
a. Ge en algoritm, i pseudokod, som med hjälp av en kö och ett minne för besökta
noder traverserar alla noderna i en graf enligt en bredden‐först‐ordning. Varje nod
besöks alltså endast en gång.
3

5. [Kursmål 5]
Giriga algoritmer
a. I ett kassasystem vill vi kunna ge tillbaka växel till en kund. Mynten vi har att tillgå
är på 1, 5, 10 respektive 25 enheter. Problemet är nu att för ett godtyckligt
växelbelopp välja ett antal mynt av de olika valörerna så att: 1) myntens
sammanlagda värde exakt uppgår till det eftersökta växelbeloppet; 2) ett så litet
antal mynt som möjligt används. Vi antar att det finns tillräckligt många mynt av
varje valör.
i. Använd pseudokod för att ge en utförlig beskrivning av en girig algoritm
som löser ovanstående problem.
ii. Antag att vi förutom valörerna ovan också har mynt som är värda 12
enheter. På vilket sätt påverkar det din giriga lösning?
iii. Har vi situationen ”ii” är det bättre att försöka lösa växlingsproblemet
m.h.a. söndra och härska (divide‐and‐conquer). Använd pseudokod för att
ge en utförlig beskrivning av en algoritm som löser växlingsproblemet med
denna teknik.
Ledning: Tänk rekursivt! Antingen så kan vi växla hela beloppet med
endast ett mynt eller så kan vi (på något lämpligt sätt) dela upp
växelbeloppet, växla delbeloppen med minimalt antal mynt rekursivt och
sedan konstruera en fullständig lösning från dellösningarna.
b. En naiv lösning för problemet med 12‐enhetersmyntet (”iii”) lider av ett problem
som är vanligt hos söndra‐och‐härska algoritmer. Beskriv detta problem. Vilken
generell lösning finns på problemet?
4

BILAGA 1: Att beskriva algoritmer
Ett schema för hur man kan beskriva en algoritm är följande:
1. ge en informell algoritm (intutiv beskrivning)
2. ge en abstrakt algoritm (i pseudokod)
3. analysera egenskaper, framförallt tidskomplexitet
4. förklara de datastrukturer som används
5. förfina algoritmen stegvis.
Nedan ges en mer utförlig beskrivning av de olika stegen.
1. Förklara hur algoritmen fungerar
Först måste man förklara varför (i vilken mening/på vilket sätt) algoritmen löser problemet i
fråga. För att göra detta kan man med fördel använda både sig av både text och bild.
Beskrivningen ska vara intuitiv och lättförstålig men samtidigt kortfattad och koncis (med fördel
används en mer matematisk notation på lagom nivå). Ett bra sätt är ofta att göra en "torrsimning"
på ett konkret exempel. Det väsentliga i detta första steg är att algoritmens idé framgår tydligt
och att man får hjälp med att förstå den abstrakta algoritmen i nästa steg.
2. Ge (beskriv) en abstrakt algoritm
Detta är en programspråksliknande beskrivning (i pseudokod) där man kan använda ADT:er för
t.ex. listor, matriser och grafer, samt satser (instruktioner) av typen "för varje nod n i grafen G
gör" och "om x finns i listan L så". Denna beskrivning ska alltså så långt som möjligt vara
programspråksoberoende.
Det väsentliga i detta steg är att algoritmens struktur framgår tydligt, att man får en förståelse
för hur algoritmen skulle kunna implementeras i ett (imperativt) programspråk.
Om man använder resultatet från en känd algoritm, t.ex. binärsökning i en sorterad lista, så räcker
det att man i detta steg bara beskriver hur resultatet ser ut (och nämner vilken algoritm man har
använt för att beräkna det). Anpassar man en känd algoritm för att passa den algoritm man håller
på att beskriva så måste den anpassade algoritmen beskrivas i sin tur (vilket görs efteråt).
Men man får inte vara för abstrakt! Om man t.ex. arbetar med ett binärt träd och vill skriva ut alla
löv i trädet så är inte "traversera trädet" en bra abstraktion. En bra tumregel är att de satser som
man använder i detta steg ska vara så abstrakta som det går samtidigt som det direkt måste framgå
att de är fullt möjliga att implementera. Om detta inte är uppenbart måste man visa hur man har
tänkt sig att implementera dessa satser. Detta gör man i sådana fall efter den abstrakta algoritmen,
inte i den.
3. Analysera algoritmens komplexitet
Här är det nästan alltid tidskomplexiteten som är det mest intressanta. Analysen behöver inte vara
formell utan det handlar snarare om att ge en uppskattning av komplexiteten och om att ge en
övertygande motivering för hur man kom fram till denna. I mer generell mening är syftet med
detta steg att beskriva algoritmens egenskaper.
5

4. Beskriv de olika delarna i den abstrakta algoritmen
Här beskriver man t.ex. hur man implementerar de ADT:er som ingår i den abstrakta algoritmen,
hur "för varje nod n i grafen G gör" utförs och hur eventuella hjälpalgoritmer (både kända och
egenkonstruerade) fungerar. Kända hjälpalgoritmer behöver normalt bara beskrivas enligt
punkterna 1- 2 ovan. Naturligtvis behöver man inte beskriva hur en länkad lista implementeras
eller hur linjär sökning i en lista går till (såvida de inte har modifierats förstås).
Syftet med detta steg är att ge ytterligare förståelse för att den abstrakta algoritmen verkligen kan
implementeras, att ge grundläggande idéer till hur den abstrakta algoritmen kan implementeras,
att ge ytterligare detaljer till en eventuell utförligare komplexitetsanalys samt, inte minst, att
förbereda inför nästa steg.
5. Implementera algoritmen
Här beskrivs hur algoritmen implementeras i valt programspråk. Detta sker ofta genom stegvisa
förfiningar av algoritmen, där man för varje steg implementerar fler och fler detaljer. Eventuellt
ska alla detaljer implementeras (ska algoritmen kunna köras på en dator är ju detta en
förutsättning). Observera att implementationen av en algoritm kan skilja sig markant från den
abstrakta algoritmen. Ett komplett körbart program är inte målet här, det räcker med att
implementera den del av programmet som utgörs av själva algoritmen.
6