lectures1st half

Algoritmik og datastrukturer I

02105/02326

1torsdag den 4. februar 2010

Velkommen

• Inge Li Gørtz. Adjunkt, forsker i algoritmer og datastrukturer.

• Kontortid: mandag kl. 12.30-13. Bygning 322, kontor 124.

• Læringsmål: Læs dem. Det er dem I bliver checket i til eksamen!

• Medbring papir og blyant.

• Lav øvelserne - kom til grupperegningerne.

• Slides.

• Feedbackpersoner.


Velkommen

• Forelæsninger. kl. 10.15-12.00.

• Grupperegning: kl. 8.15-10.00.

• Afleveringsopgaver: 5 stk. Obligatoriske.

• Samarbejdspolitik omkring afleveringsopgaverne.

• Tilladt at snakke sammen, brainstorme, diskutere.

• Skal skrive individuelt - ikke tilladt at vise besvarelser til hinanden.

• Skriv på besvarelsen hvem I har arbejdet sammen med.


Algoritmer


Hvad er en algoritme?

• En algoritme er en beskrivelse af, skridt for skridt, hvordan noget gøres (beregnes). Alle skridt skal beskrives entydigt og det skal være klart hvordan ethvert skridt udføres.

• Eksempel. Franskbrødsalgoritme:

1. Bland 30 g gær med 1 dl lunkent vand.

2. Bland yderligere 500 g mel og 2 del vand i dejen og ælt i 10 minutter. Lad hæve til dobbelt størrelse.

3. Slå dejen ned, form brødet og lad hæve i 20 min.

4. Bag i ovnen i 40 minutter ved 200 C.

Input: 500g mel, 3 dl vand, 30 g gær, 5 g sukker, 5 g salt.

Output: Et franskbrød.


Algoritme

• Beskrives i klart sprog: præcist, kortfattet, entydigt.

• Dårlige beskrivelser af franskbrødsalgoritmen.

1. Bland gær og lidt vand.2. Bland mel og mere vand, lidt

sukker og salt i dejen. 3. Bland mel i til det har en passende

konsistens.4. Lad brødet hæve.5. Slå dejen ned, form brødet og lad

det hæve igen.6. Bag i ovnen til det er færdigt.Input: mel, vand, gær, sukker og salt i passende mængder.Output: Et franskbrød

1. Åbn køleskabet og tag pakken i øverste venstre hjørne af lågen.

2. Tag den midterste pose i 3. skuffe fra højre.

3. Find decilitermål i øverste skuffe.4. Afmål 2 dl vand fra vandhanen og

5 dl fra den hentede pose. 5. Bland med indholdet af den

hentede pakke fra køleskabet.6. ....

For upræ

cist

For mange detaljer o

g

for lidt in

tution


Algoritmisk problem

• Algoritmisk problem.

• Input.

• Output: beskrevet som funktion af input.

• Eksempel: FindMin

• Input: En følge [a1,....,an] af heltal.

• Output: Det mindste tal m fra inputfølgen [a1,....,an].


Algoritme: Et andet eksempel


• Output: Det mindste tal m fra inputfølgen.

• Følgende algoritme løser problemet:

1. Sæt m = a1.

2. Sæt i = 2.

3. Hvis ai < m så sæt m = ai.

4. Læg 1 til i.

5. Hvis i ≤ n så gå til linie 3.

6. Returnér m.

• Algoritmen er korrekt: Hver gang linie 3 er udført er m lig det mindste af tallene [a1,....,ai]. Når i til sidst sættes til n+1 er m altså det mindste af tallene [a1,....,an].


Algoritme: Pseudokode


• Output: Det mindste tal m fra inputfølgen.

• Følgende algoritme løser problemet:

• = kan erstattes af <- eller :=. Det vigtige er at I gør det samme i hele beskrivelsen. Husk at algoritmer og pseudokode er uafhængige af konkrete programmeringssprog.

Min( a1,....,an]){m = a1for i = 2 to n do if (ai < m)

then m = ai return m}


Mere om algoritmer

• Hvad er forskellen på et program og en algoritme for et givet problem?

Algoritmer er uafhængige af specifikke programmeringssprog. En algoritme beskriver en løsning til et problem. Et program udtrykker en algoritme i et programmeringssprog så computeren kan udføre det.

• Se mere på

http://cimel3.cse.lehigh.edu/movies/Algorithm/facts/Algorithm_sec2.htm


Hvad er algoritmik?

• Læren om diskrete beregningsprocesser.

• Design og analyse af algoritmer og datastrukturer.

• Effektive: hurtige, bruger mindst mulig plads i hukommelsen.

• Analyse:

• Korrekthed: Algoritmen/datastrukturen virker som ønsket.

• Effektivitet:

• Hvor mange skridt bruger algoritmen/datastrukturen på en beregning på et input af en vis størrelse.

• Hvor meget plads bruger algoritmen/datastrukturen i hukommelsen.


Hvorfor algoritmik?

• Internet. Web søgning, rutning af pakker, streaming, distribueret fildeling.

• Biologi. Human genome project, protein foldning.

• Computers. Circuit layout, filsystem, compilere.

• Computer spil. Computergrafik, virtual reality.

• Transport. Skedulering af flypersonale, rutefindere.


Læringsmål og pensum for dagens forelæsning

• Efter denne forelæsning vil du være i stand til at:� Forklare begrebet algoritme.

� Definere stabil matching problemet.� Beskrive Gale-Shapley (GS) algoritmen på en klar måde.� Anvende GS-algoritmen.� Argumentere for at GS-algoritmen terminerer i endelige tid.� Argumentere for at GS-algoritmen finder en korrekt løsning.

• Pensum: KT (Kleinberg og Tardos: Algorithm Design) side 1-22.


Stabil Matching

Et eksempel


Matching af lægestuderende til hospitaler

• Mål: Givet præferencer fra hospitaler og lægestuderende skal der designes en selvjusterende tildelingsproces.

• Tildeling: Alle studerende skal tildeles et hospital og hvert hospital skal tildeles et bestemt antal studerende.

• Mulige problemer: De studerende og hospitalerne laver aftaler bag om ryggen på systemet og nogle studerende ender uden et hospital og omvendt.

Selvjusterende: Algoritmen skal designes så ingen hospitaler og studerende laver private aftaler.


Matching af lægestuderende til hospitaler

• Mål: Givet præferencer fra hospitaler og lægestuderende skal der designes en selvjusterende tildelingsproces.

• Tildeling: Alle studerende skal tildeles et hospital og hvert hospital skal tildeles et bestemt antal studerende.

• Ustabilt par: Studerende x og hospital y er ustabile hvis:

• x foretrækker y frem for sit tildelte hospital.

• y foretrækker x fremfor en af sine tildelte studerende.

• Stabil tildeling: En tildeling uden ustabile par.

Individuel interesse vil forhindre private aftaler i at blive lavet mellem studerende og hospitaler.


Stabil matching problemet

• Mål: Givet n mænd og n kvinder find en “tilfredstillende” matching. Deltagerne prioriterer deltagere af modsatte køn.• Enhver mand laver en liste med kvinder i sin foretrukne rækkefølge (fra

bedst til værst).• Enhver kvinde laver en liste med mænd i sin foretrukne rækkefølge (fra

bedst til værst).

Søren Brun Thomas Schröder Franklin

Trine Rikke Rask Lotte Nina

Søren BrunFranklinThomasSchröder

SchröderSøren BrunFranklinThomas

Søren BrunThomasFranklinSchröder

ThomasFranklinSchröder

Søren Brun

LotteNinaTrine

Rikke Rask

LotteTrine

Rikke RaskNina

Rikke RaskNinaLotteTrine

TrineRikke Rask

LotteNina


Stabil matching problemet

• Perfekt matching: • Enhver mand får præcis én kvinde.• Enhver kvinde får præcis én mand.

• Ustabilt par: En mand Søren og en kvinde Trine er ustabile hvis de foretrækker hinanden frem for deres nuværede partner:• Søren foretrækker Trine frem for sin nuværende partner.• Trine foretrækker Søren frem for sin nuværende partner.• Et ustabilt par kan forbedre deres situation ved at stikke af sammen.

• Stabil matching: Perfekt matching uden nogen ustabile par.

• Stabil matching problemet: Givet præferencelister fra n mænd og n kvinder find en stabil matching, hvis en sådan eksisterer.


19



EksempelSøren BrunFranklinThomasSchröder




Søren Brun

LotteNinaTrine

Rikke Rask

LotteTrine

Rikke RaskNina


TrineRikke Rask

LotteNina


20



Find en stabil matchingSøren BrunFranklinThomasSchröder




Søren Brun

LotteNinaTrine

Rikke Rask

LotteTrine

Rikke RaskNina


TrineRikke Rask

LotteNina


21



En stabil matchingSøren BrunFranklinThomasSchröder




Søren Brun

LotteNinaTrine

Rikke Rask

LotteTrine

Rikke RaskNina


TrineRikke Rask

LotteNina


Fri-og-afvis algoritmen

• Til at starte med er alle ledige.

• Så længe der findes en ledig mand der endnu ikke har friet til alle kvinder gør følgende:� Vælg en sådan mand m.� Manden m frier til den kvinde øverst på hans liste som han ikke allerede

har friet til:� Hvis hun er ledig, siger hun ja, og de bliver forlovet.� Hvis hun foretrækker ham frem for sin nuværende forlovede, siger hun

ja, de bliver forlovet, og samtidig ophæver hun sin tidligere forlovelse.� Hvis hun foretrækker sin nuværende forlovede, afviser hun manden m.

• Fri-og-afvis algoritmen. [Gale & Shapley 1962] Intuitiv måde der garanteret altid finder en stabil matching.


Fri-og-afvis algoritmen

• Fri-og-afvis algoritmen. [Gale & Shapley 1962] Intuitiv måde der garanteret altid finder en stabil matching.

Initialiser alle personer til at være frie.while (der findes en mand er fri som ikke har friet til alle kvinder) {

Vælg sådan en mand mk = øverste kvinde på m’s liste som m ikke allerede har friet tilif (k er fri)

then sæt m og k til at være forlovedeelse if (k foretrækker m frem for sin forlovede z)

then sæt m og k til at være forlovede, og z til at være fri.else

k afviser m.}


24



Fri-og-afvis algoritmenSøren BrunFranklinThomasSchröder




Søren Brun

LotteNinaTrine

Rikke Rask

LotteTrine

Rikke RaskNina


TrineRikke Rask

LotteNina

TrineRikke Rask

LotteNina

TrineRikke Rask

LotteNina



LotteNinaTrine

Rikke Rask

Søren BrunFranklinThomasSchröder

LotteTrine

Rikke RaskNina

LotteTrine

Rikke RaskNina





Søren Brun


Bevis for korrekthed: Terminering

• Spørgsmål: Hvorfor stopper fri-og-afvis algoritmen altid på et eller andet tidspunkt?

• Hint 1. I hvilken rækkefølge frier en mand til kvinderne på sin liste?

• Hint 2. Hvis en kvinde er ledig kan vi så sige noget om hvor mange der har friet til hende?

• Hint 3. Hvor mange gange kan en mand fri til den samme kvinde?

• Hint 4. Hvor mange frierier kan vi have i alt (der er n mænd og n kvinder)?

Ingen!

I faldende orden fra bedst til værst.

1 gang.

n2


Bevis for korrekthed: Terminering

• Observation 1. Mænd frier til kvinder i faldende orden i forhold til præferencer (bedste først).

• Observation 2. Når en kvinde er blevet forlovet bliver hun aldrig ledig igen, men hun kan skifte til noget bedre.

• Påstand: Algoritmen terminerer efter højst n2 iterationer af while-løkken (= højst n2 frierier).

• Bevis. Hver gang while-løkken gennemløbes frier en mand til en kvinde han ikke har friet til før. Der er kun n2 forskellige frierier. ∎


Bevis for korrekthed: Perfektion

• Påstand. Alle mænd og kvinder får en partner.

• Hint 1. Brug modbevis (antag der findes en ledig kvinde).

• Hint 2. Hvad kan man sige om en kvinde der er ledig når algoritmen terminerer?

• Hint 3. Hvis der er en ledig kvinde så er der også en .....?

• Hint 4. Hvor mange kvinder har en ledig mand friet til når algoritmen terminerer?

Ingen har friet til hende.

ledig mand

Alle


Bevis for korrekthed: Perfektion

• Påstand. Alle mænd og kvinder får en partner.

• Bevis. (modsætningsbevis) � Antag der findes en ledig kvinde, Hanne.� I følge Observation 2, er der ikke nogen der har friet til Hanne.� Når Hanne er ledig må der også være en ledig mand, f.eks. Per, da der er

lige mange mænd og kvinder.

� Men Per frier til alle, siden han ender med at være ledig. ∎


Bevis for korrekthed: Stabilitet

• Påstand. Der er ingen ustabile par.

• Bevis. (ved modsætning)� Antag at Per og Hanne er et ustabilt par: de foretrækker hinanden frem for

deres nuværende partner.� Tilfælde 1: Per har ikke friet til Hanne.

� Per foretækker sin nuværende partner frem for Hanne.� Per og Hanne er ikke et ustabilt par.

� Tilfælde 2: Per har friet til Hanne.� Hanne afviste Per (med det samme eller senere).� Hanne foretrækker sin nuværende partner frem for Per.

� Per og Hanne er ikke et ustabilt par. ∎

Mænd frier i faldende orden af deres præferencer.

Kvinder bytter kun opad.


Opsummering: Stabil matching

• Stabil matching problemet. Givet n mænd og n kvinder, og deres præferencer, find en stabil matching.

• Eksempel: Tildeling af lægestuderende til hospitaler.

• Gale-Shapley algoritmen. Fri-og-afvis.

• GS-algoritmen terminerer. Hver gang en mand frier, så frier han til en ny kvinde.

• GS-algoritmen finder altid en perfekt matching.


Stabil matching

• GS-algoritmen kan modificeres til at håndtere mange varianter af problemet:� Polygami (hospitaler-lægestuderende)� Forbudte partnere.� Kun præferencer for nogle - resten lige meget.� Kun to præferencer: god eller dårlig.

• Effektiv implementation? � Ser vi på om 2 uger i forbindelse med datastrukturer.

• Hvis der er flere stabile matching’er hvilken en finder GS så?


5 repræsentative problemer

Flere eksempler


Interval skedulering

• Input. Mængde af opgaver med start- og sluttider.

• Mål. Find den største delmængde af kompatible opgaver.

Tid0 1 2 3 4 5 6 7 8 9 10 11

f

g

h

e

a

b

c

d

h

e

b

Opgaverne overlapperikke tidsmæssigt.


Vægtet interval skedulering

• Input. Mængde af opgaver med start- og sluttider og vægte.

• Mål. Find den delmængde af kompatible opgaver der har størst vægt.

Tid0 1 2 3 4 5 6 7 8 9 10 11

20

11

16

13

23

12

20

26


2-delt matching

• Input. 2-delt graf.

• Mål. Find den største matching.

C

1

5

2

A

E

3

B

D 4


Uafhængig mængde

• Input. Graf.

• Mål. Find den største mængde uafhængige knuder.

6

2

5

1

7

34

6

5

1

4

Mængde af knuder hvor der ikke er nogen kanter imellem.


Kompetitiv facilitetsplacering

• Input. Graf med vægte på knuderne.

• Spil. 2 konkurrerende spiller skiftes til at vælge en knude. Det er ikke tilladt at vælge en knude hvis en af dens naboer er valgt.

• Mål. Find ud af om der findes en strategi for spiller 2 der giver værdi B.

10 1 5 15 5 1 5 1 15 10

2nd spiller kan garantere 20, men ikke 25.


Læringsmål og pensum for dagens forelæsning

• Efter denne forelæsning vil du være i stand til at:� Forklare begrebet algoritme.

� Definere stabil matching problemet.� Beskrive Gale-Shapley (GS) algoritmen på en klar måde.� Anvende GS-algoritmen.� Argumentere for at GS-algoritmen terminerer i endelige tid.� Argumentere for at GS-algoritmen finder en korrekt løsning.

• Pensum: KT side 1-22.


Analyse af algoritmer


Læringsmål og pensum

• Læringsmål: Efter denne forelæsning vil du kunne

� Forklare hvad køretid af en algoritme betyder og hvordan det beregnes.

� Forklare hvad worst-case køretid er.

� Lave simple beregninger i O-notation.

� Analysere algoritmers køretid vha. asymptotisk notation.

� Forklare hvad en polynomiel tids algoritme er.

• Pensum: KT side 29-42 (afsnit 2.0-2.2) og side 65 midt-66 (“Solved Exercises”).


Analyse af algoritmer

• Analyse af algoritmer.

• Afgøre algoritmens forbrug af ressourcer

• tid,

• hukommelse,

• cache-forbrug, ...

• Dette kursus: Mest om tid og en lille smule om hukommelse.

• Argumentere for korrekthed.


Køretid og beregningskridt

• Køretid. Antal beregningsskridt en algoritme bruger på et givet input.

• Beregningsskridt. Abstraherer væk fra detaljer og forskelle i hardware ved at måle køretid i beregningskridt. Følgende operationer tæller som ét beregningskridt (RAM modellen):� Simple tildelinger: x = y, � Simple aritmetiske operationer (+, *, -, /, floor, ceiling, %, m.fl.). � Simple sammenligninger: a < b, a = b, a > b. Eks. i > 0 and j>i; � Andre “trivielle” operationer som er uafhængige af inputstørrelsen

(conditional and unconditional branching, and, or,...).

• Køretid angives som en funktion af inputstørrelsen: T(n).


Beregningskridt: Eksempler

• Konstant antal beregningsskridt:

• Operationer som ikke tæller som et konstant antal beregningskridt er eksempelvis

� Tildelingen

T(n) afhænger af køretiden af algoritmen Min.� for-løkken:

T(n) afhænger af n: T(n)~n.

if (i > 0)then { j = 1 }else { j = j+2 }

x = Min(A)

for i = 1 to n { j = i + 1}


Opgaver

• For hvilke af følgende operationer er T(n) konstant:

✓

÷

✓

for i = 1 to n {j = i·i + 3}

for i = 1 to 27 {j = i·i + 3}

if (i < 14)then { x = i % 2}else { x = i / 2}


Worst-case analyse (værste tilfælde-analyse)

• Worst-case analyse. Find en grænse for den størst mulige køretid af en algoritme på input af en given størrelse n.

• Average case analyse. Find en grænse for køretid af en algoritme på tilfældigt input af størrelse n.

• Køretid = worst-case køretid i resten af dette kursus med mindre andet bliver sagt eksplicit.


Asymptotisk analyse

O-notation


Størrelsesorden af køretidsfunktioner

• Ønsker at sige noget om køretiden af en algoritme på input af størrelse n.

• For store n er led af lavere orden ubetydelige:

T(n) ~ 7n2

• Kan desuden ignorere konstante faktorer (ser kun på væksthastigheden):

T(n) ~ n2

T(n) = 7n2 + 3n + 42.


T(n)=7n2+3n+42

0

750

1500

2250

3000

0 5 10 15 20

7n^2 3n 42

0

200

400

600

800

0 1 2 3 4 5 6 7 8 9 10

7n^2 3n 42


Asymptotisk størrelseorden

• Øvre grænse. T(n) er O(f(n)) hvis der eksisterer konstanter c>0 og n0 ≥ 0 således at for alle n ≥ n0 gælder T(n) ≤ c · f(n).

• Eksempler: T(n)= 7n2 + 3n + 42.

� 7n2 + 3n + 42 ≤ 7n2 + 3n2 + 42n2 ≤ (7+3+42)n2 for alle n ≥ 1 T(n) er O(n2).

� T(n) er også O(n3)!

� T(n) er ikke O(n).


Notation

• Lettere misbrug af notation. T(n) = O(f(n)).

• Vær opmærksom på:� O(f(n)) er en mængde af funktioner.� Kan ikke skrive O(n3) = f(n).� f(n)=O(n3) og g(n)=O(n3) medfører ikke f(n) = g(n). Eks. f(n) = 5n3, g(n) = 3n2,

men f(n) ≠ g(n).

• Tænk på det som ∈ eller ⊆: T(n) ∈ O(f(n)) eller O(n2) ⊆ O(n3)


Opgaver

• f(n) = 3n + 2n3 - n2

• f(n) = O(n)?

• f(n) = O(n3)?

• f(n) = O(n4)?

• g(n) = 4n2 + log n

• g(n)=O(n2 log n)?

• g(n) = O(n2)?

• g(n) = O(f(n))?

• f(n) = O(g(n))?

✓✓

✓

✓✓

÷

÷


Asymptotisk størrelseorden

• Øvre grænse. T(n) er O(f(n)) hvis der eksisterer konstanter c > 0 og n0 ≥ 0 således at for alle n ≥ n0 gælder T(n) ≤ c · f(n).

• Nedre grænse. T(n) er Ω(f(n)) hvis der eksisterer konstanter c>0 og n0 ≥ 0 således at for alle n ≥ n0 gælder T(n) ≥ c · f(n).

• Tæt grænse. T(n) er Θ(f(n)) hvis T(n) er både O(f(n)) og Ω(f(n)).

• Eksempel: T(n) = 7n2 + 3n + 42. � T(n) er O(n2), O(n3), Ω(n2), Ω(n) og Θ(n2).� T(n) er ikke O(n), Ω(n3), Θ(n) eller Θ(n3).

• Obs: O-notation (O, Ω og Θ) bruges kun på ikke-negative funktioner.


Egenskaber

• Transitivitet.

� f=O(g) og g=O(h) f=O(h).

� f=Ω(g) og g=Ω(h) f=Ω(h)

� f=Θ(g) og g=Θ(h) f=Θ(h).

• Additivitet.

� f=O(h) og g = O(h) f+g =O(h).

� f=Ω(h) og g=Ω(h) f+g=Ω(h)

� f=Θ(h) og g=Θ(h) f+g=Θ(h).


Egenskaber

• Symmetri

� f = Θ(g) hvis og kun hvis g = Θ(f)

• Transponeret symmetri.

� f=O(g) hvis og kun hvis g=Ω(f)

• Addition og maximum.

� max{f,g} = Θ(f+g)


Asymptotiske grænser for nogle almindelige funktioner

• Polynomier. a0 + a1 n + ....+ ad nd = Θ(nd) for ad > 0

• Logaritmer. O(loga n) = O(logb n) for alle konstanter a, b > 0.

• Logaritmer. log n = O(nx) for alle x > 0.

• Eksponenter. nd = O(rn) for alle r > 1 og d > 0.

kan undgå at specificere basen

log vokser langsommere end ethvert polynomie

Enhver exponentiel funktion vokser hurtigere end ethvert polynomie


Eksempler

• Find mindste tal:

• Lineær køretid: T(n)=O(n) og T(n)=Ω(n) dvs. T(n) = Θ(n)

Min( a1,....,an]){m = a1for i = 2 to n { if (ai < m)

then {m = ai}}

return m}

konstant tid

gentages n-1 gange for i = 2 to n { if (ai < m)

then {m = ai}}


Eksempler m. 2 for-løkker

Loop1(n){x = 1for i = 1 to n {

for j = 1 to n { x = x + 1

}}return x

}

O(n) tid

Loop2(n){x = 1for i = 1 to n {

x = x + 1}for j = 1 to n {

x = x + 1}return m

}

gentages n gange

}

for i = 1 to n {for j = 1 to n {

x = x + 1}

• Kvadratisk køretid:

• T(n) = O(n2),

• T(n) = Ω(n2),

• T(n) = Θ(n2)

• Lineær køretid:

• T(n) = O(n),

• T(n) = Ω(n),

• T(n) = Θ(n)

for i = 1 to n {x = x + 1

}

gentages n gange

for j = 1 to n {x = x + 1

}

gentages n gange


Eksempler

• Bubble-sort: Sorterer et array A af længde n indeholdende tal.

• Eks. Input A=<3,67,34,2,25>. Output: A=<2,3,25,34,67>

• Kvadratisk køretid: T(n)=O(n2), T(n)=Ω(n2), dvs. T(n) = Θ(n2), hvor n er længden af A.

Bubblesort(A){for i = 2 to length[A]{ for j = length[A] downto i {

if (A[j] < A[j-1])

then { exchange A[j] A[j-1] }

}}

}


Eksempler

• Linearitmisk (linearitmic) køretid: T(n)=O(n log n) og T(n)=Ω(n log n) dvs. T(n) = Θ(n log n).

• For hver iteration af for-løkken kører while-løkken log n gange: 1. gang er j =1, 2. gang er j=2, osv. Efter k iterationer er j= 2k. Løkken stopper når j = 2k > n, dvs. når k > log n.

Loop4(n){x = 1for i = 1 to n {j = 1while (j ≤ n) {

x = x + 1j = 2·j

}}return x

}


Eksempel

• Mere om løkker:

• Hvor køretiden for Alg(i) = O(i)?

• Hvor køretiden for Alg(i) = O(1)?

• Hvor køretiden for Alg(i) = O(log i)?

O(n2)

O(n)

O(n log n)

for i = 2 to n { x = Alg(i)}


Effektive algoritmer


Effektiv algoritme

• Forslag til definition af effektiv algoritme (1): En algoritme er effektiv hvis den kører hurtigt på alle input.

• Brute force. For mange ikke-trivielle problemer er der en naturlig brute-force søgealgoritme der checker alle mulige løsninger.� Typisk 2n tid/skridt eller værre for input af størrelse n.� Uacceptabelt i praksis.

• Forslag til definition af effektiv algoritme (2): En algoritme er effektiv hvis den har bedre (worst-case) køretid end brute-force søgning.

n! for stabil matching med n mænd og n kvinder


Polynomiel tid

• Ønskelig skaleringsegenskab. Når input-størrelsen fordobles bliver algoritmen kun en konstant faktor langsommere.

• Definition. En algoritme kaldes for en polynomiel-tids algoritme hvis ovenstående skaleringsegenskab holder. Vi siger også at algoritmen har polynomiel køretid.

Der findes en konstant d>0 således at T(n) =O(nd).


Worst-case polynomiel tid

• Definition. En algoritme er effektiv hvis dens (worst-case) køretid er polynomiel.

• Begrundelse. Det virker rent faktisk i praksis!� Selv om 6.02 x 1023 x n20 teknisk set er polynomiel-tid, ville den være

ubrugelig i praksis. � I praksis, har polynomiel-tids algoritmer som bliver udviklet næsten altid

små konstanter og små eksponenter.� At bryde igennem den eksponentielle barriere af brute force afdækker

typisk nogle grundlæggende strukturer ved problemet.

• Undtagelser. � Nogle polynomiel-tids algoritmer har høje konstanter og/eller høje

eksponenter og er ubrugelige i praksis.� Nogle eksponentiel-tids (eller værre) algoritmer er meget brugte da worst-

case tilfældene ser ud til at være sjældne.


Hvorfor det er vigtigt


Faldgruber

• Pas på med ikke at forveksle Ω, Θ og O med worst-case, average-case og best-case analyse:

• Worst-case analyse:

� Vi kigger på hvad T(n) er i værste tilfælde for input af størrelse n.

• Ω, Θ og O:

� Siger noget om hvor tætte grænser vi har på funktionen T(n).

� T(n) = O(n) bruges når vi kender en øvre grænse for T(n).

� T(n) = Ω(f) bruges når vi har en nedre grænse for T(n).

� T(n) = Θ(n). Angiver at analysen af algoritmen er “tæt”.


Eksempel

• T(n) = antal iterationer i GS-algoritmen: Viste T(n)=O(n2) sidste gang. Er den også Ω(n2)?

• Husk vi taler om worst-case!

• Sidst: for ethvert input er der højst n2 iterationer, dvs. T(n)=O(n2).

• Vis at der findes input så der udføres n(n+1)/2 iterationer. Dvs. T(n)=Ω(n2).




� Forklare hvad køretid af en algoritme betyder og hvordan det beregnes.

� Forklare hvad worst-case køretid er.

� Lave simple beregninger i O-notation.

� Analysere algoritmers køretid vha. asymptotisk notation.

� Forklare hvad en polynomiel tids algoritme er.

• Pensum: KT side 29-42 (afsnit 2.0-2.2) og side 65 midt-66 (“Solved Exercises”).


Introduktion til datastrukturer

Hægtede lister og tabeller

1fredag den 19. februar 2010



� Forklare hvad en hægtet liste er.

� Indsætte og slette elementer, samt søge i en hægtet liste.

� Argumentere for køretiderne af ovenstående operationer på en hægtet liste og angive dem i O-notation.

� Anvende binær søgning på en tabel (array).

� Angive køretiden for binær søgning i O-notation samt argumentere for den.

� Vurdere om tabeller eller hægtede lister passer bedst til en given implementation.

� Vælge datastrukturer til implementation af GS-algoritmen, samt analysere køretiden af implementationen.

• Pensum: KT afsnit 2.3 + side 56.


Datastruktur

• Datastruktur: Måde til at organisere data så der effektivit kan søges og modificeres i det.


Implementation af stabil matching

• Ønsker at implementere af GS-algoritmen

• Hvordan holder vi styr på

• Hvilke mænd der er ledige.

• Hvilken kvinde m skal fri til i denne runde.

• Om kvinde k er ledig.

• Om kvinde k foretrækker mand m frem for sin forlovede z.

Initialiser alle personer til at være frie.

while (en mand er fri som ikke har friet til alle kvinder) {

Vælg sådan en mand m

k = øverste kvinde på m’s liste som m ikke allerede har friet til

if (k er fri)

sæt m og k til at være forlovede

else if (k foretrækker m frem for sin forlovede z)

sæt m og k til at være forlovede, og z til at være fri.

else

k afviser m.

}


Tabeller


Tabeller (arrays)

• Egenskaber ved en tabel:

• Kan tilgå det i’te element i O(1) tid: A[i]

• Eksempel

• Hvem er forlovet med hvem

• Tabel ikke egnet til dynamisk mængde: f.eks. ledige mænd.

• besværligt at tilføje/fjerne elementer.


Hægtede lister (linked lists)


Hægtede lister (linked lists)

• Implementation af dynamisk mængde: (mængde der kan ændre størrelse).

• Operationer:

• Insert

• Delete

• Search

• Hægtet liste ~ kæde: Liste over de enkelte led i kæden, hvor det for hvert led er angivet hvilket led der er det efterfølgende.

• Dobbelthægtet liste: Hvert led angiver hvilket led der er det foregående og hvilket der er det efterfølgende.


Hægtede lister

• Hægtet liste: Mængde af knuder, hvor hver knude har en værdi/et navn og indeholder en reference/peger til næste knude.

• Hægtede lister i Java:

• Nemt at definere som Java klasse.

• En reference til en String eller Int.

• En reference til en anden knude.

• Brug speciel værdi null til at slutte listen.

public class Node {private String name;private Node next;

}


Hægtede lister

• Demo


Hægtede lister

• Dobbelthægtet liste: Mængde af knuder, hvor hver knude har en værdi/et navn og indeholder referencer/pegere til en næste og foregående knude.

• Hvert element e har:

• En værdi: e.val

• En pointer/reference til næste element: e.next

• En pointer/reference til forrige element: e.prev

• Pointer first: peger på første element.

• first.prev = null, last.next = null.

• Pointer last: peger på sidste element (kan undværes).

9prev next

4prev next

13prev next

27prev next

5prev nextFirst


Hægtede lister

• Eksempler: Liste L

• first.val = 9

• first.next.val = 4 eller (first.next).val = 4

• first.next.next.val = 13 ((first.next).next).val = 13

• x = first.next: x.prev.val = 9

9prev next

4prev next

13prev next

27prev next

5prev nextfirst(L)


Søgning i hægtede lister

• Søg efter værdien k i listen L.

• Eksempel: Search(L,13)

• Køretid: Θ(n)

9prev next

4prev next

13prev next

27prev next

5prev nextFirst(L)First(L)First(L)

99 44 13

Search(L,k){x = first(L)while x ≠ Null and x.val ≠ k do { x = x.next }

return x}


Indsættelse i hægtede lister

• Indsæt element e i forrest listen

• InsertFirst tager en pointer/reference til elementet som input.

5prev next prev next

9 4prev next

13prev next

27prev next

e

first(L)

InsertFirst(L,e){e.next = first(L)if (first(L) ≠ Null) then {first(L).prev = e}

first(L) = ee.prev = Null

}



• Indsæt element e i forrest listen

• InsertFirst tager en pointer/reference til elementet som input.

• Køretid: O(1)

5prev next prev next

9 4prev next

13prev next

27prev next

e

first(L)

InsertFirst(L,e){e.next = first(L)if (first(L) ≠ Null) then {first(L).prev = e}

first(L) = ee.prev = Null

}



• Indsæt element e mellem element d og f i listen L

• Insert tager en pointer/reference til elementet som input.

• Køretid: O(1)

Insert(L,e,d,f){e.next = f

e.prev = dd.next = ef.prev = e

}


Sletning i hægtede lister

• Slet element e fra listen L.

• Delete tager en pointer/reference til elementet som input.

9prev next

4prev next

13prev next

27prev next

5prev nextFirst(L)

Delete(L,e){if (e.prev = Null) then {first(L) = e.next}else {(e.prev).next = e.next}

if (e.next ≠ Null) then {e.next.prev = e.prev}

}

e


Sletning i hægtede lister

• Slet element e fra listen L.

• Delete tager en pointer/reference til elementet som input.

• Slet element med en given værdi v: Kald først Search(L,v)

• Køretid: O(1)

9prev next

13prev next

27prev next

5prev nextFirst(L)

Delete(L,e){if (e.prev = Null) then {first(L) = e.next}else {(e.prev).next = e.next}

if (e.next ≠ Null) then {e.next.prev = e.prev}

}


Hægtede lister opsummering

• Følgende operationer:

• Search(L,k): Θ(n)

• InsertFirst(L,e): O(1)

• Insert(L,e,d,f): O(1)

• Delete(L,e): O(1)

• Hvordan ville køretiderne blive påvirket hvis vi implementerede operationerne i en simpel tabel?

• Dårligere køretider.

• Search: Θ(N), hvor N størrelsen af tabellen (N ≥ n).

• Enten Insert eller Delete får køretid Θ(n).


Mere om tabeller: binær søgning


Binær søgning i tabeller (arrays)

• Givet sorteret tabel (array) A med n tal findes tallet x i A?

• Lineær søgning: Check alle indgange i tabellen fra 1....n.

• Binær søgning:

• Find værdien v af midterste indgang i A.

• v = x: færdige

• v < x: Gentag proceduren rekursivt på øverste halvdel af A

• v > x: Gentag proceduren rekursivt på nederste halvdel af A


Binær søgning: Analyse

• Hvor mange indgange kigger vi højst på?

• En iteration: Tabellen vi kigger på bliver halvt så stor. Efter

• 1. omgang: n/2

• 2. omgang: n/4

• ......

• k’te omgang: n/2k

• k skal være så stor at n/2k ≤ 1 k ≥ log2 n.

• Køretid: Θ(log n).


Binær søgning opgave

• Brug binær søgning til at lede efter tallene 7 og 42 i denne tabel.

• Giv et generelt eksempel hvor binær søgning bruger log n skridt (vis at T(n)= Ω(log n)).

• Hvorfor kan man ikke lave binær søgning i en sorteret hægtet liste i O(log n)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

2 5 7 11 12 14 16 25 32 33 42 45 64 67 78 83 92928378676432251614121152 4542337 3232115 7 6442

• 7: A[9]=32, A[4]=11, A[2]=5, A[3]=7

• 42: A[9]=32, A[13]=64, A[11]=42

Tallet der søges efter er ikke i tabellen.

Kan ikke tilgå en bestemt position i listen i konstant tid.


Binær søgning pseudokode

• Iterativ implementationBinarySearch(A,x){lo = 1hi = length[A]while (lo ≤ hi) { mid = lo +⎣(hi - lo)/2⎦if (x < A[mid]) then { hi = mid-1 }

else if (x > A[mid]) then{ lo = mid+1 }

else // x = A[mid]{ return mid // Found }

}return -1 // Not found

}


Binær søgning pseudokode

• Rekursiv implementation:

BinarySearch(A,lo,hi,x){if (hi < lo) then {return -1} // Not foundmid = lo +⎣(hi - lo)/2⎦if (x < A[mid]) then {BinarySearch(A,lo,mid-1,x)

else if (x > A[mid]) then {BinarySearch(A,mid+1,hi,x)

else { return mid } // Found}


Sammenligning: tabeller og hægtede lister

• Tabel:

• Find i’te element: O(1)

• Søgning

• usorteret: Θ(n)

• sorteret: Θ(log n)

• Indsæt og slet: Kan ikke gøres i konstant tid hvis tabellen skal have størrelse Θ(n).

• Hægtet liste:

• Find i’te element: Θ(i) (O(n))

• Søgning (både sorteret/usorteret): Θ(n)


Implementation af GS-algoritmen

Valg af datastrukturer


Valg af datastruktur

• Hvordan vælger man hvilken datastruktur man vil bruge til implementation af f.eks. en (dynamisk) mængde?

• Kig på køretiderne for de forskellige operationer og overvej hvilke operationer du har brug for i det konkrete tilfælde.

• Eksempel: GS-algoritmen

Initialiser alle personer til at være frie.




if (k er fri)




else

k afviser m.

}



• Mænd og kvinder identificeres ved et nummer.

• Mænds præferenceliste: For hver mand m

• Hægtet liste Pm i ordnet rækkefølge, slet kvinde fra listen når m har friet til hende.

• Ledige mænd: Hægtet liste L.

• Forlovede: tabel F. F[i] = j hvis kvinde i er forlovet med mand j, -1 hvis hun er fri.

• Kvinders præferenceliste: ??? Initialiser alle personer til at være frie.




if (k er fri)




else

k afviser m.

}



• Kvindernes præferenceliste: 1. forsøg

• Ordnet tabel Bk: Bk[i] = mand nummer i på kvinde k’s præferenceliste.// Initialiser alle personer til at være frie.

for (i=1 to m) do {F[i] = -1

InsertFirst(L,i) // Indsæt mand i i listen af ledige mænd.

}

while (L non-empty) {

m = RemoveFirst(L) // m første ledige mand

k = RemoveFirst(Pm) // k første kvinde på m’s liste

z = F[k]

if (z = -1) { F[k] = m } // k ledig

else if (k foretrækker m frem for z) { // k foretrækker m

F[k] = m

InsertFirst(L,z)

}

else {InsertFirst(L,m)} // k foretrækker z

}

}

Køretid?O(n3)




• Tabel: Bk[i]= rangen af mand i på k’s præferenceliste.

• Foretrækker k mand m frem for z

• Check om Bk[m] < Bk[z]: O(1)

• Konstruktion af Bk for en kvinde: Θ(n)

• Konstruktion af Bk for alle k: Θ(n2)




• Tabel: Bk[i]= rangen af mand i på k’s præferenceliste.

Køretid?

O(n2)

// Initialiser alle personer til at være frie.

for (i=1 to m) do {F[i] = -1

InsertFirst(L,i) // Indsæt mand i i listen af ledige mænd.

}

while (L non-empty) {

m = RemoveFirst(L) // m første ledige mand

k = RemoveFirst(Pm) // k første kvinde på m’s liste

z = F[k]

if (z = -1) { F[k] = m } // k ledig

else if (m kommer før z i Bk) { // k foretrækker m

F[k] = m

InsertFirst(L,z)

}

else {InsertFirst(L,m)} // k foretrækker z

}

}



• Mænd og kvinder

• Identificeres ved et nummer.

• Mænds præferenceliste: For hver mand M

• Hægtet liste i ordnet rækkefølge, slet kvinde fra listen når M har friet til hende.

• Ledige mænd:

• Hægtet liste.

• Forlovede: tabel F.

• F[i] = j hvis kvinde i er forlovet med mand j og -1 hvis hun er fri.

• Kvinders præferenceliste:

• Tabel: Bk[i]= rangen af mand i på kvinde k’s præferenceliste.



• Analyse:

• Initialisering: Θ(n2)

• En iteration af while-løkken: O(1)

• Antal iterationer: Θ(n2)

• Køretid: T(n) = Θ(n2)

Initialiser alle personer til at være frie.while (en mand er fri som ikke har friet til alle kvinder) {

Vælg sådan en mand mk = øverste kvinde på m’s liste som m ikke allerede har friet tilif (k er fri)

sæt m og k til at være forlovedeelse if (k foretrækker m frem for sin forlovede z)

sæt m og k til at være forlovede, og z til at være fri.else

k afviser m.}



• Alternativer:

• Mænds præferenceliste: For hver mand

• Tabel (array): Am[i] = i’te kvinde på m’s præferenceliste.

• Tæller holder styr på hvor langt ned i rækken han er nået.

• Forlovede:

• Objektorienteret. Objekt for hver mand og kvinde. Kvindeobjekterne indholder felt der angiver hvem de er forlovet med. Mande/kvinde-objekter indholder tabellerne der angiver deres præferenceliste.


Hvorfor det er vigtigt

• Har set to implementationer af GS-algoritmen: Θ(n2) og Θ(n3).

• Gør det nogen forskel hvilken én vi vælger?


Opsummering

• Hægtede lister (linked lists)

• Search: Θ(n)

• Insert, InsertFirst, Delete: O(1)

• Binær søgning i tabeller (arrays)

• Θ(log n)

• Implementation af GS-algoritmen med hægtede lister og tabeller.

• Køretidsanalyse af GS-algoritmen: Θ(n2)


Hjemmeopgave 1

• Afleveres 8.15 d. 25/2


Rekursion og eksperimental analyse

1Tuesday, February 23, 2010

Dagens læringsmål

• Efter dagens forelæsning vil du være i stand til at

• Forklare hvad en rekursiv algoritme er

• Forklare forskellen mellem rekursion og iteration

• Konstruere rekursive algoritmer

• Analysere køretiden og argumentere for korrektheden af en rekursiv algoritme

• Anvende mergesort, analysere dens køretid, samt argumentere for dens korrekthed.

• Bruge den videnskabelige metode til at lave eksperimentel analyse af algoritmer.

• Pensum:

• Reges og Stepp udleverede kopier (om rekursion)

• KT 5.1 + s. 48-50 (om merge, mergesort og analysen af dem).

• Sedgewick og Wayne udleverede kopier.


Rekursion


Rekursion

• Iteration

• Aktioner der skal gentages beskrives ved hjælp af en løkke.

• Rekursion

• Aktioner der skal gentages beskrives ved hjælp af en metode/algoritme der kalder sig selv.


Rekursion: Skriv ord ud i omvendt rækkefølge

• Input:

er

dette

ikke

sjovt

• Output:

sjovt

ikke

dette

er

public static void reverse(Scanner input){

if (input.hasNextLine()) {

String line = input.nextLine();

reverse(input);

System.out.println(line);

}

}





reverse(input);


}}

line: er

environment if (input.hasNextLine()) {


reverse(input);

Input:

er

dette

ikke

sjovt

er





reverse(input);


}}

line: er

environment

reverse(input);




reverse(input);


}}

line: dette

environment

reverse(input);




reverse(input);


}}

line: ikke

environment

reverse(input);




reverse(input);


}}

line: sjovt

environment

reverse(input);




reverse(input);


}}


Input:

er

dette

ikke

sjovtsjovt





reverse(input);


}}

line: er

environment

reverse(input);

Output:

sjovt

ikke

dette

er


Input:

er

dette

ikke

sjovt


Rekursion

• Basis-tilfælde. Simpelt/simple tilfælde der løses uden rekursivt kald

• Rekursions-tilfælde/skridt. Reducerer til simplere problem der kan løses ved et (eller flere) rekursive kald.


Eksempel

• Basis-tilfælde. Gør ingenting.

• Rekursions-tilfælde. reverse(input)




reverse(input);


}

}

reverse(input);


Rekursion og induktion

• Rekursion

• Basis-tilfælde. Simpelt/simple tilfælde der løses uden rekursivt kald

• Rekursions-tilfælde/skridt. Reducerer til simplere problem der kan løses ved et (eller flere) rekursive kald.

• Induktion (over n)

• Basis-tilfælde. Simpelt/simple tilfælde der bevises for specifikke værdier af n.

• Induktionsskridt. Antag at udsagnet gælder for alle heltal mindre end n, og brug dettte til at vise det er sandt for n.


Eksempel

• Korrekthed

• Tom linie: Gør ingenting.

• n linier: Antag reverse(input) udskriver de sidste n-1 linier i omvendt rækkefølge. Så udskrives de n-1 sidste linier i omvendt rækkefølge først og bagefter udskrives den første linie.




reverse(input);


}

}

✓

✓


Eksempel

• Køretid T(n)

Hvert rekursivt kald tager worst-case O(1) tid T(n) = O(n).




reverse(input);


}

}


Største fælles divisor (gcd)

• gcd(p,q). Find største heltal der går op i begge tal.

• Eksempel. gcd(4032,1272) = 24.

4032 = 26 × 32 × 71

1272 = 23 × 31 × 531

gcd = 23 × 31 = 24

• Anvendelser

• Simple brøker = 1272/4032 = 53/168

• RSA kryptografisystem


Største fælles divisor

• gcd(p,q). Find største heltal der går op i både p og q.

• Euclids algoritme.

gcd(p, q) =

{p if q = 0gcd(q, p % q) otherwise

← Basistilfælde

← Rekursionsskridt Konvergerer mod basistilfældet.

gcd(4032, 1272) = gcd(1272, 216)

= gcd(216, 192)

= gcd(192, 24)

= gcd(24, 0)

= 24.

4032 = 3 × 1272 + 216




• Euclids algoritme.

gcd(p, q) =


← Basistilfælde

← Rekursionsskridt Konvergerer mod basistilfældet.

pp

q q p%%q

x x x x x x x x

gcd(p,q) = x, p = 8x, q = 3x




• Pseudokode

← Basistilfælde

← Rekursionsskridt

gcd(p, q) =


gcd(p,q) {

if (q = 0) return p;

else return gcd(q,p % q);

}

← Basistilfælde

← Rekursionsskridt


Towers of Hanoi

• Ryk alle plader fra den venstre pind til den højre pind.

• Kun tilladt at rykke én plade ad gangen.

• En plade kan enten placeres på en tom pind eller ovenpå en større plade.

• Legende: Verdens ende når en gruppe af munke er færdige med at flytte pladerne i et tempel med 64 guldplader på 3 diamantnåle.

• http://mazeworks.com/hanoi/index.htm

start slut


Towers of Hanoi: Rekursiv løsning



• TowersOfHanoi(n, left) udskriver de flytninger der skal til for at rykke n plader til venstre (hvis left = true) eller til højre (hvis left = false).

TowersOfHanoi(n, left){

if (n=0) return; // Basistilfælde

TowersOfHanoi(n-1, !left)

if (left) print(n + “ left”)

else print(n + “ right”)


}

Ryk n-1 øverste til modsat side

Ryk n-1 ovenpå den største

Ryk største til ønskede sted.



• TowersOfHanoi(n, left) udskriver de flytninger der skal til for at rykke n plader til venstre (hvis left = true) eller til højre (hvis left = false).

• Antal flytninger. T(n) = 2·T(n-1) + 1

TowersOfHanoi(n, left){

if (n=0) return; // Basistilfælde


if (left) print(n + “ left”)

else print(n + “ right”)


}

Ryk n-1 øverste til modsat side

Ryk n-1 ovenpå den største

Ryk største til ønskede sted.



• Antal flytninger: T(n) = 2·T(n-1) + 1

• T(1) = 1, T(2) = 3, T(3) = 7, T(4) = 15

• T(n) = 2n - 1

• Bevis:

• Hjælpefunktion U(n): U(n) = T(n) + 1

• U(0) = T(0) +1 = 1

• U(n) = T(n) + 1 = (2·T(n-1) + 1) + 1 = 2·T(n-1) + 2 = 2·U(n-1)

• U(n) = 2n

• T(n) = U(n) -1 = 2n - 1



• Antal flytninger: T(n) = 2·T(n-1) + 1 = 2n - 1

• Induktionsbevis:

• Basis tilfælde: T(0) = 20 - 1 = 0.

• Induktionsskridt:

• Antag T(n-1) = 2n-1 - 1.

• T(n) = 2 · (2n-1 - 1) + 1 = 2n - 2 + 1 = 2n - 1.



• Antal flytninger: T(n) = 2n - 1

• For n = 64 tager det 585 milliarder år (hvis der rykkes en plade i sekundet).

• Enhver løsning bruger mindst så mange skridt.

• Køretiden af TowersOfHanoi: T(n) = 2·T(n-1) + O(1) = Θ(2n)

• Pas på programmer der tager eksponentiel tid!!!


Mergesort


Sortering

• Sortering. Givet n elementer, omarranger dem i ikke-faldende orden.

• Oplagte anvendelser

• Sorter en liste af navne, organiser et MP3 bibliotek, vis Google PageRank resultater, skriv RSS nyheder op i omvendt kronologisk orden.

• Nemme problemer for sorterede elementer

• Find medianen, find nærmeste par, binær søgning i database, identificer statistiske “outliers”, find duplikater i mailingliste.

• Ikke oplagte anvendelser

• Datakompression, computergrafik, computational biology, anbefaling af bøger på Amazon.


Mergesort

• Mergesort

• Del tabellen i 2 halvdele.

• Sorter rekursivt hver del

• Flet de to halvdele sammen til én sorteret liste.Jon von Neumann (1945)

A L G O R I T H M S

DelA L G O R I T H M S

Sorter rekursivtA G L O R H I M S T

FletA G H I L M O R S T


Fletning

• Mål. Kombiner to sorterede lister til én sorteret liste i lineær tid

• Idé.

• Hold styr på mindste element i hver sorteret halvdel.

• Indsæt mindste af de to elementer i en ekstra tabel.

• Gentag indtil færdig.


Fletning

• Flet.




ekstra tabel

mindste mindste

A G L O R H I M S T

A


Fletning

• Flet.




ekstra tabel

første halvdeludtømt

anden halvdeludtømt

A G L O R H I M S T

A G H I L M O R S T


Mergesort

Mergesort(A, low, hi){

if (low < hi)

then {

mid =⎣(hi + low)/2⎦

L = Mergesort(A, low, mid)

R = Mergesort(A, mid+1, hi)

return Merge(L,R)

}

}


Mergesort: Eksempel

5 2 4 7 1 3 2 6

52 4 7 1 3 2 6

52 4 7 1 32 6

52 4 71 32 6

• A = < 5, 2, 4, 7, 1, 3, 2, 6 >

flet flet flet flet

flet

flet

flet


Mergesort: Korrekthed

• Påstand. Mergesort sorterer korrekt enhver tabel.

• Bevis: (induktion over n)

• Basistilfælde. n=1. Allerede sorteret.

• Induktionsskridt. Antag at påstanden er sand for alle tabeller af størrelse mindre end n.

• Venstre og højre halvdel har begge størrelse mindre end n.

• det rekursive kald sorterer dem korrekt

• Merge fletter de to sorterede tabeller korrekt.


Mergesort: Køretid

• Analyse

• Hvis n = 0, 1 eller 2: bruger vi konstant tid

• Hvis n > 2 bruger vi tid på

• indeling af tabellen i 2 halvdele

• rekursivt kald på venstre og højre halvdel

• fletning af de sorterede tabeller

• Rekursionsligning

• T(n) ≤ 2T(n/2) + cn, for n > 2 og en konstant c.

• T(2) ≤ c.


Mergesort: rekursionsligningen

• Rekursionsligning

• T(n) ≤ 2T(n/2) + cn, for n > 2 og en konstant c.

• T(2) ≤ c.

• Løsning

• T(n) = O(n log n)

• Forskellige beviser

• Rekursionstræ

• Substitution/induktion


T(n / 2k) 2k (cn / 2k)

cn/2 (2)

. . .

. . .

T(2) T(2) T(2) T(2) T(2) T(2) T(2) T(2)

Bevis: Rekursionstræ

• T(n) ≤ 2T(n/2) + cn, for n > 2 og en konstant c, og T(2) ≤ c.

• Påstand. T(n) = O(n log n)

log2n

cn log2n

4(cn/4)T(n/4)T(n/4)T(n/4) T(n/4)

2(cn/2)T(n/2)T(n/2)

cnT(n)


Bevis: Substitution

• Substitutionsmetoden.

1. Gæt på løsningen.

2. Brug matematisk induktion til at finde konstanterne og vise at løsningen virker.


Bevis: Substitution

• T(n) ≤ 2T(n/2) + cn, for n > 2 og en konstant c, og T(2) ≤ c.

• Påstand. T(n) = O(n log n)

• Bevis: (induktion over n).

• Basistilfælde: n = 2, cn log n = 2c ≥ T(2).

• Induktionshypotese: T(m) ≤ cm log m for alle m < n.

T(n) ≤ 2T(n/2) + cn

≤ 2c(n/2) log(n/2) + cn

= cn(log n -1) + cn

= cn log n - cn + cn = cn log n.


Rekursion: faldgruber

• Manglende basistilfælde

• Ingen konvergens mod basistilfældet

• Overdrevent pladsforbrug

• Overdreven genberegning


Rekursion: Q&A

• Er der situationer hvor iteration er den eneste mulige måde at angribe problemet på?

• Nej. Enhver løkke kan erstattes af en rekursiv funktion.

• Er der situationer hvor rekursion er den eneste mulige måde at angribe problemet på?

• Nej. Enhver rekursion kan erstattes af en tilsvarende iterativ metode.

• Hvad bør jeg foretrække?

• Det der giver den simpleste, nemmest forståelige og mest effektive algoritme (afhængigt af det konkrete problem).


Opsummering

• Rekursive algoritmer

• Basistilfælde, rekursionsskridt

• Tæt knyttet til matematisk induktion.

• Køretid: Rekursionstræ, substitutionsmetoden.

• Del-og-hersk. Elegant løsning til mange vigtige problemer.

• Mergesort: O(n log n)


Eksperimentiel Analyse af Programmer

Philip Bille


Plan

• Teoretisk vs. eksperimentiel analyse

• Den videnskabelige metode

• Bubblesort som eksempel


Teoretisk vs. Eksperimentiel Analyse

• Teoretisk analyse:

• Analysere algoritmer for at estimere antal operationer som funktion af input størrelse.

• Forsimplet model af virkelighed

• Kan kræve avanceret matematik

• Eksperimentiel analyse:

• Udføre eksperimenter for at måle køretid

• Foregår i virkeligheden :-)

• Nemt at gøre. Brug videnskabelig metode.


Den Videnskabelige Metode


Den Videnskabelige Metode

Udfør og observer eksperimenter

Opstil hypoteser der passer med observationer

Forudsig udfald af nye eksperimentervha. af hypotese

Verificer forudsigelse med nye eksperimenter

Indtil hypoteser og observationstemmer overens


Eksempel: BubbleSort


BubbleSort

public static void bubbleSort(int[] A) { int tmp; for(int i = 1; i < A.length; i++) { for (int j = A.length - 1; j >= i; j--) { if(A[j] < A[j-1]) { tmp = A[j]; A[j] = A[j-1]; A[j-1] = tmp; } } }}


BubbleSort

• Hvad ved vi om effektivitet af bubbleSort?

• Teori: Køretid for bubbleSort er cn2 (Θ(n2)) for konstant c > 0

• Praksis: Hvordan passer den teoretiske køretid med praksis?

• Er køretiden faktisk Θ(n2) for standard input (f. eks. tilfældige tal)?

• Hvad er konstanten c?

• Er der andre faktorer der har væsentlig betydning for praktisk køretid?


Observer

n tid

10000 0.27

20000 1.40

40000 3.23

80000 12.87

160000 51.38

320000 205.49


-80 0 80 160 240 320 400 480

50

100

150

200

250

300

• Kunne ligne cn2


• Lad T(n) være tid for bubbleSort på tabel af størrelse n.

• Kig på forholdet mellem T(2n) og T(n).

• Hvis T(n) = cn2 har vi:

Fordoblingshypotese

• Hypotese 1 (fordoblingshypothese): T(2n)/T(n) ≈ 4

T (2n)T (n)

=c(2n)2

cn2=

c4n2

cn2= 4


Fordoblingshypotese

n tid T(2n)/T(n)

10000 0.27

20000 1.40 5.18

40000 3.23 2.31

80000 12.87 3.98

160000 51.38 3.99

320000 205.49 4.00

Ser ud til at konvergere mod 4


Forudsigelse og Verifikation

• Forudsigelse: T(640000) = 205.49 ⋅ 4 = 821.96

• Observation: T(640000) = 822.01 !

• Yderligere observationer verificerer fordoblingshypotese.

• Overensstemmelse med hypotese og observationer :-)

n tid T(2n)/T(n)

10000 0.27

20000 1.40 5.18

40000 3.23 2.31

80000 12.87 3.98

160000 51.38 3.99

320000 205.49 4.00


Hvad Med c?

• Hvad nu hvis vi gerne vil finde konstanten c i køretid for cn2 for bubbleSort?

• Metode:

• Plot eksperimentielle målinger og tilpas c for kurve f(n) = cn2.

• Nemmest på dobbeltlogaritmisk skala da cnd bliver ret linie.


1 10 100 1000 10000 100000 1000000 10000000

10

100

1000

Målinger passer med 1/5 ⋅ n2


Hypotese

• Hypotese 2: Køretid for bubbleSort er 1/5⋅n2 .

• Kan ligeledes bruges til forudsigelse af køretider.


Klassifikation af Køretider


Teoretisk vs. Eksperimentiel Analyse

• Eksperimentiel analyse:

• Mål køretider, opstil hypoteser

• Nemt at udføre eksperimenter

• Brugbar til at forudsige opførsel af programmer men ikke forklare

• Teoretisk Analyse:

• Analysere algoritmer for at estimere antal operationer som funktion af input størrelse.

• Kan kræve avanceret matematik

• Brugbar til at forudsige og forklare


Resume

• Teoretisk vs. eksperimentiel analyse

• Den videnskabelige metode

• Bubblesort som eksempel

• Fordoblingshypoteser

• Bestemmelse af konstanter vha. dobbeltlogaritmisk plot


Basale definitioner og anvendelser

3Thursday, March 4, 2010

Uorienterede grafer

• Uorienteret graf. G = (V, E)

• V = knuder (eng. vertex eller node).

• E = kanter mellem par af knuder (eng. edge).

V = { 1, 2, 3, 4, 5, 6, 7, 8 }E = { (1,2), (1,3), (2,3), (2,4), (2,5), (3,5), (3,7), (3,8), (4,5), (5,6), (7,8)}

kant


Uorienterede grafer

• Uorienteret graf. G = (V, E)

• V = knuder (eng. vertex eller node).

• E = kanter mellem par af knuder (eng. edge).

• Parametre for grafens størrelse: n = |V|, m= |E|.

• Grad af knude v = #naboer til v = #kanter incidente til v: deg(v).

V = { 1, 2, 3, 4, 5, 6, 7, 8 }E = { (1,2), (1,3), (2,3), (2,4), (2,5), (3,5), (3,7), (3,8), (4,5), (5,6), (7,8)}n= 8m = 11

naboer

knude med grad 2

knude med grad 1kant


Orienterede grafer

• Orienteret graf. G = (V, E)

• V = knuder.

• E = orienterede kanter mellem par af knuder.

• Parametre for grafens størrelse: n = |V|, m= |E|.

• Udgrad af knude v = antal kanter fra v: deg+(v).

• Indgrad af knude v: antal kanter til v: deg-(v).

V = { 1, 2, 3, 4, 5, 6, 7, 8 }E = { (1,2), (2,3), (3,1), (4,2), (2,5), (5,3), (3,7), (8,3), (4,5), (6,5), (7,8)}n = 8m = 11

6

84

32

71

5


Eksempler på anvendelse af grafer

Graf Knuder Kanter

transport vejkryds veje

transport flyruter lufthavne

kommunikation computere optiske fiberkabler

Internettet hjemmesider links

sociale netværk mennesker forhold

forsyningsnetværk elværk/huse ledninger

madnetværk dyrearter rovdyr-byttedyr

skedulering jobs afhængigheder

kursusemner emner afhængigheder


Transport

• Transportnetværk/vejkort

• Knude: vejkryds

• Kant: veje

3/1/10 10:41 PMkøbenhavn - Google Maps

Adresse København


Internet

• Webgrafen

• Knude: hjemmeside

• Kant: hyperlinkcnn.com

cnnsi.comnovell.comnetscape.com timewarner.com

hbo.com

sorpranos.com


3/1/10 10TouchGraph Google Browser

DisplayToolsViewEdit

Spacing: Zoom: Relaterede hjemmesider

• Netværk: sammenhænge mellem hjemmesider rapporteret af Googles database for relaterede hjemmesider.

• Knude: hjemmeside

• Kant: sammenhæng


Sociale netværk

• Sociale netværk

• Knuder: personer

• Kanter: forhold i mellem personer

Reference: touchgraph.com

3/1/10 10:34 PMGraph Connections

Graph Connections

The graph shows you your friends, the networks they belong to, and the social cliques they are part of. See whois central to a particular group and which friends are connectors between two groups.


Fylogenetiske træer

• Fylogenetiske træer. Beskriver evolution af arter


2105 emner

grafer

træer

binære søgetræer

hægtede lister

hashing

tabeller

binær søgning

BFS/DFS

Dijkstra korteste vej algoritme

køer

stakke

implementation af BFS

implementation af DFS

implementation af GS-algoritmen

implementation af Dijkstra

prioritetskø

hob

orienterede grafer

topologisk sortering


Repræsentation af grafer

Uorienterede grafer



• Incidensmatrix (adjancency matrix). n × n matrice med A[u,v] = 1 hvis (u,v) er en kant.

• Hver kant repræsenteret 2 gange.

• Pladsforbrug: Θ(n2)

• Θ(1) tid for at checke om (u,v) er en kant.

• Θ(n2) tid for at identificere alle kanter.

1 2 3 4 5 6 7 81 0 1 1 0 0 0 0 02 1 0 1 1 1 0 0 03 1 1 0 0 1 0 1 14 0 1 0 0 1 0 0 05 0 1 1 1 0 1 0 06 0 0 0 0 1 0 0 07 0 0 1 0 0 0 0 18 0 0 1 0 0 0 1 0



• Incidensliste (adjancency list). Knudeindekseret tabel af lister.

• Hver kant repræsenteret 2 gange.

• Pladsforbrug: Θ(n + m)

• Θ(deg(u)) tid for at checke om (u,v) er en kant.

• Θ(m+n) tid for at identificere alle kanter.

1 2 3

2

3

4 2

5

6

7 3

8

1

1

2

5

3

3 4

2 5 7

5

8

5

8

3 4 6

7


Stier og sammenhæng

• Sti. Sekvens P af knuder v1, v2,..., vk-1, vk således at (vi, vi+1) ∈ E for alle i=1,...,k-1.

Sti: 1,2,4,5,2




• Simpel sti. Sti hvor hver knude højst forekommer én gang.

Sti: 1,2,4,5,2Simpel sti: 1,3,7,8




• Simpel sti. Sti hvor hver knude højst forekommer én gang.

• Længde af en sti. Antal kanter på stien. (længde af P= v1, v2,..., vk-1, vk er k-1).

• Sammenhængende. En uorienteret graf er sammenhængende hvis der for alle par af knuder u og v findes en sti imellem u og v.

Sti: 1,2,4,5,2Simpel sti: 1,3,7,8


Kredse/cykler

• Kreds (cykel). Sti v1, v2,..., vk-1, vk, hvor v1 = vk og de første k-1 knuder er forskellige.

kreds C = 1-2-4-5-3-1


Egenskab

• For enhver graf G=(V, E) gælder

• Bevis. Hvor mange gange tælles hver kant (u, v) i summen:

• 2 gange. 1 gang for deg(u) og en gang for deg(v).

∑v∈V

deg(v) = 2m


Træer

• Træ. En uorienteret sammenhængende graf der ikke indeholder nogle kredse.

• Sætning. I et træ er ethvert par af knuder forbundet via én unik simpel sti.


Træer


• Sætning. I et træ er ethvert par af knuder forbundet via én unik simpel sti.

• Bevis. Modbevis.

• Antag der er 2 forskellige stier mellem u og v.

• x sidste knude to stier har tilfælles inden de bliver forskellige.

• y første knude de to stier har tilfælles efter de har været forskellige.

• Lad P1 og P2 være de to forskellige stier fra x til y.

• P1 og P2 udgør en kreds.

ux y

vP1

P2


Træer


• Sætning. Et træ har n-1 kanter.


Træer


• Bevis. Induktion.

• n = 1:

• n > 1: Antag det gælder for n’ < n.

• Fjern en kant (u,v) ?

• Brug induktionshypotesen


Træer



• n = 1: Ingen kanter.

• n > 1: Antag det gælder for n’ < n.

• Fjern en kant (u,v) grafen deles i 2 (ødelagt unik sti ml. u og v).

• Brug induktionshypotesen på de to dele:

• m = m1 + m2 + 1 = (n1 -1)+ (n2 -1) +1 = n1 + n2 - 1


Træer


• Egenskaber.

• m = n-1

• Unik simpel sti mellem ethvert par af knuder.

• mindst 2 knuder har grad 1.

• Hvis der tilføjes en kant laves en kreds.

• Hvis der fjernes en kant bliver grafen usammenhængende.


Rodfæstede træer

• Rodfæstet træ. Træ T med en rodknude r, hvor alle kanter er orienteret væk fra roden.

• Vigtighed. Modellerer hierakisk struktur.

et træ samme træ rodfæstet i knude 1


1

2 6

3

4 5

7 8

9

10

Rodfæstede træer

• rod r. Alle kanter orienteret væk fra r.

• For enhver knude v:

• forælder til v. Knude umiddelbart før v på stien fra r til v.

• barn af v. Knude w er barn af v, hvis v er forælder til w.

• forfader til v. Knude før v på stien fra r til v.

• efterkommer af v. w er efterkommer af v, hvis v er forfader til w.

• blad. v er et blad hvis v ikke har nogle efterkommere.


Skov

• Skov. Graf hvor alle sammenhængskomponenter er træer.

1

2 6

3

4 5

7 8

9

10

11

12

13

14

15

16

17


Komplet graf

• Komplet graf. Graf G=(V, E), hvor der er en kant mellem ethvert par af knuder.

• Kn. Den komplette graf med n knuder.

1

2

3 4

5

K5


Opgave

• Modeller følgende problem som en graf.

Du er konsulent for langtursbusfirmaet "Blåhundebusserne" der ønsker at lave en hjemmeside hvor folk kan finde og bestille deres rejse. Man skal kunne søge på den rejse med færrest antal omstigninger (busskift) mellem to valgfrie destinationer. Der er S forskellige stoppesteder/stationer og B forskellige busruter. For hver busrute kender du startsted og destination. En bus stopper ikke undervejs, men kører direkte fra startsted til destination. Du skal ikke tage hensyn til tidspunkt for afgang og ankomst i denne opgave.


Sammenhængskomponenter



• Sammenhængskomponenter. Find alle knuder der kan nås fra s.

• Sammenhængskomponent indeholdende knude 1 = {1, 2, 3, 4, 5, 6, 7, 8}.



• Sætning. For ethvert par af knuder u og v i en graf er deres sammenhængskomponenter enten ens eller disjunkte.

• Bevis.

• Sti mellem u og v samme sammenhængskomponent:

• sti u → w sti v → u→ w

• Ingen sti mellem u og v ingen knude kan være i begge

sammenhængskomponenter.

• sti u → w og sti v → w sti u → w → v.


Udfyldning (Flood fill)

• Farveudfyldning. Skift farve til blå på hele det sammenhængende område med lysegrønne pixels i et billede.

• Knude: pixel

• Kant: nabo pixels med samme farve (her lysegrøn)

• Sammenhængende område: sammenhængskomponent af grønne pixels.

Skift farve til blå


Udfyldning (Flood fill)

• Farveudfyldning. Skift farve til blå på hele det sammenhængende område med lysegrønne pixels i et billede.

• Knude: pixel

• Kant: nabo pixels med samme farve (her lysegrøn)

• Sammenhængende område: sammenhængskomponent af grønne pixels.

Skift farve til blå



• Sammenhængskomponenter. Find alle knuder der kan nås fra s.

• Generel algoritme.

• Korrekthed. Ved terminering er mængden R er lig sammenhængs-komponenten der indeholder s.

• BFS(s) og DFS(s)

• Finder sammenhængskomponenten indeholdende s.

• Besøger/ordner knuderne i R på forskellige måder.

s

u v

R ConnectedComponent(s)

R = {S}while der er en kant (u,v) hvor u ∈ R og v ∉ R

R = R ∪ {v}


Dybde Først Søgning (DFS)

• Intuition. Udforsk ud fra s i én retning. Fortsæt indtil du når til en “blindgyde”. Gå tilbage til sidste knude hvor der var flere uudforskede kanter og fortsæt på samme måde.

• DFS træ. Hvis DFS(v) kaldes i løbet af kaldet til DFS(u) så indeholder DFS træet kanten (u,v).

DFS(u)Sæt Udforsket[u] = truefor alle kanter (u,v) ∈ E

if Udforsket[v] = false then DFS(v)


DFS eksempel

1

2

6

3

4 5

7

8

1

2 3

54

6

7

8

• BFS træ. Hvis DFS(v) kaldes i løbet af kaldet til DFS(u) så indeholder DFS træet kanten (u,v).

• Eksempel. DFS(1)




DFS træer

• Egenskaber ved DFS træer. Lad T være et DFS træ for en graf G.

1. For et givet rekursivt kald DFS(v): alle knuder markeret som udforsket mellem starten og slutningen af dette kald er efterkommere af v i T.

2. Hvis (u,v) ∈ E(G) og (u,v) ∉ E(T): Enten u eller v er en efterkommer af den anden.

• Bevis for at 1 2.

• Antag u opdaget før v.

• Når u opdages kaldes DFS(u)

• v ikke er opdaget Udforsket[v]=false ved starten af kaldet.

• Udforsket[v] = true i løbet af kaldet da der er en kant (u,v).


Sammenhængende delgraf og korteste vej


Sammenhæng og korteste vej

• s-t sammenhængsproblemet. Givet to knuder s og t, er der en sti fra s til t?

• s-t korteste vej problemet. Givet 2 knuder s og t, hvad er længden af den korteste sti fra s til t?

• Anvendelser

• LinkedIn

• færrest antal stop på busrejse.

• færrest antal hop i kommunikationsnetværk.


Korteste vej

• Eksempel. Find korteste vej fra s til alle andre knuder i nedenstående graf.

S

2

6

34

5

7

8

9

1

10


Korteste vej


S

2

6

34

5

7

8

9

1

10

1 1

1

1

2

2

2

2

2

3


Korteste vej


S

2

6

34

5

7

8

9

1

10

1 1

1

1

2

2

2

2

2

3


Bredde Først Søgning (BFS)

• Intuition. Udforsk ud fra s i alle mulige retninger, ét lag knuder ad gangen.

• BFS algoritme.

• L0 = {s}.

• L1 = alle naboer til L0.

• L2 = alle naboer til knuder i L1 der ikke er i L0 eller L1.

• Li+1 = alle naboer til knuder i Li der ikke er i Lj, for j ≤ i.

• Sætning. For ethvert i består Li af alle knuder der har afstand i fra s. Der er en sti fra s til t hvis der findes et i så t ∈ Li.

s L1 L2 L n-1


BFS

• Sætning. For ethvert i består Li af alle knuder der har afstand i fra s. Der er en sti fra s til t hvis der findes et i så t ∈ Li.


• i = 0. L0 = {s}. ✓

• i > 0. Induktionsypotese: gælder for Li-1.

• Li består af knuder der har en nabo i Li-1 og ikke tilhører Li, j < i.

• For v ∈ Li: Sti fra s til u ∈ Li-1 og kant (u,v) v har afstand i til s.


1

2

6

3

4 5

7

8

BFS træ

• BFS træ. Kanten (u,v) er en del af BFS træet hvis knude v “opdages” af algoritmen via en kant fra knude u.

• Eksempel. BFS(1)

1

2

4 5

7

6

8

3


BFS-træ og DFS-træ

• Eksempel. Tegn BFS-træet og DFS-træet når startknuden er S. I DFS besøges knuderne i stigende orden.

S

2

6

34

5

7

8

9

1

10



• Eksempel. Tegn BFS-træet og DFS-træet når startknuden er S. Naboer til en knude besøges i stigende orden.

S

2

6

34

5

7

8

9

1

10



• Eksempel. Tegn BFS-træet og DFS-træet når startknuden er S. Naboer til en knude besøges i stigende orden.

S

2

6

34

5

7

8

9

1

10


BFS

• Egenskab. Lad T være et BFS træ for en graf G og lad (x,y) være en kant i G, således at x ∈ Li og y ∈ Lj. Så er forskellen på i og j højst 1.

• Bevis.

• Antag i ≤ j.

• Lk = {alle knuder i afstand k fra s}

• Korteste vej fra s til x = i korteste vej fra s til y ≤ i+1 y ∈ Li+1

sx y



• Find alle sammenhængskomponenter.

• Start med en knude v og brug BFS eller DFS til at finde dens sammenhængskomponent.

• Find en knude der ikke er besøgt endnu og find dennes sammenhængskomponent vha. BFS eller DFS.

• Fortsæt indtil alle knuder er besøgt.


Check om en graf er todelt (bipartite)

Anvendelse af BFS


Todelte grafer (bipartite graphs)

• Todelt graf: en uorienteret graf er todelt <=> knuderne kan farves røde eller blå således at alle kanter har et rødt endepunkt og et blåt endepunkt.

• Anvendelser.

• stabil matching: mænd = røde, kvinder = blå.

• skedulering: maskiner = røde, jobs = blå.


Test af todelthed (bipartiteness)

• Test af todelthed. Er en givet graf G todelt?

• Mange grafproblemer bliver

• nemmere hvis den underliggende graf er todelt

• mulige at løse effektivt

v2

v1

v4

v3

v5

v6

v7

v2 v3

v6 v5

v7

v4

v1

G

Er G todelt?


Obstruktion af todelthed

• Lemma. Graf G er todelt <=> G indeholder ingen kreds af ulige længde

• Bevis. Ikke muligt at 2-farve den ulige kreds.

todelt (kan 2-farves)

ikke todelt(kan ikke 2-farves)


Test af todelthed vha BFS

• Lemma. Lad G være en sammenhængende graf, og lad L0, L1,......, Lk være lagene produceret af BFS startende i knude s. Præcis én af følgende holder:

1. Ingen kant fra G forbinder 2 knuder i samme lag => G er todelt.

2.En kant forbinder 2 knuder i samme lag => G indeholder en ulige kreds => G ikke todelt.

tilfælde 1

L1 L2 L3






tilfælde 1

L1 L2 L3






tilfælde 1

L1 L2 L3

tilfælde 2

L1 L2 L3






tilfælde 2tilfælde 1

L1 L2 L3 L1 L2 L3


Opsummering

• Grafer. Definition, repræsentation af grafer (incidensliste/matrix), eksempler på anvendelser.

• Træer. Definition, egenskaber.

• BFS/DFS. Algoritmer til gennemløb af grafer. BFS(s) finder korteste sti fra s.

• Sammenhængskomponenter. Definition, findes vha. BFS/DFS.

• Todelte grafer. Kan checke om en graf er todelt cha BFS.


Hjemmeopgave 2

• Test.

• Gentag testene flere gange for samme størrelse input og brug gennemsnittet.

• Lav dem på store input (hvis det kun tager 10 ms er usikkerheden for stor).

• Regler.

• Læs samarbejdspolitikken!

• Kopiering fra internettet ikke tilladt!


1

2

6

3

4 5

7

8

BFS træ


1

2

6

3

4 5

7

8

BFS træ



1

2

6

3

4 5

7

8

BFS træ



1 1

2

6

3

4 5

7

8

BFS træ



1

2

1

2

6

3

4 5

7

8

BFS træ



1

2 3

1

2

6

3

4 5

7

8

BFS træ



1

2

4

3

1

2

6

3

4 5

7

8

BFS træ



1

2

4 5

3

1

2

6

3

4 5

7

8

BFS træ



1

2

4 5

7

3

1

2

6

3

4 5

7

8

BFS træ



1

2

4 5

7

8

3

1

2

6

3

4 5

7

8

BFS træ



1

2

4 5

7

6

8

3

DFS eksempel

1

2

6

3

4 5

7

8





DFS eksempel

1

2

6

3

4 5

7

8

1





DFS eksempel

1

2

6

3

4 5

7

8

1

2





DFS eksempel

1

2

6

3

4 5

7

8

1

2 3





DFS eksempel

1

2

6

3

4 5

7

8

1

2 3

5





DFS eksempel

1

2

6

3

4 5

7

8

1

2 3

54





DFS eksempel

1

2

6

3

4 5

7

8

1

2 3

54

6





DFS eksempel

1

2

6

3

4 5

7

8

1

2 3

54

6

7





DFS eksempel

1

2

6

3

4 5

7

8

1

2 3

54

6

7

8





Stakke og køer

Implementation af BFS og DFS


Dagens læringsmål

• Efter denne forelæsning vil du være i stand til at

• Forklare datastrukturerne stak og kø og kunne forklare forskellen.

• Anvende en hægtet liste til at implementere køer og stakke, samt analysere asymptotisk pladsforbrug og køretid af denne implementation.

• Anvende en tabel til at implementere køer og stakke, samt analysere asymptotisk pladsforbrug og køretid af denne implementation.

• Sammenligne og analysere forskellige implementationer af køer og stakke.

• Kunne anvende stakke og køer.

• Anvende en passende datastruktur til effektiv implementation af BFS/DFS, same analysere køretiden.

• Pensum. KT side 89-94.




Bredde Først Søgning (BFS)

• Intuition. Udforsk ud fra s i alle mulige retninger, ét lag knuder ad gangen.

• BFS algoritme.

• L0 = {s}.

• L1 = alle naboer til L0.

• L2 = alle naboer til knuder i L1 der ikke er i L0 eller L1.

• Li+1 = alle naboer til knuder i Li der ikke er i Lj, for j ≤ i.

• Implementation.

• Konstruer alle lister.

• Én liste: Behandle knuderne i den rækkefølge vi møder dem.

s L1 L2 L n-1


Dybde Først Søgning (DFS)

• Intuition. Udforsk ud fra s i én retning. Fortsæt indtil du når til en “blindgyde”. Gå tilbage til sidste knude hvor der var flere uudforskede kanter og fortsæt på samme måde.

• Implementation.

• Rekursivt.

• Iterativt: Én liste af knuder. Behandle sidst mødte knude først.

DFS(s)Sæt Udforsket[s] = truefor alle kanter (s,v) ∈ E




• BFS

• Konstruere alle listerne Li

• Behandle knuderne i samme rækkefølge som vi møder dem

• DFS

• rekursivt

• Behandle den knude vi sidst har mødt, men ikke behandlet endnu

• Hvilke datastrukturer skal vi bruge til at holde styr på knuderne?


Stakke og køer

• Fundamentale datastrukturer

• Værdier: mængde af objecter.

• Operationer: indsæt, slet, check om tom.

• Stak. Fjern det element der er tilføjet sidst.

• Analogi. Bakker i en kantine.

• Kø. Fjern det element der blev tilføjet først.

• Analogi. Kø ved kassen i en butik.

LIFO= “last in first out”

FIFO= “first in first out”

push

pop

dequeueenqueue


Stakke


Stakke

• push(S,x). Indsæt et nyt element x i S.

• pop(S). Fjern og returner det sidst tilføjede element i S.

• isEmpty(). Returner true hvis S er tom.


Stak: Implementation med hægtet liste

• Enkelthægtet liste S.

• S har pointer “S.first” til første element.

• Hvert element e har en pointer “e.next” til næste element.

isEmpty(S) {if S.first = null

return trueelse

return false}

push(S, x) {oldfirst = S.firstS.first = xS.first.next = oldfirst

}

pop(S) {x = S.firstif (S.first != null)

S.first = S.first.nextreturn x

}


Stak: Implementation med hægtet lister

• Køretid. push, pop og is Empty tager konstant tid.

• Pladsforbrug. Proportional til antal elementer på stakken: Θ(n).

isEmpty(S) {if S.first = null

return trueelse

return false}

pop(S) {x = S.firstif (S.first != null)

S.first = S.first.nextreturn x

}

push(S, x) {oldfirst = S.firstS.first = xS.first.next = oldfirst

}


Stak: Implementation med tabel

• Implementation af stak S med tabel.

• Tabel S af længde N.

• Parameter top(S) der angiver indeks for sidste indsatte element.

• Implementerer stak med højst N elementer.

isEmpty(S) {if top[S] = 0

return trueelse

return false}

push(S, x) {if (top(S) = length[S])

then error “overflow”else

top(S) = top(S)+1S[top(S)] = x;

}

pop(S) {if (isEmpty(S))

then error “underflow”else

top[S] = top[S]-1return S[top(S)+1]

}

14 2 3

top[S]=3

14 2 3 5

top[S]=4

14 2 3

top[S]=3

push(S,5) pop(S)


Stak: Implementation med tabel

• Køretid. push, pop og isEmpty tager konstant tid.

• Pladsforbrug. Proportionel til længden af tabellen: Θ(N).

• Minus. Skal kende den maximale størrelse fra start.

isEmpty(S) {if top[S] = 0

return trueelse

return false}

push(S, x) {if (top(S) = length[S])

then error “overflow”else

top(S) = top(S)+1S[top(S)] = x;

}

pop(S) {if (isEmpty(S))

then error “underflow”else top[S] = top[S]-1return S[top(S)+1]

}

14 2 3

top[S]=3

14 2 3 5

top[S]=4

14 2 3

top[S]=3

push(S,5) pop(S)


DFS implementation med stak

DFS(s)Sæt Udforsket[v] = false for alle v.Initialiser S til at være en tom stak.push(S,s)while !isEmpty(S)

u = pop(S)if Udforsket[u] = false

then Udforsket[u] = truefor alle kanter (u,v) incidente til u

push(S,v)


DFS eksempel

1

2

6

3

4 5

7

8

1

2 3

54

6

7

8

• DFS(1)

1

2

6

3

4 5

7

8

1

2 3

54

6

7

8

incidensliste i stigende orden incidensliste i faldende orden


DFS implementation med stak: Analyse

• Køretid. O(n+m)

• pop(S), push(S,v), isEmpty(S), Udforsket[v] =?:

• Hvor mange gange kan en knude u puttes på stakken?

• Tid for at gennemløbe alle incidente kanter til en knude u:

• Samlet tid: DFS(s)Sæt Udforsket[v] = false for alle vInitialiser S til at være en tom stak.push(S,s)while !isEmpty(S)

u = pop(S)if Udforsket[u] = false

then Udforsket[u] = truefor alle kanter (u,v) incidente til u

push(S,v)

O(1)

én gang for hver incidente kant: deg(u).

O(deg(u)) tid hvis vi bruger incidenslister

∑u deg(u) = 2m.


Køer


Køer

• enqueue(K,x). Indsæt et nyt element x i K.

• dequeue(K). Fjern og returner det tidligst tilføjede af elementerne i K.

• isEmpty(K). Returner true hvis K er tom.


Kø: Implementation med hægtet lister

• Enkelthægtet liste K.

• K har pointere “K.first” og “K.last” til første og sidste element.

• Hvert element e har en pointer “e.next” til næste element.

isEmpty(K) {if K.first = null

return trueelse

return false}

enqueue(K, x) {oldlast = K.lastK.last = xK.last.next = nullif (K.first = null)

K.first = K.lastelse

oldlast.next = K.last}

dequeue(K) {x = K.firstif (K.first != null)

K.first = K.first.nextelse

K.last = null;return x

}


Kø: Implementation med hægtet lister

• Køretid. enqueue, dequeue og isEmpty tager konstant tid.

• Pladsforbrug. Proportional til antal elementer i køen: Θ(n)

isEmpty(K) {if K.first = null

return trueelse

return false}

enqueue(K, x) {oldlast = K.lastK.last = xK.last.next = nullif (K.first = null)

K.first = K.lastelse

oldlast.next = K.last}

dequeue(K) {x = K.firstif (K.first != null)

K.first = K.first.nextelse

K.last = null;return x

}


Kø: Implementation med tabel

• Implementation af kø K med tabel.

• Tabel K af længde N.

• Parametre head(K) og tail(K) der angiver indeks for tidligst indsatte og senest indsatte element i K.

• Parameter count(K) der angiver antal elementer i K.

dequeue(K) dequeue(K)

dequeue(K)enqueue(K,9)enqueue(K,4)

14 2 3 7

head(K) tail(K)

count(K)=4

14 2 3 7

head(K) tail(K)

count(K)=3

14 2 3 7

head(K) tail(K)

count(K)=2

14 2 3 7 4

head(K) tail(K)

count(K)=39 2 3 7 4

head(K)tail(K)

count(K)=49 2 3 7 4

head(K)tail(K)

count(K)=3



• Implementation af kø K med tabel.

• Tabel K af længde N.

• Parametre head(K) og tail(K) der angiver indeks for tidligst indsatte og senest indsatte element i S.

• Parameter count(K) der angiver antal elementer i K.

• Implementerer kø med højst N elementer.

isEmpty(S) {if count(S) = 0

return trueelse

return false}

enqueue(K, x) {if count > length[K]

then error “overflow”if tail(K)= length[K]

then tail(K) = 1else tail(K) = tail(K) +1

S[tail(K)] = xcount(S) = count(S)+1

}

dequeue(K) {if (isEmpty(K))

then error “underflow”x = K[head(K)]count(S) = count(S)-1if head(K) = length[K]

then head(K) = 1else head(K) = head(K)+1

return x}



• Køretid. enqueue, dequeue og isEmpty tager konstant tid.

• Pladsforbrug. Proportionel til længden af tabellen: Θ(N).

• Minus. Skal kende den maximale størrelse fra start.

isEmpty(S) {if count(S) = 0

return trueelse

return false}

enqueue(K, x) {if count > length[K]

then error “overflow”if tail(K)= length[K]

then tail(K) = 1else tail(K) = tail(K) +1

S[tail(K)] = xcount(S) = count(S)+1

}

dequeue(K) {if (isEmpty(K))

then error “underflow”x = K[head(K)]count(S) = count(S)-1if head(K) = length[K]

then head(K) = 1else head(K) = head(K)+1

return x}


BFS implementation

BFS(s)Sæt Opdaget[s] = true og Opdaget[v] = false for alle v ≠ sInitialiser en tom kø Kenqueue(K,s)while !isEmpty(K)

u = dequeue(K)for alle kanter (u,v) incidente til u

if Opdaget[v] = falsethen

Opdaget[v] = trueenqueue(K,v)


BFS implementation: Analyse

• Køretid. O(n+m)

• dequeue(K), enqueue(K,v), isEmpty(K), Opdaget[v] =?:

• Hvor mange gange kan en knude u lægges i køen?

• Tid for at gennemløbe alle incidente kanter til en knude u:

• Samlet tid: BFS(s)Sæt Opdaget[s] = true og Opdaget[v] = false for alle v ≠ sInitialiser en tom kø Kenqueue(K,s)while !isEmpty(K)

u = dequeue(K)for alle kanter (u,v) incidente til u

if Opdaget[v] = falsethen

Opdaget[v] = trueenqueue(K,v)

O(1)

én gang

O(deg(u)) tid hvis vi bruger incidenslister

∑u deg(u) = 2m.


Implementation af stakke

Sammenligning af implementation med tabel og hægtet liste



• Hægtet liste.

• push/pop/isEmpty: O(1)

• pladsforbrug: Θ(n)

• Tabel.

• push/pop/isEmpty: O(1)

• pladsforbrug: Θ(N)

hvor n er antal elementer i stakken og N er størrelsen af tabellen (n ≤ N).



• Hægtet liste.

• push/pop/isEmpty tager konstant tid.

• bruger ekstra plads og tid til referencer/pointere.

• Tabel.

• push/pop/isEmpty tager konstant tid.

• maximale kapacitet skal sættes fra start af

• Implementation med tabel af varierende størrelse???


Stak: dynamisk tabel implementation

• Problem. Skal angive størrelse af tabellen fra start.

• Spørgsmål. Hvordan kan vi lade tabellen vokse og skrumpe?

• Første forsøg.

• push(S,x): Øg størrelsen af s[] med én.

• pop(S): Mindsk størrelsen af s[] med én.

• For dyrt.

• Skal kopiere alle elementer over i en ny tabel hver gang.

• Indsættelse af N elementer tager tid proportionelt med: 1 + 2 + ······ + n = Θ(n2).

• Mål. Sikre at ændring af tabelstørrelsen ikke sker for tit.



• Fordobling. Hvis tabellen er fuld kopieres elementerne over i en ny tabel af dobbelt størrelse.

• Konsekvens. Indsættelse af n elementer tager O(n) tid i alt:

1 + 2 + 4 + 8 + ···· + n/2 + n ~ 2n



• Halvering. Hvis tabellen er kvart fuld kopieres elementerne over i en ny tabel af halv størrelse.

• Konsekvens. Tabellen er altid mellem 25% og 100% fuld.



• Effektiv løsning.

• push: fordobl størrelsen når tabellen er fuld

• pop: halver størrelsen når tabellen er 1/4 fuld.

• Tid og plads.

• Pladsforbrug. Tabellen altid 25-100% fuld: Θ(n)

• Tidsforbrug. push/pop tager worst case amortiseret O(1) tid (dvs. n operationer tager O(n) tid i alt).


Stak: Implementation med hægtet lister i Java

public class StackofStrings {private Node first = null;

private class Node {String item;Node next;

}

public boolean isEmpty() {return first == null;

}

public void push(String item) {Node oldfirst = first;first = new Node();first.item = item;first.next = oldfirst;

}

public String pop() {if (isEmpty()) throw new RuntimeException();String item = first.item;first = first.next;return item;

}}


Stak: Implementation med tabel i Javapublic class StackofStrings {

private String[] s;private int top = 0;

public StackofStrings(int capacity) {s = new String[capacity];

}

public boolean isEmpty() {return top == 0;

}

public void push(String item) {if (top == s.length) resize(2 * s.length); s[top++] = item;

}

public String pop() {String item = s[--top];s[top] = null;if (top > 0 && top == s.length/4) resize(s.length/2);return item;

}

public void resize(int capacity) {String[] dup = new String[capacity];for (int i = 0; i < top; i++)

dup[i] = s[i];s = dup;

}}


Implementation af stakke: pladsforbrug i Java

• Hægtet liste. ~ 16N bytes.

• Tabel med fordobling/halvering. Mellem ~4N (100% fuld) of ~16N (25% fuld) bytes.

• Obs. Analysen inkluderer ikke pladsforbruget for indholdet af elementerne (items).

private class Node {String item;Node next;

}

public class DoublingStackofStrings {private String[] s;private int top = 0;

8 bytes overhead for object4 bytes4 bytes--------------------------------16 bytes

4 bytes × størrelse af tabel4 bytes


Opsummering

• Stakke

• LIFO: Last in first out.

• Implementeres med hægtet liste eller tabel. Alle operationer O(1) tid.

• Køer

• FIFO: First in first out.

• Implementeres med hægtet liste eller tabel. Alle operationer O(1) tid.

• BFS

• Køretid O(m+n) hvis der bruges incidenslister.

• Implementeres med kø eller med liste for alle L

• DFS

• Køretid O(m+n) hvis der bruges incidenslister.

• Implementeres rekursivt eller med stak.

• OBS. Fordoblingsteknikken er ikke pensum.


25

BFS: eksempel

A B

F

I

E H

DC

G

FIFO Kø

-

start

26

A B

F

I

E H

DC

G

A

FIFO Kø

-

startenqueue start knude

BFS: eksempel

27

A B

F

I

E H

DC

G

A

FIFO Kø

-

Startdequeue næste knude

BFS: eksempel

28

startBesøg A’s naboer

A B

F

I

E H

DC

G

-

FIFO Kø

BFS: eksempel

29


A B

F

I

E H

DC

G

-

FIFO Kø

BFS: eksempel

29


A B

F

I

E H

DC

G

-

FIFO Kø

BFS: eksempel

30

BstartB opdaget

A B

F

I

E H

DC

G

- A

FIFO kø

BFS: eksempel

31

B startBesøg A’s naboer

A

F

I

E H

DC

G

-

B

A

FIFO Kø

BFS: eksempel

31

B startBesøg A’s naboer

A

F

I

E H

DC

G

-

B

A

FIFO Kø

BFS: eksempel

32

B I startI opdaget

A

F

I

E H

DC

G

-

B

A

A

FIFO Kø

BFS: eksempel

33

B I startfærdig med A

A

F

I

E H

DC

G

-

B

A

A

FIFO Kø

BFS: eksempel

34

B I start

A

F

I

E H

DC

G

-

B

A

A

dequeue næste knude

FIFO Kø

BFS: eksempel

35

I start

A

F

I

E H

DC

G

-

B

A

A

Besøg B’s naboer

FIFO Kø

BFS: eksempel

36

I start

A

F

I

E H

DC

G

-

B

A

A

Besøg B’s naboer

FIFO Kø

BFS: eksempel

36

I start

A

F

I

E H

DC

G

-

B

A

A

Besøg B’s naboer

FIFO Kø

BFS: eksempel

37

I F start

A

F

I

E H

DC

G

-

B

A

A

F opdaget

B

FIFO Kø

BFS: eksempel

38

I F start

A

F

I

E H

DC

G

-

B

A

A

Besøg B’s naboer

B

FIFO Kø

BFS: eksempel

38

I F start

A

F

I

E H

DC

G

-

B

A

A

Besøg B’s naboer

B

FIFO Kø

BFS: eksempel

39

I F start

A

F

I

E H

DC

G

-

B

A

A

A allerede opdaget

B

FIFO Kø

BFS: eksempel

40

I F start

A

F

I

E H

DC

G

-

B

A

A

færdig med B

B

FIFO Kø

BFS: eksempel

41

I F start

A

F

I

E H

DC

G

-

B

A

A


B

FIFO Kø

BFS: eksempel

42

F start

A

F

I

E H

DC

G

-

B

A

A

Besøg I’s naboer

B

FIFO Kø

BFS: eksempel

43

F start

A

F

I

E H

DC

G

-

B

A

A

Besøg I’s naboer

B

FIFO Kø

BFS: eksempel

43

F start

A

F

I

E H

DC

G

-

B

A

A

Besøg I’s naboer

B

FIFO Kø

BFS: eksempel

44

F start

A

F

I

E H

DC

G

-

B

A

A

A allerede opdaget

B

FIFO Kø

BFS: eksempel

45

F start

A

F

I

E H

DC

G

-

B

A

A

Besøg I’s naboer

B

FIFO Kø

BFS: eksempel

45

F start

A

F

I

E H

DC

G

-

B

A

A

Besøg I’s naboer

B

FIFO Kø

BFS: eksempel

46

F E start

A

F

I

E H

DC

G

-

B

A

A

E opdaget

BI

FIFO Kø

BFS: eksempel

47

F E start

A

F

I

E H

DC

G

-

B

A

A

Besøg I’s naboer

BI

FIFO Kø

BFS: eksempel

47

F E start

A

F

I

E H

DC

G

-

B

A

A

Besøg I’s naboer

BI

FIFO Kø

BFS: eksempel

48

F E start

A

F

I

E H

DC

G

-

B

A

A

F allerede opdaget

BI

FIFO Kø

BFS: eksempel

49

F E start

A

F

I

E H

DC

G

-

B

A

A

I færdig

BI

FIFO Kø

BFS: eksempel

50

F E start

A

F

I

E H

DC

G

-

B

A

A


BI

FIFO Kø

BFS: eksempel

51

E start

A

F

I

E H

DC

G

-

B

A

A

Besøg F’s naboer

BI

FIFO Kø

BFS: eksempel

51

E start

A

F

I

E H

DC

G

-

B

A

A

Besøg F’s naboer

BI

FIFO Kø

BFS: eksempel

lectures1st half

Travel