fundamentals of algorithmics n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Fundamentals Of Algorithmics PowerPoint Presentation
Download Presentation
Fundamentals Of Algorithmics

Loading in 2 Seconds...

play fullscreen
1 / 29

Fundamentals Of Algorithmics - PowerPoint PPT Presentation


  • 179 Views
  • Uploaded on

Fundamentals Of Algorithmics. Gilles Brassard & Paul Bratley. Elementary Algorithmics. Problems & Instances , algoritma harus bekerja dengan benar pada setiap instance dari permasalahan ( problem ) yang di-klaim akan diselesaikan.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Fundamentals Of Algorithmics' - kirti


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
fundamentals of algorithmics

Fundamentals Of Algorithmics

Gilles Brassard & Paul Bratley

elementary algorithmics
Elementary Algorithmics
  • Problems & Instances, algoritma harus bekerja dengan benar pada setiap instance dari permasalahan (problem) yang di-klaim akan diselesaikan.
  • Domain of definition, ketika permasalahan ditentukan, maka hal penting yang harus dilakukan adalah mendefinisikan “domain of definition”, yaitu himpunan semua instances yang diperhitungkan.
the efficiency of algorithms
The Efficiency Of Algorithms
  • Empirical (a posteriori) approach, untuk memilih algoritma yang terdiri dari pemrograman teknik2 yang dibandingkan, dan mencoba mereka pada instances yang berbeda dengan bantuan komputer.
  • Theoretical (a priori) approach, terdiri dari penentuan secara matematik kuantitas dari sumber (resource) yang diperlukan oleh masing2 algoritma sebagai fungsi dari ukuran instance yang diperhitungkan.
the efficiency of algorithms cont
The Efficiency Of Algorithms (cont)
  • Contoh resource : # of processors yang diperlukan oleh algoritma parallel.
  • Ukuran (size) instance bersesuaian secara formal dengan # of bits yang diperlukan untuk menyatakan (represent) instance tersebut pada komputer, menggunakan suatu skema coding yang didefinisikan secara tepat dan sangat beralasan.
  • Dalam bahasan, size berarti sebarang integer yang mengukur # of components dalam instance. (dalam sorting, size : # of items being sorted.)
the efficiency of algorithms cont1
The Efficiency Of Algorithms (cont)
  • Manfaat theoretical approach tidak tergantung pada komputer yang digunakan, programming language, maupun keahlian programmer nya.
  • Algoritma mungkin juga dianalisa dengan menggunakan “hybrid approach”, di mana bentuk function yang menggambarkan “algorithm’s efficiency” ditentukan secara teoritis, kemudian setiap parameter numerik yang diperlukan ditentukan secara empiric untuk program dan mesin tertentu, biasanya dengan suatu jenis regresi.
the efficiency of algorithms cont2
The Efficiency Of Algorithms (cont)
  • Untuk mengukur “amount of storage” yang digunakan algoritma sebagai function dari size of the instances, ada satuan natural yang tersedia, yaitu “bit”. (tanpa memperhatikan mesin yang digunakan, konsep “one bit of storage” terdefinisikan dengan baik.
  • Tetapi tidak berlaku jika efisiensi algoritma ingin diukur dalam “term” waktu yang diperlukan untuk menghasilkan jawaban.
the efficiency of algorithms cont3
The Efficiency Of Algorithms (cont)
  • (Jawaban) “principle of invariance”, yang menyatakan bahwa dua implementasi yang berbeda dari algoritma yang sama tidak akan berbeda efisiensi nya lebih dari suatu konstanta pengali (multiplicative constant).
  • Secara lebih tepat, jika dua implementasi dari algoritma yang sama masing2 memerlukan t1(n) dan t2(n) detik, maka untuk menyelesaikan instance dengan size n, akan selalu ada konstanta2 positif c dan d sedemikian hingga t1(n)  ct2(n) dan t2(n)  dt1(n), ketika n cukup besar.
the efficiency of algorithms cont4
The Efficiency Of Algorithms (cont)
  • Prinsip tetap benar, apapun komputer yang digunakan untuk mengimplementasikan algoritma, tidak peduli programming language dan compiler apa yang digunakan, dan bahkan tidak mempedulikan keahlian (skill) dari programmer.
  • Perubahan mesin bisa menyelesaikan 10 kali atau 100 kali lebih cepat, sehingga menaikkan kecepatan dengan faktor konstan. Sebaliknya, perubahan algoritma bisa meng-improve secara besar2an seiring dengan peningkatan ukuran instance.
the efficiency of algorithms cont5
The Efficiency Of Algorithms (cont)
  • Algoritma untuk suatu permasalahan memerlukan waktu “in the order of” t(n), untuk suatu function t, jika ada suatu konstanta positif c dan implementasi algoritma mampu menyelesaikan setiap instance ukuran n ct(n) detik (atau sebarang satuan waktu yang lain).
  • Algoritma memerlukan waktu “in the order of” n, atau lebih sederhana dengan mengatakan waktu linier (linear algorithm).
average worst case analyses
Average & worst-case Analyses
  • Waktu yang diperlukan, atau “storage” yang digunakan oleh suatu algoritma sangat bervariasi antara dua instances yang berbeda dengan ukuran sama.
  • (Ilustrasi), perhatikan dua algoritma “elementary sorting”, yaitu “sorting by insertion”, dan “sorting by selection”.
average worst case analyses cont
Average & worst-case Analyses (cont)

procedureinsert( T[1..n] )

for i  2tondo

x  T[i]; j  i – 1

whilej > 0andx < T[j]do

T[j+1]  T[j]

j  j – 1

T[j+1]  x

average worst case analyses cont1
Average & worst-case Analyses (cont)

procedure select( T[1..n] )

fori  1to n – 1do

minJ  i; minX  T[i]

for j  i+1tondo

if T[j] < minXthen

minJ  j

minX  T[j]

T[minJ]  T[i]

T[i]  minX

average worst case analyses cont2
Average & worst-case Analyses (cont)
  • Analisis worst-case cocok untuk algoritma yang response time nya kritis (critical). (controlling a nuclear power plant).
  • Menganalisa perilaku rata2 algoritma biasanya lebih sulit dibanding menganalisa perilaku algoritma dalam worst-case nya.
  • Oleh karena itu, analisis yang bermanfaat dari perilaku rata2 algoritma memerlukan suatu pengetahuan sebelumnya tentang distribusi instances yang akan diselesaikan.
elementary operations
Elementary Operations
  • Operasi elementer : operasi yang waktu eksekusinya bisa dibatasi (nilai) atasnya dengan suatu konstanta yang hanya tergantung pada implementasi tertentu yang digunakan – seperti, mesin, programming language, dll.
  • Sehingga, konstanta tidak tergantung pada size maupun parameter2 lain dari instance yang diperhitungkan.
elementary operations cont
Elementary Operations (cont)
  • Contoh, algoritma memerlukan a additions, m multiplications, dan s assignment instructions. Selanjutnya, addition tidak lebih lebih dari ta msec, multiplication tidak lebih dari tm msec, dan assignment tidak lebih dari ts msec, dengan ta, tm, dan ts konstanta2 yang tergantung pada mesin yang digunakan.
  • Selanjutnya, addition, multiplication, dan assignment bisa dianggap sebagai operasi2 elementer. Total time t yang diperlukan algoritma bisa dibatasi oleh

t  ata + mtm + sts

 max(ta, tm, ts)  (a + m + s)

elementary operations cont1
Elementary Operations (cont)
  • Dalam algoritma, satu baris program bisa bersesuaian dengan sejumlah (variabel) operasi2 elementer. Contoh, T : array dari n elemen (n > 0), maka waktu yang diperlukan untuk menghitung (compute)

x  min T[i]  1  i  n 

menaik (increase) berdasarkan n.

elementary operations cont2
Elementary Operations (cont)

functionWilson( n )

{ mengembalikan true jika dan hanya jika n

prima, n > 1 }

if n dibagi habis oleh (n – 1)! + 1then return true

else returnfalse

elementary operations cont3
Elementary Operations (cont)

functionSum( n )

{ menghitung jumlahan integers dari 1 ke n }

sm  0

for i  1 tondo

sm  sm + i

return sm

elementary operations cont4
Elementary Operations (cont)

function Fibonacci( n )

{ menghitung suku ke-n dari barisan fibonacci }

i  1

j  0

for k  1 to n do

j  i + j

I  j – 1

return j

elementary operations cont5
Elementary Operations (cont)
  • Tidak ada real machine yang bisa mengeksekusi penjumlahan ini, jika n dipilih cukup besar. Sehingga, analisa algoritma harus tergantung pada domain aplikasi yang dimaksudkan.
  • Kasus di Fibonacci, hanya diperlukan n = 47 untuk terakhir kalinya bisa mengeksekusi “j  i+j” yang menyebabkan “arithmetic overflow” pada mesin 32-bits.
elementary operations cont6
Elementary Operations (cont)
  • Sehingga untuk menampung hasil saat n = 65535 diperlukan 45496bits, atau lebih dari 1420 computer-words. (Dalam permasalahan praktis tidak realistik.)
  • Untuk kasus perkalian, masih bisa dianggap elementary operation selama operand nya cukup kecil. (lebih mudah menghasilkan operands besar dengan perkalian berulang dari pada dengan jumlahan  yang penting, operasi aritmatik tidak “overflow”.)
elementary operations cont7
Elementary Operations (cont)
  • Permasalahan serupa muncul ketika mengnalisa algoritma yang melibatkan real numbers, yaitu jika presisi yang dikehendaki meningkat seiring dengan size of instance yang akan diselesaikan. Satu contoh tipikal untuk fenomena ini digunakan “de Moivre’s formula”. Yaitu, suku ke-n (fn) dari barisan didekati dengan n/√5, dengan  = (1 + √5)/2 yang disebut “golden ratio”.
algorithm s efficiency
Algorithm’s Efficiency
  • (Fact) computing equipment berkembang sangat cepat (khususnya dalam kemampuan computation nya), sehingga terlihat tidak begitu bermanfaat untuk meluangkan waktu mencoba merancang algoritma yang lebih efisien.
  • Apakah tidak lebih mudah menunggu “the next generation of computers” ?
  • (Jawaban) : argumentasi tidak benar.
algorithm s efficiency cont
Algorithm’s Efficiency (cont)
  • (ilustrasi) : algoritma eksponensial, dan komputer bisa me-run algoritma pada instance dengan size n dalam 10-4 x 2n detik. Jadi, program bisa menyelesaikan instance dengan size10 dalam 10-4 x 210 detik (atau sekitar 1/10 detik). n= 20, t = 1000 x 1/10 = 100 detik ≈ 2 menit; n = 30, t = 1000 x 100 detik = 100000 detik > 1 hari penuh.
  • (ekstrim) : misal komputer mampu run tanpa interruption / error dalam setahun, ukuran instance yang bisa diselesaikan baru 38. Untuk n > 38, tetapi ada komputer yang kecepatannya 10-2 x 10-4 x 2n (10-6 x 2n), ternyata dalam setahun komputer hanya mampu menyelesaikan instance dengan ukuran (n = 45).
algorithm s efficiency cont1
Algorithm’s Efficiency (cont)
  • (Pada umumnya), jika komputer sebelumnya mampu menyelesaikan instance dengan size n dalam waktu t, maka komputer baru (dalam waktu yang sama, t) akan menyelesaikan instance dengan size terbaiknya n + lg 100, atau sekitar n + 7.
  • (investasi di algoritma) dengan algoritma kubik, misal komputer semula mampu menyelesaikan instance dengan size n dalam 10-2 x n3 detik. Maka n=10, t=10 detik; n=20, t=1 s.d 2 menit; n=30, t=4.5 menit; dalam satu hari mampu menyelesaikan untuk n > 200, dan dalam setahun bisa menyelesaikan instance dengan size hampir 1500.
algorithm s efficiency cont2
Algorithm’s Efficiency (cont)

10-6 x 2n

10-4 x 2n

Computation time (in second)

10-2 x n3

10-4 x n3

Size of the instance

some examples calculating determinants
Some Examples (Calculating Determinants)
  • Dua algoritma terkenal untuk menghitung determinan : (1) berdasar pada definisi rekursif, dan (2) disebut “Gauss-Jordan elimination”.
  • Algoritma rekursif memerlukan waktu proporsional dengan n! (untuk menghitung determinant matriks n x n).
  • Algoritma “Gauss-Jordan” memerlukan waktu proporsional dengan n3untuk pekerjaan yang sama.
some examples calculating determinants cont
Some Examples (Calculating Determinants - Cont)
  • Kedua algoritma diprogram pada komputer (mesin) yang sama. Algoritma “Gauss-Jordan” menghitung determinan matriks 10 x 10 dalam waktu 1/100 detik, dan untuk matriks 100 x 100 memerlukan waktu 5.5 detik. Algoritma rekursif, untuk matriks 5 x 5 memerlukan waktu > 20 detik, dan 10 menit untuk matriks 10 x 10.
  • Untuk matriks 20 x 20, algoritma rekursif memerlukan waktu > 10 juta tahun.
some examples sorting
Some Examples (Sorting)
  • Perbedaan praktis antara waktu dalam order n2dengan n log n, bisa dilihat dengan memprogram algoritma “insertion sort” dengan “quicksort” pada mesin (komputer) yang sama.
  • Quicksort hampir 2 x lebih cepat dengan “insertion sort” ketika n = 50 elemen, dan 3 x lebih cepat ketika n = 100. Untuk mengurutkan 1000 elemen, “insertion” memerlukan waktu lebih dari 3 detik, sementara “quicksort” memerlukan waktu kurang dari 1/5 detik.