Mm4: Greedy algorithms, backtracking and more recurrences - October 21, 2008

Transkript

1 Algorithms and Architectures I Rasmus Løvenstein lsen (RL), Jimmy Jessen Nielsen (JJE) Mm4: Greedy algorithms, backtracking and more recurrences - ctober 21, 2008

2 Algorithms and Architectures II 1. Introduction to analysis and design of algorithms(rl) 2. Recursive algorithms and recurrences (RL) 3. More about recurrences (RL) 4. Greedy algorithms, backtracking and more recurrences(rl) 5. Counting, probabilities and randomized algorithms (RL) 6. More sorting algorithms: Heap sort and quick sort (RL) 7. A little bit more about sorting - and more times for exercises (RL) 8. Hash tables, Hashing and binary search trees (RL) 9. Binary search trees, red-black trees (JJE) 10. Red-black trees continued + string matching (JJE)

3 Dagsorden Rekursion flere eksempler Heltalsmultiplikation Tennis turnering Dynamisk programmering World series odds Grådige algoritmer Eksempler Kruskals algoritme Prims algoritme Den omrejsende handelsmand Heuristiske algoritmer Backtracking Alpha beta beskæring psummering og konklusion pgaver

4 Multiplikation af heltal #1 Tænk på opgaven Z = * Y En algoritme går ud på at dele og Y ind i to andre heltal med længden n/2 bits hver, således = A B = A2 n/2 + B Y = C D = C2 n/2 + D Produktet Z kan nu skrives som Z = Y = AC2 n + (AD + BC)2 n/2 + BD Dette kræver 4 Multiplikationer af n/2 bit heltal, hver tager T(n/2) Tre additioner og to skifte operationer (*2 n termerne), tager (n)

5 Multiplikation af heltal #2 Multiplikationskompleksiteten bliver således T(1) = 1 T(n) = 4T(n/2) + cn a = 4, b = 2 og med c = 1og vi får d(n) = n Ved brug af de metoder vi kender kan vi konstatere at T(n) = (n 2 )

6 Multiplikation af heltal #3 Tænk nu over flg. metode at udføre multiplikationen Z = Y = AC2 n + [(A - B)(D - C) + AC + BD]2 n/2 + BD Kompliceret? Måske umiddelbart, men nu kræves der kun Tre multiplikationer, hver T(n/2) Seks additioner/subtraktioner og to rotationer, i alt (n) Derved opnår vi en kompleksitet på T(1) = 1 T(n) = 3T(n/2) + cn Hvis løsning er T(n) = (n log2(3) ) = (n 1.59 ) (n 1.59 ) < (n 2 ) og dermed er det hurtigere at anvende denne

7 Multiplikation af heltal #3 men men men.. Hvorfor bruger/lærer vi så ikke den komplicerede algoritme? Den første algoritme er for de fleste nemmere at indse og lære Vi har sat konstanten c = 1, med andre værdier af c opnår vi ens beregningskompleksitet

8 Tennis turnering En round-robin tennis turnering planlægges for n = 2 k spillere Spillene udføres over n 1 dage Programmet organiseres i en n x n-1 matrix, der indikerer hvem spiller mod hvem på de forskellige dage Ideen bag en algoritme der kan lave en sådan turnering er således at Gruppen af spillere deles op i halve portioner (undergrupper), indtil vi når grundtilfældet med undergrupper på to spillere De to parres og samles i større undergrupper Undergrupperne parres nu sammen indtil samtlige undergrupper er samlet i den store gruppe Efterfølgende dage, skabes ved samtlige mulige permutationer af den/de disjunkte undergruppe

9 Løsning af underproblemerne Til samling af undergrupperne udføres altså en cyklisk permutation af de enkelte undergrupper Til deling og samling af undergrupperne kan vi benytte enten Insertion - sort der giver en kompleksitet på T(n) = T(1) + T(n-1) + n; -> (n 2 ) Merge sort der giver en kompleksitet på T(n)=2T(n/2) + d(n); T(1)=1; -> (nlog 2 (n))

11 Dynamisk programmering Rekursive algoritmer baseres ofte på at dele problemer op i mindre dele der ligner original problemet, som vi har set Det sker dog ofte at vi løser det samme problem igen og igen En ide kunne være at genbruge resultater, så f.eks. f(n) = n! ved vi at hvis vi en gang har beregnet f(4) = 4*3*2*1 = 24, så behøver vi ikke beregne f(4) igen. Vi gemmer resultatet i en tabel og genbruger. Dermed øges hastigheden også på beregning af f.eks. f(5) = 5*f(4)

12 World series odds #1 Tænk på to teams, A og B, spiller et spil hvori det gælder om at vinde n spil World series er sådan et spil med n = 4 Antag A og B er lige gode, hvert hold har 50% sandsynlighed for at vinde Lad nu P(i,j) være sandsynligheden for at team A vinder, hvor i er antallet af spil A mangler at vinde for at vinde spillet j er antallet af spil B mangler at vinde for at vinde spillet Hvis i = 0 eller j = 0 så har A eller B vundet kampen allerede, dvs. P(0,j) = 1; j>0 P(i,0) = 0; i>0 Generelt P(i,j) = (P(i-1, j) + P(i, j-1))/2

13 World series odds #2 Dermed har vi en funktion (for vores sandsynlighed) der ser således ud 1; i = 0, j > 0 P( i, j) = 0; i > 0, j = 0 P( i 1, j) + P( i, j 1) ; 2 Lad T(n) være den maksimum tid det tager at kalde P(i,j), hvor i + j = n, så T(1) = c T(n) = 2T(n-1) + d T(n) 2 n-1 + (2 n-1-1)d = (2 n ) Konklusion: P(i,j) tager ikke mere end (2 i+j ) tid i > 0, j > 0

14 World series odds #3 Den totale mængde af kald til P(i,j) er givet ved (antallet af måder i hvormed i kan vælges ud af i+j muligheder) For i = j er T(n) givet ved Ω(2 n /sqrt(n)) i + j Forskellen mellem (2 n ) og Ω(2 n /sqrt(n)) er ikke forfærdelig stor, og i begge tilfælde er det ikke praktisk at beregne sandsynlighederne på denne måde Men hvad gør vi så? Dynamisk Programmering..

15 World series odds dynamisk programmering /2 21/32 13/16 15/ /32 1/2 11/16 7/ /16 5/16 1/2 3/ /16 1/8 1/4 1/ i j Lad algoritmen udfylde tabellen fra nederste højre hjørne og arbejd opad/henad. I det her tilfælde kan man også udnytte symmetrien P(i,j) + P(j,i) = 1

16 Worlds series odds Implementering af beregning Funktion odds(i, j) Cost Integer s, k; 1 For s = 1 to i + j n = i + j 2 P(0, s) = 1; n 1 3 P(s, 0) = 0; n 1 4 for k = 1 to s-1 5 P(k, s-k) = ((P(k-1, s-k) + P(k, s-k-1))/2 6 return P(i, j) 1 Dermed bliver T(n) for odds(i,j) = (n 2 ), n=i+j s 1 k = 1 s 2 k = 1 k k

17 Sammenligning (2 n ) Complexity f(n) Ω(2 n / n) n (n 2 ) - Konklusion: Vi har lyst til at bruge dynamisk programmering!!

19 Grådige algoritmer Forestil jer at vi har følgende mønter 25 Eurocents 10 Eurocents 5 Eurocents 1 Eurocents Nu skal vi give 63 Eurocents tilbage for et køb af en vare Hvordan finder vi ud af at give penge tilbage? Nogle bud? A. 63x1 Eurocents B. 6x10 + 3x1 Eurocents C. 2x25 + 1x10 + 3x1 Eurocents D. 2x25 + 1x5 + 8x1 Eurocents Hvilke kriterier havde i for jeres valg?

20 Grådige algoritmer: Nogle grundsten 1. Et kandidat sæt hvorfra en løsning er skabt 2. En udvælgelsesfunktion der bestemmer den bedste kandidat der skal tilføjes løsningen 3. En gyldighedsfunktion der bestemmer om den mulige løsning overhovedet er lovlig 4. En formålsfunktion der bestemmer om løsningen skal med i den fuldstændige eller en partiel løsning 5. En løsningsfunktion der bestemmer hvorvidt algoritmen har nået en løsning eller ej

21 Møntproblemet igen nu også grafisk

22 Den omrejsende salgsmand (the travelling salesman) problem - Brute force løsninger giver en kompleksitet på (n!) - Med dynamisk programmering kan vi reducere det til (n 2 2 n ) - Flere andre løsninger findes også: - Dijkstras algoritme og lignende - Backtracking - Alfa-beta beskæring - Genetiske algoritmer

23 Eksempel - Dijkstras algoritme Grådig algoritme til at finde korteste og billigste sti i en retningsorienteret graf Ideen er for hvert punkt at estimere prisen for at rejse til næste knude, og vælge den billigste tur Anvendes til bl.a. routning af data pakker i netværk S Ø 2 Q V[G] 3 while Q Ø do u ETRACT-MIN(Q) S S {u} for each vertex v Adj[u] do Relax(u,v,w) 4 6

24 Eksempel - Kruskal s algorithm Grådig algoritme til at konstruere et minimum span træ Ideen er baseret på at danne et sæt af linjer lokalvist og derefter sætte dem sammen stykvist 1 A Ø 2 for each vertex v V[G] do MAKE-SET(v) 3 sort edges of E into increasing cost by w 4 for each edge (u,v) E do if FIND-SET(u) FIND-SET(v) then A A {(u,v)} UNIN(u,v) 5 return A a b h i 2 6 c g d f e

25 Eksempel - Prim s algorithm Grådig algoritme til at danne et sæt af forbundne noder, ligesom Kruskal s Alle kanter der endnu ikke er en del af træet er anført i en minimum prioritets kø, Q A = {( v, π[ v]) : v V { r} Q} Målet er nået når flg. kriterium er opnået A = {( v, π[ v]) : v V { r}} a b h i 2 6 c g 7 1 for each u V[G] do key[u] π[u] NIL 2 key[r] 0 3 Q V[G] 4 while Q Ø do u ETRACT-MIN(Q) for each v Adj[u] do if v Q and w(u,v)<key[v] then π[v] u key[v] w(u,v) 2 4 d f e

26 Eksempler Sammenligninger Kompleksitet for de tre algoritmer Knuder : V; Forbindelser : E Kruskal s algoritme (E log (V)) Prim s og Djikas algoritme (afhængig af hvorledes Q er implementeret) Adjacency matrix: (V 2 ) Binary heap: ((V+E) log (V)) = (E log(v)) Fibonacci heap: (E+V log(v)) Prim s algorithm indeholde til enhver tid et komplet træ, mens Kruskal s algoritme ikke nødvendigvis gør

27 Heuristiske grådige algoritmer For nogle problemer producerer grådige algoritmer ikke optimale løsninger, f.eks. Dijkstras algoritme med negativt vægtede forbindelser Den omrejsende salgsmand

28 Dijkstras algoritme med negative vægtet forbindelse Betragt følgende: SA = 1, ikke så meget der AB = 2 < AC = 3, ergo vælger en grådig algoritme AB Men hmmm.. AC + CB = 1 < AB = 2 Konklusion: Grådige algoritmer virker ikke altid helt efter hensigten! Grådige algoritmer som Dijkstra ser ikke på helhedsbilledet. 2 B S 1 A -2 3 C

29 Heuristiske grådige algoritmer Nogle problemer egner sig som sagt ikke til at finde optimale løsninger med Men i langt de fleste tilfælde er det nok at få et ret godt resultat Spørgsmålet er blot hvor godt Eller om andre valg er realistiske tidsmæssige... Tag nu den omrejsende salgsmands problem igen som eksempel... c d c d c d b e b e b e a A f Hvilken tur er den bedste? Det er nemt nok hvis der kun er tre at vælge imellem, men hvad hvis der var løsninger at vælge imellem? a B f a C f

30 Den omrejsende salgsmands problem igen igen En modificeret Kruskals algoritme kan løse vores problem (en heuristisk grådig algoritme) Et punkt under betragtning skal overholde flg. krav før den kan indgå i en løsning: kanten får ikke den eksisterende løsning til at have mere end tre grader kanten får ikke den eksisterende løsning til at danne en kreds, undtagen der er tale om den sidste kant En betragtet kant der overholde disse krav, bliver en del af løsningen og hvis ikke, bliver den afvist

31 g den modificerede algoritme i praksis c d b e a f Så svaret på spørgsmålet blev her (A)

32 Backtracking hvad er problemet? Er det virkelig nødvendigt at gennemgå løsninger der er baseret på ulovlige træk? Kan vi ikke spare noget tid ved eliminering af sådanne muligheder? Løsningen hedder backtracking Eksempler Kryds og bolle Dronninge problemet Convex hull problemet

33 Eksempel - Kryds og bolle

34 Eksempel - Kryds og bolle #2 Først mappes udviklingen ind i et træ med symboler forståelig for vores algoritme, f.eks. -1 indikation af et godt træk for 0 indikation af et lige godt/dårligt træk for og 1 indikation af et godt træk for Spillerne bør bruge funktionen : min(x 1,..,x n ) : max(x 1,..,x n ) Andre spil/problemer, f.eks. Skak kan have meget mere komplicerede regler og funktioner flytter S = 0 flytter S = -1 Udsnit af træ S = 1 flytter S = -1 flytter

35 Eksempel - Dronninge problemet Betragt et n gange n skakbræt, og problemet med at placere q dronninger på brættet uden at dronningerne truer hinanden. Ø Ø ØØ Ø Ø En dronning truer en række felter Løsningsrummet er {1,2,3,,n} n At prøve alle samtlige løsninger inkluderer n n tilfælde, men ved at udnytte to dronninger ikke kan være i samme række/kolonne reducerer opgaven til n! tilfælde.

36 Eksempel: Convex hull (Graham s Scan) Problemet går ud på at konstruere den korteste polygon der omkredser et given sæt af punkter på et plan Gennemgå punkterne i en tilfældig rækkefølge, læg dem i en delvis løsning når der laves et retningskift på mindre en 180 o og backtrack når der laves større retningsskift Gennemgå nu de forskellige løsninger Intuitivt Start med et yderpunkt Algoritmen kræver (o log n) gange for at sortere punkterne og (n) tid for at vælge en relevant basis

37 Backtracking En potentiel løsning er repræsenteret som S={v 1,v 2,..,v n } Try(S) Is S a solution Yes Return S No For each v in S, do: No Is {v 1,v 2,..,v n, v} Acceptable? Yes Try {v 1,v 2,..,v n, v} No Is S = Ø Return S Yes

38 Karakteristika for backtracking algoritmen Backtracking er god til at gennemgå et løsningsrum for gode løsninger Det vigtigste, og tit sværeste, er identifikation af problemet Beskrivelse og identifikation af regler er nødvendige, men ikke nødvendigvis let! kan nemt reducere antallet af iterationer der er behov for under udførsel

39 Alpha beta beskæring I nogle tilfælde kan man afskære hele grene af et træ og spare meget tid Betragt flg. Regler 1. Hvis alle underpunkter af et knudepunkt n er blevet overvejet eller afskåret, lad den endelige værdi for knudepunktet blive endeligt 2. Hvis vi for et knudepunkt n betragter en 1. Max knudepunkt der har en midlertidig værdi v1 og et underpunkt med en endelig værdi v2, så sæt den midlertidige værdi af n til max(v1,v2). 2. Min knudepunkt der har en midlertidig værdi v1 og et underpunkt med en endelig værdi v2, så sæt den midlertidige værdi af n til min(v1,v2) 3. Hvis et knudepunkt er en 1. Min knudepunkt p med en super knude q (en max knude) og p og q har midlertidige værdier v1 og v2, med v1<=v2 så kan vi afskære underpunkterne i p 2. Max knudepunkt p med en super knude q (en max knude) og p og q har midlertidige værdier v1 og v2, med v2<=v1 så kan vi afskære underpunkterne i p g i praksis ser det således ud...

40 Eksempel - Alpha beta beskæring

42 psummering og konklusion Endnu lidt flere eksempler med rekursive algoritmer og udnyttelse af analyse til valg af effektiv algoritme Heltalsmultiplikation Tennis turnering Hvordan vi kan effektivisere rekursive algoritmer Dynamisk programmering Grådige algoritmer Fokuserer sig på bedst løsning i situationen Ser ikke så meget på helhedsbilledet F.eks. Kruskals algoritme og Prims algoritme Effektivisering af grådige algoritmer Reducering af løsningsrum ved afskæring af ulovlige løsningsmuligheder Backtracking Alpha beta beskæring

43 g endelig...!!!

44 pgaver vervej implementeringsstrategier for planlægning af hvorledes en robot kan bevæge sig effektivt i et lager Hvilke forbehold er der for en potentiel rute? Hvilken type algoritme vil være bedst? Kruskal, Prims, Dijkstras eller noget andet? Hvordan vil robotten kunne opdatere sin rute hvis der sker ændringer i lokalet? Hvad hvis en sætter en boks et sted og forhindrer/gør det dyrt at bevæge sig et sted? Er det muligt at anvende en form for beskæring af muligheder i form af ulovlige ruter? Fortsæt med rekursive opgaver fra sidst