Transcript materi 1

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 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)
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 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
(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
(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 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
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)
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 (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 (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 =
65535 diperlukan 45496 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 (fn) 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
10-4 x 2n detik. Jadi, program bisa menyelesaikan
instance dengan size 10 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 (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 (cont)
10-4 x 2n
Computation
time (in
second)
10-6 x 2n
10-2 x n3
10-4 x n3
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 n3 untuk
pekerjaan yang sama.

Some Examples
(Calculating Determinants - Cont)
Kedua algoritma diprogram pada komputer
(mesin) yang sama. Algoritma “GaussJordan” 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 n2
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.
