Design, analyse og verifikation

1. Design, analyse og verifikation

2. Plan • Design Bevisteknikker Design ved hjælp at matematisk induktion • Analyse O-notation Logaritmer Binær søgning • Verifikation PåstandeEt eksempel på verifikation

3. Bevisteknikker(relevant både ved design og verifikation) • Bevisførelse ved modstrid (indirekte bevis). • Antag at det givne teorem er falsk. • Konkluder at dette vil føre til en modstrid. Teorem. Der findes uendeligt mange primtal. Bevis: Antag at der findes et endeligt antal primtal, p1, p2 , ..., pk. Betragt nu tallet N = p1 . p2 ... pk+1. N er større end pk. Men ingen af de kendte primtal går op i N (resten ved division er 1). Så N må være et primtal. Vi har dermed en modstrid, hvilket beviser sætningen.

4. Nogle personer står i en kø: Matematisk induktionuformel beskrivelse • Hvis (1) jeg kender den forreste person, og • (2) hvis jeg for enhver person, jeg kender i køen, også kender dennes efterfølger, • så kender jeg alle personer i køen. Også selv om køen er uendelig lang.

5. Matematisk induktionformel beskrivelse • Lad T være et teorem, der skal bevises, og lad T være udtrykt i termer af heltalsparameteren n. • Teoremet T gælder da for enhver værdi af n ≥ c, hvor c er en konstant, hvis følgende to betingelser er opfyldt: • 1. Basistilfældet: • T gælder for n = c, og • 2. Induktionsskridtet: • Hvis T gælder for n-1, så gælder T for n. Antagelsen i induktionsskridtet kaldes induktionshypotesen.

6. Eksempler på simpel induktion • Teorem: Summen S(n) af de første n naturlige tal er n(n+1)/2. • Bevis:(1) Basistilfældet. For n = 1 er S(1) =1, hvilket stemmer med formlen. • (2) Induktionsskridtet. Antag at sætningen gælder for n-1, dvs. S(n-1) = (n-1)n/2. • S(n) = S(n-1) + n = (n-1)n/2 + n = n(n+1)/2. • Dermed gælder sætningen også for n.

7. Teorem: Ethvert beløb ≥ 4 kroner kan veksles i et antal 2-kroner og et antal 5-kroner. • Bevis: (1) Basistilfældet. 4 kroner kan veksles ved hjælp af to 2-kroner. • (2) Induktionsskridtet. Antag at n-1 kroner kan veksles. Vi kan vise, at denne veksling kan benyttes som udgangspunkt til at veksle n kroner. • Enten indeholder vekslingen en 5-krone, eller også gør den ikke. I første tilfælde erstattes 5-kronen med tre 2-kroner. I andet tilfælde erstattes to 2-kroner med en 5-krone.

8. Stærk induktion • Teoremet T gælder for enhver værdi af n ≥ c, hvor c er en konstant, hvis følgende to betingelser er opfyldt: • 1. Basistilfældet: T gælder for n = c, og • 2. Induktionsskridtet: Hvis T gælder for ethvert k, c ≤ k < n, så gælder T for n.

9. (1) Start med en vilkårlig instans af problemet. (2) Prøv at løse dette under antagelse af, at det samme problem - men af mindre størrelse - er blevet løst. Induktion kan benyttes ved design af algoritmer • Induktionsprincippet kan benyttes konstruktivt. Løsning af små problemer benyttes til at løse større problemer.

10. Eksempel:Sortering af n tal i stigende rækkefølge • Antag at vi kan sortere n-1 tal. • Vi kan da opnå en sortering af n tal ved enten • (1) først at sortere n-1 af tallene, og derefter indsætte det n´te tal på den rette plads (sortering ved indsættelse), • eller • (2) bestemme det mindste af de n tal og sætte det forrest, sortere de resterende tal, og derefter sætte dem bagefter dette forreste tal (sortering ved udvælgelse).

11. Eksempel:Den maksimale delsekvenssum • Problem. Givet en sekvens (a1,a2, .., an) af reelle tal. Find en delsekvens (ai,ai+1, .., aj) af konsekutive elementer, sådan at summen af dens elementer er størst mulig. Eksempel. For sekvensen (-2, 11, -4, -1, 13, -5, 2) er den maksimale delsekvens (11, -4, -1, 13) med summen 19. Hvis alle elementer er positive, er sekvensen selv maksimal. Hvis alle elementer er negative, er den maksimale delsekvens tom. Idet den tomme delsekvens har summen 0.

12. aj ai j i En simpel algoritme maxSum = 0; for (i = 1; i <= n; i++) { for (j = i; j <= n; j++) { sum = 0; for (k = i; k <= j; k++) sum += a[k]; if (sum > maxSum) maxSum = sum; } }

13. Forbedret algoritme Fjern den inderste løkke. Udnyt at maxSum = 0; for (i = 1; i <= n; i++) { sum = 0; for (j = i; j <= n; j++) { sum += a[j]; if (sum > maxSum) maxSum = sum; } }

14. Induktionshypotese: Vi ved, hvordan den maksimale delsekvens findes for en sekvens af længde n-1. S an-1 a1 a2 an S’M S’ • Hvis n = 1, så kan den maksimale delsekvens let bestemmes. Hvis tallet er positivt, består den af tallet selv. Ellers er den tom. • Lad S = (a1,a2, .., an) og S’ = (a1,a2, .., an-1). • Lad S’M være den maksimale delsekvens for S’. Hvis S’M er tom, er den maksimale delsekvens for S tom, hvis an er negativ, ellers lig med (an).

15. S an-1 a1 a2 an S’M S’ Antag at S’M ikke er tom, dvs. S’M = (ai,ai+1, .., aj), for 1 ≤ i ≤ j ≤n-1. • Hvis j = n-1, udvides S’M med an , hvis og kun hvis an er positiv.

16. S an-1 a1 a2 an S’M S’ • Hvis j < n-1 er der to tilfælde: • (1) Enten er S’M også maksimal for S. • (2) Eller der er en anden delsekvens, der ikke er maksimal i S’, men som er maksimal i S, når an tilføjes. • Hvilket tilfælde, der er tale om, kan ikke afgøres på baggrund af den foreliggende information: S’M . • Men da an kun forlænger en delsekvens, der ender i an-1 , dvs. er et suffix for S’, kan afgørelsen træffes, hvis vi kender det maksimale suffix S’E = (ai,ai+1, .., an-1) for S’. • Induktionshypotesen skærpes.

17. maxSum = maxSuffix = 0; for (i = 1; i <= n; i++) { maxSuffix += a[i]; if (maxSuffix > maxSum) maxSum = maxSuffix; else if (maxSuffix < 0) maxSuffix = 0; } • Skærpet induktionshypotese: Vi ved, hvordan den maksimale delsekvens og det maksimale suffix findes for en sekvens af længde n-1. • Vi når derved frem til følgende algoritme:

18. Empirisk undersøgelse af algoritmernes tidsforbrug static void randomFill(int[] a) { java.util.Random r = new java.util.Random(7913); for (int i = 0; i < a.length; i++) a[i] = r.nextInt() % 1000; } public static void main(String [] args) { for (int n = 10; n <= 1000000; n *= 10) { System.out.println("n = " + n); int a[] = new int[n]; randomFill(a); long start = System.currentTimeMillis(); int maxSum = maxSubSum1(a); System.out.println(" Time used: " + (System.currentTimeMillis() - start)/1000.0); System.out.println(); } }

19. Observerede køretider

20. Kurvefitning med MacCurveFitMaxSubSum1

25. AlgoritmeanalyseBeskrivelse af algoritmers ressourceforbrug • Vurdering af algoritmers tids- og pladsforbrug. • Nyttigt: (1) ved valg imellem eksisterende algoritmer • (2) ved udvikling af nye algoritmer

26. O-notation • O-notation benyttes til at angive en øvregrænse for en algoritmes ressourceforbrug (tid eller plads), idet der ses bort fra konstante faktorer. • At en algoritmes tidsforbrug er O(f(n)), hvor n er et udtryk for problemets “størrelse”, betyder: • (1) Intuitiv definition: Algoritmens tidsforbrug vokser i værste tilfælde som f(n), når blot n er tilstrækkelig stor. • (2) Formel definition: Der eksisterer to konstanter, cog N0, således at algoritmens tidsforbrug er opadtil begrænset af cf(n) for alle n ≥ N0.

27. cf(n) g(n) N0 n • O-notationen fokuserer på den generelle kurveform (ser bort fra proportionali-tetskonstanter). • O-notationen muliggør vurderinger af algoritmers effektivitet (kompleksitet), som er uafhængige af det valgte programmeringssprog, oversætter og maskinel. • Illustration af udsagnet “g(n) er O(f(n))”

28. Kurver for n2 , n og log2n n n2 log2n

29. logb(M*N) = logbM + logbN Værd at vide om logaritmer • logb betegner logaritmefunktionen med base b. • logbN = x  bx = N To særligt interessante logaritmefunktioner er log10 og log2. log10N = x  10x = N log2N= x  2x= N Specielt gælder log10(10N) = 1 + log10N log2(2N)= 1 + log2N

30. log2N ° ° ° ° N ° Alle logaritmefunktioner er proportionale Eksempel: log2N = k*log10N, hvor k = 1/log102 ≈ 3.3 Funktionskurve for log2N

31. Brug af log2 • Gentagen fordobling Hvis vi starter med X = 1, hvor mange gange kan X da fordobles, før X bliver større end eller lig med N? • Svar: log2N,det nærmeste heltal, der er større end eller lig med log2N. • Gentagen halvering Hvis vi starter med X = N, hvor mange gange kan X da halveres, før X bliver mindre end eller lig med 1? • Svar: log2N,det nærmeste heltal, der er mindre end eller lig med log2N.

32. Regneregler for O-notationen • Hvis f(n) = dominerende led + ikke-dominerende led, så er O(f(n)) = O(dominerende led) • Eksempler: O(n3 - 10000n2 + 10000) = O(n3) O(n3 + n log n) = O(n3) O(6n3) = O(n3) O(logbn) = O(log n) O(300) = O(1) • Præcedensregler: • O(1) < O(log n) < O(n) < O(n log n) < O(n2) < O(n3) < O(2n) < O(10n) < O(n!) • O(1): konstant, O(log n): logaritmisk, O(n): lineær, O(n2): kvadratisk, • O(n3): kubisk, O(nc): polynomiel,O(cn): eksponentiel (hvor c > 1)

33. x *= i; Tidsforbrug: O(1) (konstant) for (i = 1; i <= n; i++) x *= i; Tidsforbrug: O(n) (lineært) for (i = 1; i <= n; i++) for (j = 1; j <= n; j++) x *= i+j; Tidsforbrug: O(n2) (kvadratisk) for (i = 1; i <= n; i++) for (j = 1; j <= i; j++) x *= i+j; Tidsforbrug: O(n(n+1)/2) = O(n2/2+n/2) = O(n2) Eksempler på analyse

34. Eksempel på analyse(Den maksimale delsekvenssum) maxSum1: • maxSum = 0; • for (i = 1; i <= n; i++) { • for (j = i; j <= n; j++) { • sum = 0; • for (k = i; k <= j; k++) • sum += a[k]; • if (sum > maxSum) • maxSum = sum; • } • } Tidsforbrug: O(n3) (kubisk)

35. maxSum = 0; for (i = 1; i <= n; i++) { sum = 0; for (j = i; j <= n; j++) { sum += a[j]; if (sum > maxSum) maxSum = sum; } } maxSum2: Tidsforbrug: O(n2) (kvadratisk)

36. maxSum = maxSuffix = 0; for (i = 1; i <= n; i++) { maxSuffix += a[i]; if (maxSuffix > maxSum) maxSum = maxSuffix; else if (maxSuffix < 0) maxSuffix = 0; } maxSum3: Tidsforbrug: O(n) (lineært)

37. Søgning er genfinding af lagret information. Informationen har form af poster, der hver har en nøgle. Målet med en søgning er at finde den eller de poster, der har en nøgle, der matcher en given søgenøgle. Søgning • Søgning er det problem at afgøre, om en mængde af objekter indeholder et objekt, der opfylder visse specificerede krav, og i givet fald finde det. Søgning er den mest tidsforbrugende aktivitet i mange programmer. At erstatte en dårlig søgemetode med en god giver ofte en væsentlig effektivitetsforbedring.

38. Klassifikation af søgemetoder • intern/ekstern søgning • statisk/dynamisk søgning • søgning baseret på nøglesammenligninger/ digitale egenskaber ved nøglerne • søgning baseret på de aktuelle nøgler/ transformerede nøgler

39. Interfacet Comparable • public interface Comparable { • int compares(Comparable rhs); • boolean lessThan (Comparable rhs); • } Objekter, der skal sammenlignes, skal implementere dette interface. lhs.compares(rhs), hvor lhs og rhs er to Comparable-objekter, skal returnere -1, 0 eller 1, alt efter om lhs er “mindre end”, “lig med” eller “større end” rhs. lhs.lessThan(rhs)skal returnere true, hvis lhs er “mindre end” rhs. Ellers false.

40. Eksempel på brug af Comparable • public class MyInteger implements Comparable { • public MyInteger(int x) { value = x; } • public int intValue() { return value; } • public int compares(Comparable rhs) { • return value < ((MyInteger) rhs).value ? -1 : • value > ((MyInteger) rhs).value ? 1 : 0; • } • public boolean lessThan(Comparable rhs) { • return value < ((MyInteger) rhs).value; • } • private int value; • }

41. Sekventiel (lineær) søgning • int sequentialSearch(Comparable[] a, Comparable key) throws ItemNotFound { • for (int i = 0; i < a.length; i++) if (a[i].compares(key) == 0) • return i; • throw new ItemNotFound(); • } Sekventiel søgning i et usorteret array bruger altid N sammenligninger for en mislykket søgning, og gennemsnitligt (N+1)/2 sammenligninger for en succesfuld søgning. Tidskompleksiteten for sekventiel søgning er O(N).

42. Eksempel: Søgning efter N. A B E F G H I L M N P R S X L M N P R S X L M N N Binær søgningi et sorteret array • Metode: • Opdel arrayet i to (næsten) lige store dele. • Afgør i hvilken af de to dele, nøglen skal findes. • Fortsæt søgningen i denne del på samme måde.

43. Implementation af binær søgning • int binarySearch(Comparable[] a, Comparable key) • throws ItemNotFound { • int low = 0, high = a.length - 1; • while (low <= high) { • int mid = (low + high)/2; • if (a[mid].compares(key) < 0) • low = mid + 1; • else if (a[mid].compares(key) > 0) • high = mid - 1; • else • return mid; } • throw new ItemNotFound(); • } Algoritmen bruger altid Îlog2N˚ +1sammenligninger for en mislykket søgning, og gennemsnitligt Îlog2N˚ sammenligninger for en succesfuld søgning.

44. Alternativ implementation afbinær søgning • int binarySearch(Comparable[] a, Comparable key) throws ItemNotFound { • int low = 0, high = a.length - 1; • while (low < high) { • int mid = (low + high)/2; • if (a[mid].compares(key) < 0) low = mid + 1; • else high = mid; } • if (a[low].compares(key) == 0) return mid; • throw new ItemNotFound(); } Algoritmen bruger altidÎlog2N˚ +1 sammenligninger for en søgning.

45. Hvor svært kan det være? Binær søgning blev første gang beskrevet i 1946. Den første fejlfri udgave blev publiceret i 1962. I 1986 fandt Bentley, at 90% af de professionelle programmører på hans kurser ikke kunne skrive en fejlfri udgave på to timer.

46. H D N B F L R S E C M I A P G X Kompleksiteten af binær søgning • Binær søgning bruger aldrig mere end Î log2N˚ + 1 sammenligninger - for såvel succesfuld som mislykket søgning. • Binær søgning kan beskrives ved et søgetræ:

47. a[high] key a[low] low next high Interpolationssøgning • Indeksintervallet opdeles efter et gæt på nøglens placering. Ved lineær interpolation sammenholdes søgenøglen med nøglerne i de to interval-endepunkter. I binær søgning erstattes mid med next, og mid = (low + high)/2med next = low + (key - a[low])*(high - low)/(a[high] - a[low]).

48. Kompleksiteten af interpolationssøgning • Interpolationssøgning bruger Îlog2log2N˚ + 1 sammenligninger for både succesfuld og mislykket søgning på “ tilfældige” tabeller. • Færre end 5 forsøg i praksis (225 ≈ 4*1010). • Svagheder: (1) tabellerne er normalt ikke “tilfældige”, • (2) beregningerne af next kan koste mere end de sparede sammenligninger.

49. Kompleksitetsvurdering • 3 tilfælde: • det bedste • • det værste • • det gennemsnitlige • Eksempel - Quicksort: • Bedste: O(n log n) Værste: O(n2) Gennemsnitlige: O(n log n) (hvor n er antallet af elementer, der skal sorteres) • Sædvanligvis er vi interesseret i det værste tilfælde, fordi: • (1) vi ønsker en øvre grænse (en garanti), og • (2) det er lettest at beregne.

50. O-notationens begrænsning • O-notationen er kun brugbar for “store” værdier af n. • For små værdier af n kan de ikke-dominerende led have en væsentlig betydning.