Fundamentals Of Algorithmics

1. Fundamentals Of Algorithmics Gilles Brassard & Paul Bratley

2. 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.

3. 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.

4. 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.)

5. 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.

6. 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.

7. 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.

8. 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.

9. 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).

10. 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”.

11. 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

12. 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

13. 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.

14. 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.

15. 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)

16. 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.

17. 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

18. Elementary Operations (cont) functionSum( n ) { menghitung jumlahan integers dari 1 ke n } sm  0 for i  1 tondo sm  sm + i return sm

19. 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

20. 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.

21. 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”.)

22. 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”.

23. 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.

24. 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).

25. 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.

26. 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

27. 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.

28. 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.

29. 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.