Algorithms and Architectures I Rasmus Løvenstein Olsen (RLO), Jimmy Jessen Nielsen (JJE) Mm1: Introduction to analysis and design of algorithms - October 7, 2008
Algorithms and Architectures II 1. Introduction to analysis and design of algorithms (RLO) 2. Recursive algorithms and recurrences (RLO) 3. More about recurrences (RLO) 4. Greedy algorithms, backtracking and more recurrences(rlo) 5. Counting, probabilities and randomized algorithms (RLO) 6. More sorting algorithms: Heap sort and quick sort (RLO) 7. A little bit more about sorting - and more times for exercises (RLO) 8. Hash tables, Hashing and binary search trees (RLO) 9. Binary search trees, red-black trees (JJE) 10. Red-black trees continued + string matching (JJE)
Dagsorden Introduktion og formål med kursus Introduktion til algoritmer Eksempler Fra problem til algoritme Analyse af algoritmers korrekthed Metode Eksempler Insert sorterings algoritme Merge algoritme Metoder til analyse af algoritmer Notationer Kompleksitet Opsummering og konklusion Opgaver
Formål og mål med kursus (taget fra studieordningen) Kursets formål er at understøtte den studerende i at: Forstå og anvende fundamentale algoritmer til organisation af og beregninger på data. Analysere og konstruere hensigtsmæssige repræsentationer af og beregninger på data. Den studerende skal ved den afsluttende prøve kunne: Anvende begreber, teorier og metoder til at analysere og designe algoritmer. Dokumentere forståelse for simple og sammensatte datastrukturer og deres anvendelser. Dokumentere forståelse for algoritmers og datastrukturers effektivitet, og anvende denne forståelse i forbindelse med konstruktion og analyse af algoritmer og datastrukturer. Redegøre for de overvejelser, der er forbundet med at implementere datastrukturer og algoritmer i praksis Benytte korrekt fagterminologi
Kursets indhold Kurset indeholder følgende elementer: Analyse og design af algoritmer Talrepræsentation: Præcision og dynamikområde Regneoperationer Matematisk rutine bibliotek Effektivitet (fejl, køretid, lagerforbrug) Datarepræsentation: Simple og sammensatte datastrukturer (arrays, records, lister) Operationer (søgning, indsættelse, sletning) Effektivitet (hyppighed, alternativer)
Dagsorden Introduktion og formål med kursus Introduktion til algoritmer Eksempler Fra problem til algoritme Analyse af algoritmers korrekthed Metode Eksempler Insert sorterings algoritme Merge algoritme Metoder til analyse af algoritmer Notationer Kompleksitet Opsummering og konklusion Opgaver
Hvad er algoritmer Ordet algoritmer stammer fra den persiske matematiker fra det 9. århundrede: Abu Abdullah Muhammed ibn Musa al-khwarizmi Algoritmer findes overalt i dagligdagen, f.eks. for lyspærer De tidligst kendte algoritmer blev lavet af Babylonerne omkring år 1600 BC til faktorisering af tal og uddragelse af kvadratrødder Et spørgsmål: Hvorfor skal vi studere algoritmer når vi nu har super hurtige computere, der kværner tal en zillion gange hurtigere end vi selv gør? Lamp does not work Lamp plugged In? Bulp burned Out? Buy new lamp Plug in lamp Replace bulp
Et spørgsmål om computer kraft? Lommeregner Desktop Mainframe Distribuerede computere Nogle problemer er mere komplekse end andre. Tænk bare på f.eks. Skak og alle de kombinationsmuligheder der findes, valg af næste træk Søgning og organisering af data på Internettet, data baser, billet systemer osv. Rutning af data over store netværk (evt. ad-hoc) Planlægning af kabel nedgravning for fiber udlægning
En analogi til kompleksitet Fire rejsende med forskellige transportmidler L rejser x meter på x tid P rejser x^2 meter på x tid E rejser e^x meters på x tid F rejser x! meters på x tid hver tager en lille tur.
En analogi til kompleksitet #2 Så de starter hver deres rejse Når L har taget 18 skridt, har E næsten nået sin anden gang rundt om jorden og F vil have været nået til Månen og tilbage igen næsten 500.000 gange L linear P polynomial E exponential F - factorial E vil have taget 12 ture rundt om jorden før L har taget 20 skridt
En analogi til kompleksitet #3 Fortsat Eller hvad med F har taget Solen-Jorden tur/retur ca. 5*10^127 gange mens L stadig mangler 10 meter på 100 m banen? L linear P polynomial E exponential F - factorial Konklusion: Kompleksitet betyder virkelig noget! Overvej hvad i sætter maskinen igang med at lave!
Klassifikation af algoritmer efter design metode Del og hersk Nedbrydning af problem til mindre problemer der er lettere at løse Dynamisk programming Genanvendelse af tidligere opnåede resultater Ligner Del-og-hersk men er typisk hurtigere i udførsel pga. genanvendelse af resultater Lineær programming Løsning af lineære uligheder, eks. Ax<b Grådige algoritmer Valg af umiddelbart mest optimal løsning til et givet delproblem Giver ikke nødvendigvis bedste resultat, men typisk et ret godt resultat Reduktion Inkludere problem transformering til et kendt og mindre kompleks løsning Søg og nummerering Til problemer der kan løses som grafer, f.eks. Skak eller kryds og bolle Probabilistiske and heuristiske algoritmer Algoritmer der er baseret på tilfældigheder, f.eks. genetiske algoritmer
Klassifikation af algoritmer efter implementationsmetode Rekursion eller iteration Algoritmer der baserer sig på gentagne kald af sig selv Typisk del-og-hersk type algoritme Logiske Anvendelse af logiske aksiomer der leder til kontrollerede, logiske udledninger baseret på input Serielle, parallelle eller distribuerede Serielle algoritmer kræver instruktioner udført en ad gangen Parallelle algoritmer kan dele sine opgaver op i mindre delopgaver (f.eks. del-og-hersk) Distribuerede algoritmer, arbejder ikke bare på en enkelt maskine, men over et helt netværk Deterministiske eller non-deterministiske Deterministiske algoritmer baserer sine beslutninger på et deterministik grundlag Non-deterministiske algoritmer baserer ikke altid sine beslutninger på et deterministisk grundlag, f.eks. probabilistiske algoritmer Præcise eller upræcise Nogen algoritmer (præcise) leverer et eksakt resultat, mens andre algoritmer leverer et næsten, eller ret godt resultat.
Fra problem til algoritme hvad kræves der? Hvad er problemet? Hvordan beskriver vi en løsning, der utvetydigt kan forstås af alle? Samling af Ikea møbler Olie kontrol på bilen Madlavning Sortering af og søgning i millioner af data elementer En computer er ikke indforstået med ret mange ting! Den er DUM! Nogle vigtige krav til algoritmer Korrekthed (skal kunne løse problemet tilfredsstillende præcist) Effektivitet (skal kunne løse problemet indenfor given tids/ressource rammer) Let forståelige og vedligeholdelsesvenlig (andre skal også kunne forstå algoritmen og evt. lave opdateringer) Genbrugelighed og generalitet (må gerne kunne genbruges i andre sammenhæng)
Dagsorden Introduktion og formål med kursus Introduktion til algoritmer Eksempler Fra problem til algoritme Analyse af algoritmers korrekthed Metode Eksempler Insert sorterings algoritme Merge algoritme Metoder til analyse af algoritmer Notationer Kompleksitet Opsummering og konklusion Opgaver
Loop invarianter I familie med matematisk induktion Beskriver egenskaber for variable, og skal leve op til tre egenskaber Initialisering: Skal være sand før første iteration i et loop Vedligheholdelse: Hvis den er sand før loopet, er den også sand efter Slutning: Når loopet afsluttes, skal invarianten have et brugbart egenskab der hjælper med at afgøre hvornår algoritmen sluttes
Insertion sort algoritme Et problem simpelt nok til at starte med
Insertion sort algoritmen grafisk representation 5 2 4 6 1 3 2 5 4 6 1 3 2 4 5 6 1 3 2 4 5 6 1 3 1 2 4 5 6 3 1 2 3 4 5 6
Insertion sort algoritmen pseudo kode - reminder Insertion - sort(a) 1 for j=2 to length(a) 2 do key=a[j] 3 insert A[j] into sorted sequence A[1..j-1] 4 i=j-1 5 while i>0 and A[i]>key 6 do A[i+1]=A[i] 7 i=i-1 8 A[i+1]=key Loop Invariant: I starten af for loopet, indeholder A[1..j-1] de originale elementer i A[1..j-1] men i ordnet rækkefølge!
Bevis for loop invariant i insert-sort algoritmen 1. Initialisering: Første iteration, j=2 -> A[1..j-1] kun indeholder A[1] Denne er sorteret og dermed holder punkt 1 i loop invariant kravet 2. Vedligeholdelse: For hvert j, skal A[1..j-1] være ordnet ved start af loop, og A[i..j-1] skal være ordnet ved slut af loop (ikke nødvendigvis samme orden, men stadig i en orden) Det kræver at den indre while loop overholder samme invarians, hvormed samme type analyse bør udføres for dette loop 3. Slutning: Hvad sker der når det ydre loop når j>n? Sæt j=n+1, og indsæt i array A[1..n+1-1] = A[1..n] (hele det originale array) Pga. 2. med j=n+1 er vi sikker på at arrayet er sorteret ved slutning! Konklusion: Algoritmen virker efter hensigten
Merge algoritmen - antagelser og parametre Formål med algoritmen er Umiddelbart: At samle et delvist sorteret array A På længere sigt: At fungere i en rekursiv sorteringsalgoritme Parametrene p, q og r angiver steder i et array A[1..N], hvormed algoritmen skal arbejde p: startangivelse q: midterpunkt r: stopangivelse Algoritmen antager at arrayet A er delvist sorteret A[p.. q] er sorteret A[q+1.. r] er sorteret
Merge algoritmen grafisk representation p q r 2 4 5 7 1 2 3 6 L 2 4 5 7 1 2 3 6 R 1 4 5 7 1 2 3 6 8 8 1 2 5 7 1 2 3 6 L 2 4 5 7 8 1 2 3 6 8 R L 2 4 5 7 8 1 2 3 6 8 R 1 2 2 7 1 2 3 6 L 2 4 5 7 8 1 2 3 6 8 R
Merge algoritmen Merge(A, p, q, r) 1 n1 = q-p+1 10 i=1 2 n2 = r-q 11 j=1 3 Make arrays L[1..n1+1], R[1..n2+1] 12 for k = p to r 4 for i = 1 to n1 13 do if L[i] R[j] 5 do L[i] = A[p+i-1] 14 then A[k] = L[i] 6 for j = 1 to n2 15 i = i+1 7 do R[j] = A[q+j] 16 else A[k] = R[j] 8 L[n1+1] = Inf 17 j=j+1 9 R[n2+1] = Inf p: start af array q: midterpunkt i array r: slut af array
Loop invariant for merge algoritme Nu definerer vi loop invarianten som I starten af loopet ved linje 10, indeholder delarrayet A[p..k-1] k-p mindste elementer af L[1..n1+1] og R[1..n2+1] i ordnet rækkefølge. Derudover, er L[i] og R[j] de mindste elementer i de respektive arrays der endnu ikke er kopieret over i A[]. Så skal vi igen til at vise 1. Loop invarianten holder før den første iteration 2. Hver iteration holder invarianten 3. Invarianten leder til et brugbart egenskab der afgører algoritmens afslutning
Bevis for korrekthed af algoritme Initialisering: I starten af loopet har vi k = p, så A[p..k-1] er tomt, dvs. længden af A er givet som p-k = 0 Derudover, er i = j = 1, medførende at L[i] og R[j] er de mindste i arrayene L og R Vedligeholdelse: Antag L[i] R[j] så er L[i] det mindste element der skal kopieres til A. Fordi A[p..k-1] indeholder de k-p mindste elementer, vil A[p..k] efter at have kopieret L[i] ind i A[k] indeholde de k-p+1 mindste elementer. Antag L[i] > R[j] så med samme argument blot med R[j] i stedet for, overholdes loop invarianten. Linjerne 14-17 (if-then-else sætningen) sikrer de to ovenstående tilfælde
Bevis for korrekthed af algoritme #2 Slutning: Ved afslutning er k = r +1, dvs. arrayet A[p.. k-1(=r)] indeholder nu k p = r p + 1 mindste elementer af L[1..n1+1] og R[1..n2+1] i sorteret rækkefølge L og R indeholder samlet n1+n2+2=r-p+3 elementer Alle elementer undtage de største, nemlig er blevet kopieret ind i A. De to sidste elementer,, bruges til indikation af hvornår algoritmen er slut
Dagsorden Introduktion og formål med kursus Introduktion til algoritmer Eksempler Fra problem til algoritme Analyse af algoritmers korrekthed Metode Eksempler Insert sorterings algoritme Merge algoritme Metoder til analyse af algoritmer Notationer Kompleksitet Opsummering og konklusion Opgaver
Vurderinger af algoritme kompleksitet Tre forskellige vurderinger af algoritmer Værste tilfælde Det kan i hvert fald ikke blive værre en det Sker for nogle algoritmer ofte, f.eks. Søgealgoritmer i databaser når data ikke findes Bedste tilfælde Det kan ikke blive bedre end det her Gennemsnitlig tilfælde Et billede af typiske tilfælde Minder ofte om værste tilfælde mere end bedste tilfælde
Den store O notation (the big-o) O(g(n)): angiver en asymptotisk øvre grænse for kompleksiteten Ω(g(n)): angiver en asymptotisk nedre grænse for kompleksiteten Θ(g(n)): indikere en øvre og nedre grænse, hvor g(n) er den asymptotiske tætte grænse
Udspecificerede notation og definition Θ(g(n)) = { f(n): there exist positive constants c 1, c 2 and n 0 such that 0 c 1 g(n) f(n) c 2 g(n) for all n n 0 } Eksempler på tavlen O(g(n)) = {f(n): there exist positive constants c and n 0, such that 0 f(n) cg(n) for all n n 0 } Hvis en funktion tilhører Θ(g(n)), så tilhører den også automatisk O(g(n)) I meget andet litteratur benyttes O(g(n)) om hvad bogen/vi opfatter som Θ(g(n)) Ω(g(n)) = {f(n): there exist positive constants c and n 0 such that 0 cg(n) f(n) for all n n 0 } For at en funktion f(n) skal tilhøre Θ(g(n)), skal den også tilhøre O(g(n)) OG Ω(g(n))!!
Insertion sort algoritmen pseudo kode Insertion - sort(a) Cost Gentagelser 1 for j=2 to length(a) c 1 n 2 do key=a[j] c 2 n-1 3 insert A[j] into sorted 0 n-1 sequence A[1..j-1] 4 i=j-1 c 4 n-1 5 while i>0 and A[i]>key c 5 6 do A[i+1]=A[i] c 6 7 i=i-1 c 7 8 A[i+1]=key c 8 n-1 Den tager vi lige manuelt på tavlen... n j = 2 n j= 2 n j= 2 ( t ( t j j t j 1) 1)
Udførselstid T(n)= Σalle bidrag fra hvert led Insert-sort på tavlen I bedste tilfælde ved en allerede sorteret struktur T(n)=an+b I værste tilfælde hvis strukturen er omvendt sorteret T(n)=an 2 +bn+c Men hvad kan vi bruge det til? Vi har jo ikke altid bedst eller værst tilfælde
Merge algoritmen Merge(A, p, q, r) Cost Gentagelser 1 n 1 = q-p+1 c1 1 2 n 2 = r-q c2 1 3 Make arrays L[1..n1+1], R[1..n2+1] c3 1 4 for i = 1 to n1 c4 n 1 5 do L[i] = A[p+i-1] c5 n 1 6 for j = 1 to n2 c6 n 2 7 do R[j] = A[q+j] c7 n 2 8 L[n 1 +1] = Inf c8 1 9 R[n 2 +1] = Inf c9 1 p: start af array q: midterpunkt i array r: slut af array Udførselstid på tavlen
Merge algoritmen #2 10 i=1 c10 1 11 j=1 c11 1 12 for n = p to r c12 n+1 (n=r-p) 13 do if L[i] R[j] c13 n 14 then A[k] = L[i] c14 tl 15 i = i+1 c15 tl 16 else c16 n-tl 17 j=j+1 c17 n-tl p: start af array q: midterpunkt i array r: slut af array Udførselstid på tavlen
Algoritme kompleksitet sammenligning. To sorterings algoritmer insertion og merge-sort bruger forskellig tid til at løse samme opgave: Insertion bruger c 1 n 2 til at sortere n elementer Merge-sort bruger c 2 *n*log(n) til at sortere n elementer Computer A er hurtig: 1 mia. instruktioner per sekund Computer B er langsommere: 10 mio. instruktioner per sekund Med c 1 =2 og c 2 =50 bruger Computer A: 2000 sekunder Computer B: 100 sekunder Og det til trods at konstanterne c 1 og c 2 favoriserer den hurtige computer!
Algoritme kompleksitet grafisk sammenligning Insertion Merge-sort
Konklusion og opsummering Først og fremmest svare på spørgsmålet: Virker min algoritme efter hensigten? Programmøren: Ja, den virker da, jeg har prøvet 20 tilfældige test data Dig: Se her er min loop invariant og her er beviset på papir Det kan betale sig at analysere sin algoritme, eventuelt sammenligne med andre der løser samme opgaver: versus Vi kan godt løse problemet med Algoritme A, men det tager.. År Hmmm. Du ved godt Algoritme B tager. Sekunder?
Og så lige en at gå hjem på... http://xkcd.com/
Opgaver Opgave 1.2-1, 1.2-2, 1.2-3 Problem 1-1 Opgave 2-2 Opgave 3-2, 3-3 Diskuter hvilke algoritme(r) i får brug for i jeres projekt og Bevis dens gyldighed Beregns dens kompleksitetsgrad