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. 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 Empirical (a posteriori) approach, untuk memilih algoritma yang terdiri dari pemrograman teknik 2 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 masing 2 algoritma sebagai fungsi dari ukuran instance yang diperhitungkan.

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 (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 (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 (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 masing 2 memerlukan t 1 (n) dan t 2 (n) detik, maka untuk menyelesaikan instance dengan size n, akan selalu ada konstanta 2 positif c dan d sedemikian hingga t 1 (n)  ct 2 (n) dan t 2 (n)  dt 1 (n), ketika n cukup besar.

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 besar 2 an seiring dengan peningkatan ukuran instance.

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 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) procedure insert( T[1..n] ) for i  2 to n do x  T[i]; j  i – 1 while j > 0 and x < T[j] do T[j+1]  T[j] j  j – 1 T[j+1]  x

Average & worst-case Analyses (cont) procedure select( T[1..n] ) for i  1 to n – 1 do minJ  i; minX  T[i] for j  i+1 to n do if T[j] < minX then minJ  j minX  T[j] T[minJ]  T[i] T[i]  minX

Average & worst-case Analyses (cont) Analisis worst-case cocok untuk algoritma yang response time nya kritis (critical). (controlling a nuclear power plant). Menganalisa perilaku rata 2 algoritma biasanya lebih sulit dibanding menganalisa perilaku algoritma dalam worst-case nya. Oleh karena itu, analisis yang bermanfaat dari perilaku rata 2 algoritma memerlukan suatu pengetahuan sebelumnya tentang distribusi instances yang akan diselesaikan.

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 parameter 2 lain dari instance yang diperhitungkan.

Elementary Operations (cont) Contoh, algoritma memerlukan a additions, m multiplications, dan s assignment instructions. Selanjutnya, addition tidak lebih lebih dari t a msec, multiplication tidak lebih dari t m msec, dan assignment tidak lebih dari t s msec, dengan t a, t m, dan t s konstanta 2 yang tergantung pada mesin yang digunakan. Selanjutnya, addition, multiplication, dan assignment bisa dianggap sebagai operasi 2 elementer. Total time t yang diperlukan algoritma bisa dibatasi oleh t  at a + mt m + st s  max(t a, t m, t s )  (a + m + s)

Elementary Operations (cont) Dalam algoritma, satu baris program bisa bersesuaian dengan sejumlah (variabel) operasi 2 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 (cont) function Wilson( n ) { mengembalikan true jika dan hanya jika n prima, n > 1 } if n dibagi habis oleh (n – 1)! + 1 then return true else return false

Elementary Operations (cont) function Sum ( n ) { menghitung jumlahan integers dari 1 ke n } sm  0 for i  1 to n do sm  sm + i return sm

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 (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 (cont) Sehingga untuk menampung hasil saat n = diperlukan bits, 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 (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 (f n ) dari barisan didekati dengan  n /√5, dengan  = (1 + √5)/2 yang disebut “golden ratio”.

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) (ilustrasi) : algoritma eksponensial, dan komputer bisa me-run algoritma pada instance dengan size n dalam x 2 n detik. Jadi, program bisa menyelesaikan instance dengan size 10 dalam x 2 10 detik (atau sekitar 1/10 detik). n= 20, t = 1000 x 1/10 = 100 detik ≈ 2 menit; n = 30, t = 1000 x 100 detik = 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 x x 2 n ( x 2 n ), ternyata dalam setahun komputer hanya mampu menyelesaikan instance dengan ukuran (n = 45 ).

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 x n 3 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 (cont) x 2 n x 2 n x n x n 3 Computation time (in second) Size of the instance

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 n 3 untuk pekerjaan yang sama.

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) Perbedaan praktis antara waktu dalam order n 2 dengan 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.