College 3 Derde college complexiteit 7 februari 2017 Recurrente Betrekkingen Zoeken 1
Recurrente betrekkingen -1- Rij van Fibonacci: 0,1,1,2,3,5,8,13,21,... Vanaf het derde element: som van de voorgaande twee Een recurrente betrekking is een voorschrift om een waarde T(n) te berekenen door middel van zijn voorganger(s), dus bijvoorbeeld T(n 1), of T( n 2 ), of... Voor de Fibonacci-getallen geldt: T(n) = 0 n = 0 1 n = 1 T(n 1)+T(n 2) n > 1 2
Recurrente betrekkingen -2- Een ander voorbeeld van een recurrente betrekking: T(n) = { 1 n = 1 2T( n 2 )+n n = 2k > 1 Strategie: herhaalde substitutie en afleiden algemene vorm, of: Probeer wat termen door te rekenen: zie je een patroon? Bewijs de formule met volledige inductie Oplossing: T(n) = n+nlgn Θ(nlgn) 3
Recurrente betrekkingen -3- De vorige recurrente betrekking, maar nu voor algemenere n, dus niet alleen voor tweemachten: T(n) = { 1 n = 1 2T( n 2 )+n n > 1 Dan geldt: T(n) O(nlgn) (en overigens ook T(n) Θ(nlgn)). Dit kan bewezen worden door met behulp van volledige inductie bijvoorbeeld aan te tonen dat T(n) 2nlgn voor alle n 2. 4
Recurrente betrekkingen -4- En ten slotte nog twee voorbeelden om op te lossen. (i) T(n) = { 3 n = 1 T(n 1)+n 1 n > 1 Oplossing: T(n) = 3+ 1 2 n(n 1) (ii) T(n) = { 0 n = 1 2T( n 4 )+ n n = 4 k > 1 Oplossing: T(n) = nlog 4 n = 1 2 nlgn 5
Verder vandaag We bekijken een aantal zoekalgoritmen, waarvan we de complexiteit vergelijken. Met behulp van beslissingsbomen bewijzen we later een ondergrens op de complexiteit. Zoeken met behulp van sleutelvergelijkingen Zoekalgoritmen: Ongeordend Lineair zoeken (opgave 3) Geordend Lineair zoeken (opgave 4) Jump Search Binair Zoeken (opgave 5) 6
Zoeken Probleem Gegeven een waarde X en een array A, bestaande uit n elementen A[1],...,A[n]. Bepaal of X in A zit. Zo ja, geef de index terug, zo nee, geef -1 terug. We maken gebruik van sleutelvergelijkingen van de vorm: of if (X = A[i]) then // binaire vergelijking gevonden; else...; if (X = A[i]) then // drie-weg vergelijking gevonden; else if (X < A[i]) then...; else...; 7
Sleutelvergelijking Een sleutelvergelijking doet voor iedere aanroep maximaal twee ja/nee vergelijkingen Kost dus Θ(1) tijd per aanroep De drie-weg vergelijking kost in orde van grootte evenveel tijd als de vergelijking (X = A[i]) We tellen beide soorten sleutelvergelijkingen dan ook als één vergelijking 8
Ongeordend lineair zoeken Probleem Zoek X in een willekeurig array A = A[1],...,A[n]. Complexiteit van het probleem (opgave 3.e.) Elk algoritme dat een waarde X zoekt in een (willekeurig) array A met n elementen, en dat alleen gebruik maakt van sleutelvergelijkingen (X =,< A[i]), doet in de worst case ten minste n vergelijkingen. Algoritme en complexiteit Lineair zoeken doet in de worst case n vergelijkingen, en is dus optimaal. In het bewijs wordt expliciet gebruikt dat je geen informatie hebt over de invoer, behalve wat je uit de sleutelvergelijkingen leert. 9
OLZ: algoritme Algoritme (zie opgave 3): (1) index := 1; (2) while index n and A[index] X do (3) index := index+1; (4) od (5) if index n then (6) return index; (7) else (8) return 1; (9) fi basisoperatie 10
OLZ: complexiteit Best case Je kunt al bij de eerste vergelijking prijs hebben: Θ(1) Average case Laat q de kans zijn dat X in A voorkomt Iedere positie in A is even waarschijnlijk Dan worden er in de average case q 1 2 (n+1)+(1 q) n Θ(n) sleutelvergelijkingen gedaan Worst case Als X niet in A zit of helemaal achteraan: Θ(n) 11
Geordend lineair zoeken Probleem Zoek X in een oplopend gesorteerd array A, bestaande uit n elementen A[1],...,A[n]. Algoritme: (1) index := 1; (2) while index n and A[index] < X do (3) index := index+1; (4) od (5) if index n and X = A[index] then (6) return index; (7) else (8) return 1; (9) fi basisoperatie 12
GLZ: complexiteit De complexiteit van geordend lineair zoeken. Worst case: n sleutelvergelijkingen (Bij welke invoer gebeurt dit? En bij ongeordend zoeken?) Average case: n 2 + n n+1 +q (1 2 n n+1 ) Θ(n 2 ), met q de kans dat X in A voorkomt, en: 1. als X in A: alle n posities in A even waarschijnlijk 2. als X niet in A: alle n+1 gaten even waarschijnlijk zie ook opgave 4 13
Jump search A is weer oplopend gesorteerd; kies k met 1 k < n index := k; // index is altijd een k-voud // vergelijk X met A[k],A[2k],A[3k],... while index n and A[index] < X do index := index+k; od if index n // A[index k] < X A[index] lineair zoeken van X in A[index k +1]...A[index]; else // A[index k] < X A[n] lineair zoeken van X in A[index k +1]...A[n]; fi 14
JS: complexiteit Worst case: n +k sleutelvergelijkingen k Beste keus: k = n. Dan doet Jump sort in het slechtste geval Θ( n ) sleutelvergelijkingen. Dat is beter dan geordend lineair zoeken. Vraag: kan zoeken in een geordend array nog beter? Antwoord: Ja, namelijk binair zoeken. 15
(Werk)college - Volgende college: dinsdag 14 februari, 11:15 13:00, zaal 174 - Eerste werkcollege: dinsdag 7 februari, 13:45 15:30, zaal 405, 408 - liacs.leidenuniv.nl/ graafjmde/comp/ 16