deeegimnoorrrsstt Sjette forelesning

Transkript

1 deeegimnoorrrsstt Sjette forelesning 1

2 2

3 Bellman-Ford BFS/DFS Binære søketrær Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort Sterke komponenter Topologisk sortering 3

4 Bellman-Ford BFS/DFS Binære søketrær Binærsøk De gjenværende algoritmene er litt mer omfattende. (Mange av sorteringsalgoritmene Bubblesorther er ganske enkle, f.eks.) Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort 4 Sterke komponenter I tillegg: Eksempler (DP, LP) NPC-problemer Topologisk sortering

5 Gjensyn med masterteoremet 5

6 Masterteoremet 6

7 T (n) = at (n/b) + f(n) Antall «barn»: Størrelse per «barn»: «Høyde»: a n/b log b n = Θ(lg n) Rota har f(n) arbeid; hver løvnode har en konstant mengde arbeid. Hva vil dominere totalen? Det kommer an på forholdet mellom f(n) og antallet løvnoder. Antall «løvnoder»: a log b n = n log b a Husk uttrykket for antall løvnoder! 7

8 Tilfelle 1: Løvnodene dominerer Da blir kostnaden Θ(n log b a ) Det skjer når f(n) = O(n log b a ɛ ) 8

9 Tilfelle 2: «Dødt løp» Da blir kostnaden Det skjer når Θ(n log b a lg n) f(n) = Θ(n log b a ) Samme kostnad i hvert nivå (dvs. det samme som løvnodene); vi ganger med høyden. 9

10 Det finnes en c < 1 s.a. af(n/b) cf(n), for store nok verdier n Det vil intuitivt si at f-en krymper nedover i treet. 10 f(n) er da regulær

11 Tilfelle 3: Rota dominerer Da blir kostnaden Det skjer når Θ(f(n)) f(n) = Ω(n log b a+ɛ ) 11 Regulariteten innebærer, for en c < 1 og store n: a*f(n/b) c*f(n). Trenger ikke sjekkes hvis f(n) er polynomisk (dvs. n^k). f(n) må være regulær!

12 T (n) = { 1 if n = 1 2T (n/2) + n if n > 1 a = 2 b = 2 log b a = 1 n log b a = n f(n) = n = Θ(n log b a ) Her er det dødt løp, så vi får høyde * antall løvnoder = høyde * radsummen, som vi jo kjenner så godt fra treet vårt T (n) = Θ(n log b a lg n) = Θ(n lg n) 12

13 T (n) = { 1 if n = 1 2T (n/2) + n if n > 1 a = 2 b = 2 log b a = 1 n log b a = n f(n) = n = Θ(n log b a ) Her er det dødt løp, så vi får høyde * antall løvnoder = høyde * radsummen, som vi jo kjenner så godt fra treet vårt T (n) = Θ(n log b a lg n) = Θ(n lg n) 13

14 Variabelskifte 14

15 Flytter oss til «en enklere verden» Skift funksjon og variabel; går «opp i opp» T(n) = S(m) F.eks. m = lg n, S(m) = T(2m ) 15

16 T (n) = 2T ( n) + lg n [m = lg n] T (2 m ) = 2T (2 m/2 ) + m [S(m) = T (2 m )] S(m) = 2S(m/2) + m = O(m lg m) T (n) = O(lg n lg lg n) 16

17 T (n) = 2T ( n) + lg n [m = lg n] T (2 m ) = 2T (2 m/2 ) + m [S(m) = T (2 m )] S(m) = 2S(m/2) + m = O(m lg m) T (n) = O(lg n lg lg n) Legg merke til at alle venstresidene (og høyresidene, for den saks skyld) er like. 17

18 Rebus. Hva er dette? Svar: Kvadratiske sorteringsalgoritmer :-> Som vanlig relativt abstrakte beskrivelser her. Ta en titt på pseudokode i boka for mer detaljert arrayelement-skyfling. sorteri ngsalgo ritmer. Nært Brute Force, men ikke helt. Hva vil brute force (type prøv alle muligheter e.l.) være for sortering? 18

19 Merk: Samme mønster som Bellman-Ford, på sett og vis. Tilsynelatende bare overfladisk, men egentlig et generelt mønster. Bubble Sort Normalt: Sammenlign alle par i rekkefølge fra venstre til høyre. Tenk etter: Vil det fungere om du i hver iterasjon fikser parene i tilfeldig rekkefølge? Beviset blir helt klart ikke det samme, men blir det korrekt likevel? Gjenta n ganger: Sammenlign og evt. fiks alle n 1 par Utfør fra venstre til høyre i hver iterasjon. I hver iterasjon vil da det største usorterte elementet ha falt på plass. n iterasjoner gir da fullstendig sortering. 19

20 Selection Sort Gjenta n ganger: Finn det største usorterte elementet Bytt plass med det siste usorterte Nærmest en direkte implementasjon av korrekthetsbeviset til Bubble Sort!20

21 Insertion Sort Gjenta n ganger Sett inn første usorterte blant sorterte De sorterte havner i starten. Man leter etter riktig plass. Merk at man ofte lar elementet synke ned til riktig plass, så man setter det inn mens man leter. Det kan evt. gjøres ved å bare duplisere neste element hele veien, og så sette inn elementet direkte når man har funnet rett plass. 21 Oppgave : Tenk ut din egen sorteringsalgoritme med kvadratisk kjøretid. Om du ikke klarer det, prøv en med kjøretid på O(2^n) eller O(n!) :)

22 Stå på eksamen uten å lese! 22

23 23

24 And I was really impressed with how they managed to shock the Goatse guy. 24

25 Men hvor effektivt kan det bli? Ω(n lg n) 25

26 Se kap. 8 Hver sammenligning halverer antall muligheter. Vi starter med n! mulige rekkefølger. Beste «worst-case» blir lg(n!) :"+76#'391.23("391/2.,/ 91.23!391/2! /234&5673$%36##689 /,) 91.23!391/2.,)! - 91/23-391)2! - ".0/0)#.,) "/0.0)# /,)! - Nyttig: 91.23!391/23!391)2! Stirlings - approksimasjon: / )2 ".0)0/# ")0.0/# "/0)0.# ")0/0.# n! > (n/e)^n Dermed: h lg(n!) lg(n/e)^n = n lg(n/e) = n lg n - n lg e = Omega(n lg n) 26

27 Med andre ord lg n! = Ω(n lg n) 27

28 Heapsort 28

29 < D C > E = B <? <= <> A B C D > < 29

30 < D C > E = B <? <= <> A B C D > < p(i) = i/2 l(i) = 2i r(i) = 2i + 1 < D C > E = B <? <= <> A B C D > < 30

31 Heapify 31

32

33

34

35 På tavla: Kjøretid Korrekthet (invariant) Build-Heap(A, n): for i floor(n/2) downto 1 Heapify(A, i, n) 35

36 Korrekthet vises enkelt induktivt. Eksempel på tavla. Heapsort(A, n): Build-Max-Heap(A, n) for i n downto 2 exchange A[1] and A[i] Max-Heapify(A, 1, i 1) 36

37 Operasjonene forklart på tavla. Viktig: Hvordan elementer kan «flyte» oppover eller «synke» nedover til riktig plass. Insert(S, x) Maximum(S) Extract-Max(S) Increase-Key(S, x, k) 37

38 Sortering «Selection sort» med en heap In-place, enkel O(n lg n) Heapsort 38

39 M g O e rg t r o es Dårlig worst-case, men bra average-case. Lave konstantledd. Mergesort virker på en måte «omvendt». QS er in-place; MS er det ikke. MS har bedre worst-case. Quicksort 39

40 Grunn-idé Korrekthet vises induktivt. Kjøretiden gis av vårt velkjente binærtre. Del sekvensen i to Sorter hver halvdel rekursivt Kombinér etterpå (Mergesort) eller rydd litt først (Quicksort) Tegning/forklaring på tavla. 40

41 &! " # $ % & ' (. 7 &! " # $ % & ' (.62 7 & "! # $ % & ' (.62 7 & "! # $ % & ' (. 2 7 & " $ #! % & ' (. 2 7 & " $ %! # & ' (. 2 7 & " $ % & #! ' (. 2 & " $ % & #! ' (. 2 & " $ % & (! ' # Invariant: 41 8)&*+, -./01 8)7,22,&3"*+, 401,561, : 8)2;",22,73"*+, <40=4,10,>6,?,-./01 8).,22,2*+, <40=4,10,>6,!,-./01

42 &! " # $ % & ' (. 7 &! " # $ % & ' (.62 7 & "! # $ % & ' (.62 7 & "! # $ % & ' (. 2 7 & " $ #! % & ' (. 2 7 & " $ %! # & ' (. 2 7 & " $ % & #! ' (. 2 & " $ % & #! ' (. 2 & " $ % & (! ' # Invariant: 42 8)&*+, -./01 8)7,22,&3"*+, 401,561, : 8)2;",22,73"*+, <40=4,10,>6,?,-./01 8).,22,2*+, <40=4,10,>6,!,-./01

43 Merge Enkelt eksempel på tavla. Du har to sorterte (del-)sekvenser Plukk ett av sekvens-«hodene» Velg hele tiden det minste Legg det inn på neste ledige plass i resultatet 43

44 Kjøretid Worst-case for MS og Best-case for QS T(n) = 2T(n/2) + n Selv 9-til-1-split gir Θ(n log n) for QS Average-case blir også Θ(n log n) Skjev split for QS gir kvadratisk WC Randomisering: Unngår data-avhengig WC 44

45 Average-case Intuisjon: Selv om annenhvert nivå er helt skjevt vil det bare øke kjøretiden med en konstant. 6!B6C 6!B6C? 45

46 Sortering Store/små for seg Rekursivt Kjapp O(n 2 ) WC O(n lg n) Avg. Quicksort 46

47 Sortering Splitt og hersk og flett Stabil Ikke in-place O(n lg n) Mergesort 47

48 48

49 49

50 50

51 51

52 52

53 53

54 54

55 Vi slår den nedre grensen ved å «spille et annet spill» Lineær sortering 55

56 Lineær sortering Counting sort 56

57 Inn: A[1 n], der A[i] {0, 1,, k} Ut: B[1 n], sortert Ekstralager: C[0 k] Vi bruker C til å telle forekomster 57

58 Tell hvor mange vi har av hver Gjør telle-tabellen (C) kumulativ Tallet angir nå posisjonen til den siste forekomsten Gå igjennom A (baklengs) og bruk C til å finne posisjon Oppdater C etter hvert (dekrementer posisjonen) 58

59 for i = 0 to k C[i] = 0 for j = 1 to n C[A[j]] = C[A[j]] + 1 for i = 1 to k C[i] = C[i] + C[i 1] for j = n downto 1 B[C[A[j]]] = A[j] C[A[j]] = C[A[j]] 1 Her gjelder det å gå systematisk til verks Her har vi «downto» for å holde sorteringen stabil. Ser du hvorfor det må være sånn? Bonusspørsmål: Klarer du å lage en versjon som *ikke* bruker downto, men som er stabil likevel? 59

60 Kø-sortering En måte å se «koblingen» på er at vi i tellesortering først holder rede på hvor lange køene er, og deretter på En lignende sak hvor køene slutter. En forskjell er at vi henter verdier fra hver kø i tilfeldig rekkefølge. Opprett en FIFO-kø for hver mulig verdi For hvert input-element: Legg bakerst i riktig kø Slå sammen køer Fyll output med verdier fra køen Denne algoritmen er også en svært nær slektning (en slags heltallsvariant) av bøttesortering (forklares litt senere). 60 Dette kan enten ses som en konseptuell forklaring av (nesten) hva som skjer i tellesortering (det kan kreve litt tenking å se «ekvivalensen») eller som en egen, enkel, lineær-tids sorteringsalgoritme.

61 Sorter heltall Eller lignende Verdier O(n) Tell forekomster Regn ut indeks Lineær Strenge krav O(n) Tellesortering 61

62 Lineær sortering Radix sort 62

63 Sorter hvert siffer for seg Bruk en stabil sortering (f.eks. CS) for å bevare arbeidet så langt Vi må begynne med minst signifikante siffer Konstant antall siffer: Lineær kjøretid 63

64 A09>3H <:P T;< P+R R<; ];. T<; ]+T PV+ PV+ ];. T;< ]+T R<; T<; <:P P+R ]+T P+R <:P R<; T<; ];. T;< PV+ <:P T<; T;< P+R PV+ ]+T ];. R<; 64

65 A09>3H <:P T;< P+R R<; ];. T<; ]+T PV+ PV+ ];. T;< ]+T R<; T<; <:P P+R ]+T P+R <:P R<; T<; ];. T;< PV+ <:P T<; T;< P+R PV+ ]+T ];. R<; 65

66 Hva om tallene har ulikt antall siffer? Hva om det er veldig stor forskjell? Kan vi få til O(m), der m er det totale antall siffer brukt? (Det ville kunne brukes på vilkårlige strenger også.) Bryter vi i så fall den nedre grensen vår? Korrekthet kan vises ved induksjon på antall pass Kjøretid Θ(n + k) (evt. Θ((n + k)d) Hvordan bryter radix sort reglene for sammenligningssortering? Vi kan få informasjon ut over bare å sammenligne to nøkler. Vi bruker nøkler som tabellindekser! 66 Det kan vi gjøre fordi vi kjenner verdiområdet.

67 Sorter heltall Eller lignende Verdier O(n k ) Sorter siffer Stabilt Lineær Ganske strenge krav O(kn) Radikssortering 67 Evt. gruntallssortering :-)

68 Lineær sortering Bucket sort 68

69 Anta uniformt fordelte verdier i [0,1) Del [0,1) i n like store bøtter Fordél verdiene i bøttene Gå igjennom bøttene i rekkefølge Skriv ut verdiene sortert 69

70 Bøttene sorteres (med en enkel algoritme) Hver bøtte har O(1) forventet størrelse Totalt O(n) kjøretid 70

71 Sortering Uniformt [0,1) Ordnet hashing Lineær Krav O(n) Bøttesortering 71

72 Select 72

73 Seleksjon: Finn i-ende ordens statistic Eksempler: minimum, maksimum, median min/maks: enkle spesialtilfeller Vi ønsker ikke å sortere 73

74 I stedet for å sortere begge halvdeler fortsetter vi bare i den som inneholder posisjon i, som er den vi leter etter. Randomized-Select Eksempel på tavla..5 Quicksort Verste tilfelle blir som for Quicksort. Beste tilfelle blir Theta(n). Forventet kjøretid, forenklet: T(n) = T(n/2) + n 74 Regnes på tavla.

75 Select Hårete og søt 75

76 Del i grupper på 5, og finn medianen i hver Finn «medianen til medianene», rekursivt Bruk denne som pivot i Partition Select rekursivt på «halvparten» Median-av-5: Konstant tid (insertion sort, f.eks.) for hver; O(n) totalt. Median-av-medianer: T(n/5). Merk: Etter utført algoritme vil dataene allerede være partisjonerte rundt elementet vi leter etter. Så ved å kjøre select etter element k så finner vi automatisk de k minste elementene i tabellen. 76 Partition: O(n). Rekursivt kall T(7n/10 + 6), hvis T(n) er monotont stigende. Mao: Vi får en «prosent-deling» i rekursjonen.

77 Finn median Og lignende Halv Quicksort Kjapp O(n 2 ) WC O(n) Avg. Randomized Select 77

78 Finn median Og lignende Pivot = m. av m. finnes rekursivt Kjapp O(n) Select 78

79 Bellman-Ford BFS/DFS Binære søketrær Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort Sterke komponenter Topologisk sortering 79

80 Bellman-Ford BFS/DFS Binære søketrær Binærsøk Bubblesort Bucket sort Counting sort Dijkstra DAGshortest-path Edmonds- Karp Floyd- Warshall Hashing Heapsort Huffmankoding Insertion sort Kruskal Merge sort Prim Quicksort Radix sort Randomized Select Select Selection sort Sterke komponenter Topologisk sortering 80