UU - Perancangan Analisis & Algoritma

Novrina
a. Kesalahan sintaks (penulisan program).

b. Kesalahan pelaksanaan: semantik, logika, dan
ketelitian..
Setiap Algoritma akan selalu terdiri dari tiga
bagian yaitu :
lJudul (Header)
lKamus
lAlgoritma
Judul adalah bagian teks algoritma yang
digunakan sebagai tempat mendefinisikan
nama dengan menentukan apakah teks
tersebut adalah program, prosedur, fungsi.
Kamus adalah bagian teks algoritma sebagai
tempat untuk mendefinisikan :
lNama type
lNama konstanta
lNama variabel
lNama fungsi
lNama prosedur.
Algoritma adalah bagian inti dari suatu
algoritma yang berisi instruksi atau
pemanggilan aksi yang telah didefinisikan.
Bentuk penyajian untuk algoritma dibagi
menjadi 3 (tiga) bentuk penyajian, yaitu :
l Algoritma dengan struktur Bahasa
Indonesia
l Algoritma dengan Pseudocode
l Algoritma dengan Flowchart
Sifat: Umum
l Tidak menggunakan simbol atau sintaks dari suatu
bahasa pemrograman.
l Tidak tergantung pada suatu bahasa
pemrograman.
l Notasi-notasinya dapat digunakan untuk seluruh
bahasa manapun.
Contoh : Menghitung rata-rata tiga buah data
Algoritma dengan struktur bahasa Indonesia :
l 1) Baca bilangan a, b, dan c
l 2)Jumlahkan ketiga bilangan tersebut
l 3)Bagi jumlah tersebut dengan 3
l 4)Tulis hasilnya
Penyajian algoritma dengan pseudocode
berarti menggunakan kode yang mirip
dengan kode pemrograman yang
sebenarnya. Pseudocode lebih rinci dari
English/Indonesia Structure.
Contoh (1) : Menghitung rata-rata tiga
buah data
Algoritma dengan struktur pseudocode :

l1) input (a, b, c)
l2) Jml = a+b+c
l3) Rerata = Jml/3
l4) Output (Rerata)
Flowchart adalah penggambaran secara grafik dari
langkah-langkah dan urut-urutan prosedur dari
suatu program. Flowchart menolong analis dan
programmer untuk memecahkan masalah kedalam
segmen-segmen yang lebih kecil dan menolong
dalam menganalisis alternatif-alternatif lain dalam
pengoperasian.
Kegunaan:
§Untuk mendesain program
§Untuk merepresentasikan program
Maka, flowchart harus dapat

Merepresentasikan komponen-komponen
dalam bahasa pemrograman
a. Relationship
Flowchart dapat memberikan gambaran
yang efektif, jelas, dan ringkas tentang
prosedur logic. Teknik penyajian yang
bersifat grafis jelas akan lebih baik
daripada uraian-uraian yang bersifat teks
khususnya dalam menyajikan logika logika
yang bersifat kompleks.
b. Analysis
Dengan adanya pengungkapan yang jelas
dalam model atau chart, maka para
pembaca dapat dengan mudah melihat
permasalahan atau memfokuskan
perhatian pada area-area tertentu sistem
informasi.
c. Communication
Karena simbol-simbol yang digunakan
mengikuti suatu standar tertentu yang
sudah diakui secara umum, maka
flowchart dapat merupakan alat bantu
yang sangat efektif dalam
mengkomunikasikan logika suatu masalah
atau dalam mendokumentasikan logika
tersebut.
Problem:
Menghitung
Luaspersegipanjang
Algoritma:
1.Masukkanpanjang(p)
2.Masukkanlebar(l)
3.Hitungluas(L),
yaitupanjangkali lebar
4.Cetakluas(L)
Problem:
Menentukan
Bilangan ganjil atau
Genap
Struktur dasar algoritma :
1. Struktur Runtunan (Sequence Proses)
2. Struktur Pemilihan (Selection Proses)
3. Struktur Pengulangan (Iteration Proses)
Sebuah runtunan terdiri dari satu atau lebih
‘instruksi’. Tiap-tiap instruksi dilaksanakan
secara berurutan sesuai dengan urutan
penulisannya; sebuah instruksi baru bisa
dilaksanakan setelah instruksi sebelumnya
selesai dilaksanakan.
Pada struktur ini, jika kondisi terpenuhi
maka salah satu aksi akan dilaksanakan
dan aksi yang ke dua diabaikan.
Kondisi adalah persyaratan yang dapat dinilai benar atau

salah sehingga akan memunculkan ‘aksi’ yang berbeda
dengan ‘kondisi’ yang berbeda.
Notasi algoritmik :
if Syarat then
Aksi {True}
endif {False}
Notasi Algoritma,
IF syarat THEN
aksi-1 {true}
ELSE
aksi-2 {false}
ENDIF
CONTOH :
Menentukan bilangan terbesar diantara 3 bilangan:
‘if’ x > y ‘then’

‘if’ x > z ‘then’
tulis x sebagai bilangan terbesar
‘else’
tulis z sebagai bilangan terbesar
‘else’
‘if’ y > z ‘then’
tulis y sebagai bilangan terbesar
‘else’
tulis z sebagai bilangan terbesar
Digunakan untuk program yang pernyataannya akan
dieksekusi berulang-ulang. Instruksi dikerjakan selama
memenuhi suatu kondisi tertentu. Jika syarat (kondisi)
masih terpenuhi maka pernyataan (aksi) akan terus
dilakukan secara berulang.
For-Next
For var=awal to akhir

…………….
instruksi-instruksi
……………..
Next var
While - do
Bentuk umum :
While {kondisi} do
…………..
instruksi-instruksi
…………..
Endwhile
Repeat - Until
Bentuk Umum ;
Repeat
………………..
Instruksi
………………...
Until (kondisi)
Contoh :
Contoh :
Algoritma Cetak_Angka
Algoritma Cetak_Angka
{mencetak 1, 2, .., 8 ke piranti keluaran}
{mencetak 1, 2, .., 8 ke piranti keluaran}
Deklarasi :
Deklarasi :
K: integer
K: integer
Deskripsi :
Deskripsi :
K 1 {inisialisasi}
K 1 {inisialisasi}
while k <= 8 do
repeat
write (k)
write (k)
k k+1
k k+1
endwhile
until k > 8
1. Buat Algoritma untuk mengecek suatu bilangan positif atau
negatif menggunakan struktur bahasa indonesia,
pseudocode dan flowchart
2. Buat algoritma untuk menampilkan deret angka berikut :
0
2
5
10
26
37
3. Diketahui sebuah algoritma berikut ini :
Deklarasi :
i, m : integer
Deskripsi :
i=0
m=0
while i < 9 then
m= i*i
cetak m
i=i+1
endwhile.
Tulis output yang dihasilkan algoritma di atas !
 Jajat Sudrajat,
http://www.google.co.id/url?sa=t&rct=j&q=syarat%20algoritma%20yang%20baik&sou
rce=web&cd=1&ved=0CBcQFjAA&url=http%3A%2F%2Fyusufhdc.edublogs.org%2Ffi
les%2F2010%2F01%2FPENGANTAR-ALGORITMA_adzet.ppt&ei=K2-
FTryKEOqtiQfYuqCSDw&usg=AFQjCNFR-bfs2ySV6zumBAvRI1tOwM-pvw&cad=rja
Kompleksitas Algoritma
Mengukur efisiensi sebuah Algoritma

Pendahuluan
• Sebuah masalah dapat memiliki beberapa
algoritma penyelesaian. Misalnya untuk
pengurutan (sort)
• Sebuah algoritma tidak saja harus benar,
tetapi juga harus efisien (mangkus)
• Kemangkusan algoritma diukur dari waktu
(time) eksekusi algoritma dan kebutuhan
ruang (space) memori
• Algoritma yang mangkus adalah algoritma
yang meminimumkan kebutuhan ruang
dan waktu
• Kebutuhan waktu dan ruang suatu
algoritma bergantung pada ukuran
masukan (n), yang menyatakan jumlah data
diproses
• Kemangkusan algoritma dapat digunakan
untuk menilai algoritma yang bagus dari
sejumlah algoritma penyelesaian masalah.
Model Perhitungan Kebutuhan Waktu
Menghitung kebutuhan waktu algoritma dengan
mengukur waktu sesungguhnya (dalam satuan
detik) ketika algoritma dieksekusi oleh komputer
bukan cara yang tepat.
Alasan:
1. Setiap komputer dengan arsitektur berbeda
mempunyai bahasa mesin yang berbeda  waktu
setiap operasi antara satu komputer dengan
komputer lain tidak sama.
2. Compiler bahasa pemrograman yang berbeda
menghasilkan kode mesin yang berbeda  waktu
setiap operasi antara compiler dengan compiler lain
tidak sama.
Besaran yang dipakai untuk menerangkan
model abstrak pengukuran waktu/ruang
disebut dengan kompleksitas algoritma
Ada 2 jenis kompleksitas algoritma yaitu
• Kompleksitas waktu T(n), diukur dari
jumlah tahapan komputasi yang
dibutuhkan untuk menjalankan algoritma
sebagai fungsi dari ukuran masukan n
• Kompleksitas ruang S(n), diukur dari
memori yang digunakan oleh struktur data
yang terdapat di dalam algoritma sebagai
fungsi dari ukuran masukan n
Ukuran masukan (n): jumlah data yang
diproses oleh sebuah algoritma.
Contoh:
§ Algoritma pengurutan 1000 elemen larik,
maka n=1000
§ Algoritma perkalian 2 buah matriks
berukuran 50 x 50, maka n = 50
Dalam praktek perhitungan kompleksitas,
ukuran masukan dinyatakan sebagai variabel
n saja
Contoh
Kompleksitas Waktu
• Jumlah tahapan komputasi dihitung dari berapa kali
suatu operasi di dalam sebuah algoritma sebagai fungsi
ukuran masukan
• Di Dalam sebuah algoritma, terdapat bermacam jenis
operasi, misalnya:
– Operasi baca tulis
– Operasi aritmatika
– Operasi pengisian nilai
– Operasi pengaksesan elemen larik
– Operasi pemanggilan fungsi/prosedur
• Dalam praktek, kita hanya menghitung jumlah operasi
khas (tipikal) yang mendasari suatu algoritma
Contoh :
• algoritma untuk menghitung perpangkatan
dua bilangan
• f(x,y)= xy
def pangkat(x, y):
hasil = 1
for i in range(0, y):
hasil = x * hasil
return hasil
• Pada dasarnya yang kita lakukan pada kode
di atas adalah mengkalikan x dengan
dirinya sendiri sebanyak y kali, dan
menyimpan hasil kali tersebut di dalam
variabel hasil.
• Baris hasil = x * hasil melakukan
perkalian x dengan dirinya sendiri, dan
perulangan dilakukan untuk memastikan
baris ini dijalankan sebanyak y kali
Y Proses Jml Langkah
1 2+1 3
10 2 + 10 12
100 2 + 100 102
1000 2 + 1000 1002
10000 2 + 10000 10002
Semakin meningkatnya jumlah y, semakin nilai 2

yang ditambahkan menjadi tidak relevan.
Semakin besar nilai Y, jml eksekusi semakin besar, jadi
bayangkan jika jml eksekusi yg diperlukan Y2
Y Jml Langkah (Y) Jml Langkah (Y2)
1 1 1
10 10 100
100 100 10000
1000 1000 1000000
10000 10000 100000000

Contoh operasi khas di dalam
algoritma
• Algoritma pencarian di dalam larik
Operasi khas: perbandingan elemen larik
• Algoritma pengurutan
Operasi khas: perbandingan elemen dan
pertukaran elemen
• Algoritm penjumlahan 2 buah matriks
Operasi khas: penjumlahan
• Algoritma perkalian 2 buah matriks
Operasi khas: perkalian dan penjumlahan
Tinjau algoritma menghitung rerata sebuah larik.
sum 0
for i  1 to n do
sum  sum + a[i]
endfor
rata_rata  sum/n
• Operasi yang mendasar pada algoritma

tersebut adalah operasi penjumlahan elemen-
e l e m e n a i ( ya i t u s u m  s u m + a [ i ] ) ya n g
dilakukan sebanyak n kali.
• Kompleksitas waktu: T(n) = n.
Kompleksitas waktu dibedakan atas tiga
macam:
1. Tmax(n): Kompleksitas waktu untuk kasus
terburuk (worst case)  kebutuhan waktu
maksimum
2. Tmin(n): Kompleksitas waktu untuk kasus
terbaik (best case)  kebutuhan waktu
minimum
3. Tavg(n): Kompleksitas waktu untuk kasus
rata-rata (average case)  kebutuhan
waktu secara rata-rata
Jumlah operasi perbandingan elemen tabel:
1. Kasus terbaik: ini terjadi bila a1 = x
Tmin(n) = 1
2. Kasus terburuk: bila an = x atau x tidak ditemukan.
Tmax(n) = n
3. Kasus rata-rata: Jika x ditemukan pada posisi ke-j,
maka operasi perbandingan (ak = x) akan
dieksekusi sebanyak j kali.
1
n (1  n )
(1  2  3  ...  n ) 2 ( n  1)
T AVG (n)   
n n 2
Notasi Asimtotik
• Perhitungan pertumbuhan fungsi seperti
yang kita lakukan sebelumnya sangat
krusial dalam menghitung efisiensi sebuah
algoritma
• Penulisan fungsi pertumbuhan dilakukan
dengan menggunakan notasi asimtotik
Jenis Notasi Asimtotik
• Keadaan terbaik (best case)
Dilambangkan dengan notasi (...) dibaca
Theta
• Keadaan rata-rata (average case)

Dilambangkan dengan notasi (...) dibaca
Omega
• Keadaan terburuk (worst case)

Dilambangkan dengan notasi O(...) dibaca Big-
O
Kinerja sebuah algoritma biasanya diukur dengan
menggunakan patokan keadaan terburuk (worst case)
yang dinyatakan dengan Big-O. Big-O dipilih karena
merupakan notasi yang paling populer dan paling banyak
digunakan pada kalangan peneliti ilmu komputer
Fungsi Big-O Nama
O(1) Konstan
O(Log n) Logaritmik
O(n) Linier
O(n log n) n log n
O(n2) Kuadratik
O(nm) Polinomial
O(n!) Faktorial
O(1), Konstan
• Sebuah algoritma yang memiliki
kompleksitas konstan tidak bertumbuh
berdasarkan ukuran dari data atau
masukan yang diterima algoritma tersebut.
Bahkan, algoritma dengan kompleksitas ini
tidak akan bertumbuh sama sekali.
Berapapun ukuran data atau masukan yang
diterima, algoritma dengan kompleksitas
konstan akan memiliki jumlah langkah
yang sama untuk dieksekusi
void add_list(node *anchor, node *new_list)
{
new_list->next = anchor->next;
anchor->next = new_list;
}
• untuk menambahkan elemen baru ke dalam
linked list tidak memerlukan perulangan,
percabangan, ataupun banyak langkah
O(log n): Kompleksitas Logaritmik
• Algoritma dengan kompleksitas logaritmik

merupakan algoritma yang menyelesaikan
masalah dengan membagi-bagi masalah
tersebut menjadi beberapa bagian,
sehingga masalah dapat diselesaikan tanpa
harus melakukan komputasi atau
pengecekan terhadap seluruh masukan
def binary_search(lst, search):
lower_bound = 0
upper_bound = len(lst) - 1
while True:
if upper_bound < lower_bound:
print("Not found.")
return -1
i = (lower_bound + upper_bound) // 2
if lst[i] < search:
lower_bound = i + 1
elif lst[i] > search:
upper_bound = i - 1
else:
print("Element " + str(search) + " in " + str(i))
return 0
1. Langkah yang akan selalu dieksekusi pada
awal fungsi, yaitu inisialisasi lower_bound dan
upper_bound: 2 langkah.
2. Pengecekan kondisi while (pengecekan tetap
dilakukan, walaupun tidak ada perbandingan
yang dijalankan): 1 langkah.
3. Pengecekan awal
(if upper_bound < lower_bound): 1 langkah.
4. Inialisasi i: 1 langkah.
5. Pengecekan kondisi kedua (if lst[i] < search: ...),
kasus terburuk (masuk pada else dan
menjalankan kode di dalamnya): 4 langkah.
Setelah melalui langkah kelima, jika elemen
belum ditemukan maka kita akan kembali ke
langkah kedua. Perhatikan bahwa sejauh ini,
meskipun elemen belum ditemukan atau
dianggap tidak ditemukan, kita minimal harus
menjalankan 2 langkah dan pada setiap
perulangan while kita menjalankan 7 langkah.
Sampai di titik ini, model matematika untuk
fungsi Big-O yang kita dapatkan adalah
seperti berikut:
f(n)=2+7(jumlah perulangan)
Pertanyaan berikutnya, tentunya adalah berapa
kali kita harus melakukan perulangan?
Berhentinya kondisi perulangan ditentukan oleh
dua hal, yaitu:
• Kondisi upper_bound < lower_bound, dan
• Pengujian apakah lst[i] == search, yang
diimplikasikan oleh perintah else.
Perhatikan juga bagaimana baik nilai
upper_bound maupun lower_bound dipengaruhi
secara langsung oleh i, sehingga dapat dikatakan
bahwa kunci dari berhentinya perulangan ada
pada i
Melalui baris kode ini:
i = (lower_bound + upper_bound) / 2
Terlihat bahwa pada setiap iterasinya

nilai i dibagi 2, sehingga untuk setiap
iterasinya kita memotong jumlah data yang
akan diproses (n) sebanyak setengahnya.
Sejauh ini kita memiliki model matematika
seperti berikut (konstanta 2 dihilangkan
karena tidak berpengaruh):
Jika diturunkan lebih lanjut

• kita ketahui kondisi dari pemberhentian
perulangan adalah ketika sisa elemen list
adalah 1
• Artinya :
• Sehingga dapat dikatakan bahwa

binary search memiliki kompleksitas
• Atau sederhananya
O(n): Kompleksitas Linear
• Algoritma dengan kompleksitas linear

bertumbuh selaras dengan pertumbuhan
ukuran data.
• Maka algoritma ini memerlukan 10 langkah
untuk menyelesaikan kalkulasi data
berukuran 10, dan ia akan memerlukan 100
langkah untuk data berukuran 100
Contoh lain dari algoritma dengan
kompleksitas linear adalah linear search
• Linear search melakukan pencarian dengan
menelusuri elemen-elemen dalam list satu
demi satu, mulai dari indeks paling rendah
sampai indeks terakhir
def linear_search(lst, search):
for i in range(0, len(lst)):
if lst[i] == search:
print("Nilai ditemukan pada posisi " + str(i))
return 0
print("Nilai tidak ditemukan.")
return -1
Dengan menggunakan cara perhitungan yang sama pada
perhitungan pangkat, kita bisa mendapatkan jumlah
eksekusi kode seperti berikut (dengan asumsi n = len(lst)):
Sehingga nilai kompleksitas dari linear search adalah (5 + n)

Atau ditulis O(n)
O(n log n)
Algoritma dgn kompleksitas (n log n) memiliki

cara perhitungan yang sangat mirip dengan
algoritma (log n). Pada dasarnya algoritma
kelas ini merupakan algoritma log n yang
dijalankan sebanyak n kali.
Contoh kasus
• misalkan kita diminta untuk mencari
sepasang bilangan di dalam sebuah list
yang jika ditambahkan akan bernilai 0.
Asumsikan list yang diberikan sudah
terurut.
• Salah satu solusi yang paling sederhana
ialah dengan menelusuri seluruh list, satu
demi satu (kompleksitas: n) lalu mencari
elemen yang bernilai invers dari elemen
sekarang menggunakan binary search
(kompleksitas: log n).
def zero_sum(lst):
n = len(lst)
for i in range(0, n):
j = binary_search(lst, -1 * lst[i])
if j > i:
n1 = str(lst[i])
n2 = str(lst[j])
print("Zero sum: " + n1 + " and " + n2 + "\n")
• Perhatikan bagaimana kita melakukan
binary search sebanyak n kali, sehingga
secara sederhana kompleksitas yang akan
kita dapatkan adalah
• n∗ log n=n log n.
O(nm): Kompleksitas Polinomial
• Algoritma dengan kompleksitas polinomial

merupakan salah satu kelas algoritma yang
tidak efisien, karena memerlukan jumlah
langkah penyelesaian yang jauh lebih besar
daripada jumlah data
def kali(a, b):
res = 0
for i in range(a):
for j in range(b):
res += 1
return res
Algoritma di atas melakukan perkalian
antara a dan b, dengan melakukan
penambahan 1 sebanyak b kali, yang hasilnya
ditambahkan sebanyak a kali. Mengabaikan
dua langkah, yaitu awal (res = 0) dan akhir
(return res) kode, kita dapat melihat total
langkah yang diperlukan oleh perulangan
bersarang yang ada seperti berikut:
Total langkah
karena pada setiap iterasi kita harus menjalankan

kode for i in range(b), maka dapat dikatakan
kompleksitas dari kode di atas adalah a * b,
Jika harga a = b maka kompleksitasnya adalah a2
Dengan bentuk umum nm dengan m=2
Perbandingan Pertumbuhan Seluruh
Kompleksitas
n
n! 2
n2
n log n
n
log n
Kesimpulan
• Pengembangan algoritma idealnya diusahakan
mendapatkan kompleksitas O(1) atau O(logn).
Tetapi pada kenyataannya kita tidak akan selalu
mendapatkan kompleksitas terbaik dalam
merancang algoritma.
• Jika tidak dapat mencapai kompleksitas maksimal,
hal terbaik yang dapat kita lakukan ketika
mengembangkan solusi dari masalah adalah
melihat apakah masalah yang ada dapat
diselesaikan dengan algoritma yang ada terlebih
dahulu, sebelum mengembangkan algoritma baru.
Novrina
JENIS STRATEGI ALGORITMA
 Strategi Solusi Langsung
ü Alg. Brute Force
ü Alg Greedy
 Strategi Berbasis Pencarian Pada Ruang Status
ü Teknik DFS (Depth First Search)
ü Teknik BFS (Breadth First search)
ü Alg. Backtracking
ü Alg. Branch and Bound
 Strategi Solusi Atas-Bawah
ü Alg. Devide and Conquer
 Strategi Solusi Bawah-Atas
ü Alg. Dinamic Programming
 Strategi Shortest Path
ü Alg. Djikstra
ü Alg . Floyd-Warshall
Definisi Brute Force
 Brute force adalah sebuah pendekatan yang
langsung (straightforward) untuk memecahkan
suatu masalah, biasanya didasarkan pada
pernyataan masalah (problem statement) dan
definisi konsep yang dilibatkan.
 Algoritma brute force memecahkan masalah

dengan sangat sederhana, langsung dan dengan
cara yang jelas (obvious way).
Contoh-contoh Brute Force
1. Menghitung an (a > 0, n adalah bilangan bulat
tak-negatif)
an = a x a x … x a (n kali) , jika n > 0

=1 , jika n = 0
Algoritma: kalikan 1 dengan a sebanyak n kali

2. Menghitung n! (n bilangan bulat tak-negatif)
n! = 1 × 2 × 3 × … × n , jika n > 0
=1 , jika n = 0
Algoritma: kalikan n buah bilangan, yaitu 1, 2, 3, …,
n, bersama-sama
3. Mengalikan dua buah matrik yang berukuran n
× n.
 Misalkan C = A × B dan elemen-elemen matrik

dinyatakan sebagai cij, aij, dan bij
 Algoritma: hitung setiap elemen hasil perkalian

satu per satu, dengan cara mengalikan dua
vektor yang panjangnya n.
4. Menemukan semua faktor dari bilangan bulat n
selain dari 1 dan n itu sendiri.
 Definisi: Bilangan bulat a adalah faktor dari

bilangan bulat b jika a habis membagi b.
5. Mencari elemen terbesar (atau terkecil)
Persoalan: Diberikan sebuah himpunan yang

beranggotakan n buah bilangan bulat. Bilangan-
bilangan bulat tersebut dinyatakan sebagai a1,
a2, …, an. Carilah elemen terbesar di dalam
himpunan tersebut.
Kompleksitas algoritma ini adalah O(n).
6. Sequential Search
Persoalan: Diberikan n buah bilangan bulat

yang dinyatakan sebagai a1, a2, …, an. Carilah
apakah x terdapat di dalam himpunan bilangan
bulat tersebut. Jika x ditemukan, maka lokasi
(indeks) elemen yang bernilai x disimpan di
dalam peubah idx. Jika x tidak terdapat di
dalam himpunan tersebut, maka idx diisi
dengan nilai 0.
7. Bubble Sort
• Apa metode yang paling lempang dalam

memecahkan masalah pengurutan? Jawabnya adalah
algoritma pengurutan bubble sort.
• Algoritma bubble sort mengimplementasikan teknik

brute force dengan jelas sekali.
8. Uji keprimaan
Persoalan:
Diberikan sebuah bilangan bilangan bulat positif.
Ujilah apakah bilangan tersebut merupakan
bilangan prima atau bukan.
9. Menghitung nilai polinom secara brute force
Persoalan: Hitung nilai polinom
p(x) = anxn + an-1xn-1 + … + a1x + a0
pada titik x = x0.

Kompleksitas algoritma ini adalah O(n2).
Perbaikan (improve):

Karakteristik Algoritma
Brute Force
1. Algoritma brute force umumnya tidak “cerdas” dan tidak
mangkus, karena ia membutuhkan jumlah langkah yang
besar dalam penyelesaiannya. Kadang-kadang algoritma
brute force disebut juga algoritma naif (naïve algorithm).
2. Algoritma brute force seringkali merupakan pilihan yang

kurang disukai karena ketidakmangkusannya itu, tetapi
dengan mencari pola-pola yang mendasar, keteraturan,
atau trik-trik khusus, biasanya akan membantu kita
menemukan algoritma yang lebih cerdas dan lebih
mangkus.
3. Untuk masalah yang ukurannya kecil,
kesederhanaan brute force biasanya lebih
diperhitungkan daripada ketidakmangkusannya.
Algoritma brute force sering digunakan sebagai

basis bila membandingkan beberapa alternatif
algoritma yang mangkus.
4. Algoritma brute force seringkali lebih mudah
diimplementasikan daripada algoritma yang lebih
canggih, dan karena kesederhanaannya, kadang-
kadang algoritma brute force dapat lebih mangkus
(ditinjau dari segi implementasi).
Bubble sort
 Kompleksitas algoritma ini adalah O(n2).

 Adakah algoritma pengurutan elemen elemen yang
lebih mangkus daripada brute force?
Algoritma Divide and
Conquer
• Divide and Conquer dulunya adalah
strategi militer yang dikenal dengan
nama divide ut imperes.
• Sekarang strategi tersebut menjadi

strategi fundamental di dalam ilmu
komputer dengan nama Divide and
Conquer.
Definisi
n Divide: membagi masalah menjadi beberapa
upa-masalah yang memiliki kemiripan dengan
masalah semula namun berukuran lebih kecil
(idealnya berukuran hampir sama),
n Conquer: memecahkan (menyelesaikan)

masing-masing upa-masalah (secara rekursif),
dan
n Combine: mengabungkan solusi masing-masing

upa-masalah sehingga membentuk solusi
masalah semula.
n Obyek permasalahan yang dibagi :
masukan (input) atau instances yang berukuran n
seperti:
- tabel (larik),
- matriks,
- eksponen,
- dll, bergantung pada masalahnya.
n Tiap-tiap upa-masalah mempunyai karakteristik

yang sama (the same type) dengan karakteristik
masalah asal, sehingga metode Divide and Conquer
lebih natural diungkapkan dalam skema rekursif.
Skema Umum Algoritma Divide and Conquer
Penyelesaian dengan Algoritma Brute Force
T(n) = (n – 1) + (n – 1) = 2n – 2 = O(n)
• Ukuran tabel hasil pembagian dapat
dibuat cukup kecil sehingga mencari
minimum dan maksimum dapat
diselesaikan (SOLVE) secara lebih mudah.
• Dalam hal ini, ukuran kecil yang dipilih

adalah 1 elemen atau 2 elemen.
MinMaks(A, n, min, maks)
Algoritma:
1. Untuk kasus n = 1 atau n = 2,
SOLVE: Jika n = 1, maka min = maks = A[n]
Jika n = 2, maka bandingkan kedua elemen untuk
menentukan min dan maks.
2. Untuk kasus n > 2,

(a) DIVIDE: Bagi dua tabel A menjadi dua bagian yang sama,
A1 dan A2
(b) CONQUER:
MinMaks(A1, n/2, min1, maks1)
MInMaks(A2, n/2, min2, maks2)
(c) COMBINE:
if min1 <min2 then min  min1 else min  min2
if maks1 <maks2 then maks  maks2 else maks maks1
Procedure MinMaks2 (Input A: TableInt, i, j: integer, Output min, maks: integer)
Algoritma:
If i = j then
min  maks  A(i)
Else
if (i = j-1) then
if A(i) < A(j) then
maks  A(j); min  A(i)
else
maks  A(i); min  A(j)
endif
else
k  (i+j) div 2
MinMaks2(A, i, k, min1, maks1)
MinMaks2(A, k+1, j, min2, maks2)
if min1 < min2 then
min  min1
else
min  min2
endif
if maks1 < maks 2 then
maks  maks2
else
maks  maks1
endif
endif
endif
Kompleksitas waktu asimptotik:
• MinMaks1 secara brute force :
T(n) = 2n – 2
• MinMaks2 secara divide and conquer:

T(n) = 3n/2 – 2
• Perhatikan: 3n/2 – 2 < 2n – 2 , n  2.
• Kesimpulan: algoritma MinMaks lebih

mangkus dengan metdoe Divide and
Conquer.
3. Algoritma Pengurutan dengan
Metode Divide and Conquer
(a) Merge Sort
Algoritma:
1. Untuk kasus n = 1, maka tabel A sudah terurut
dengan sendirinya (langkah SOLVE).
2. Untuk kasus n > 1, maka

(a) DIVIDE: bagi tabel A menjadi dua bagian,
bagian kiri dan bagian kanan, masing-masing
bagian berukuran n/2 elemen.
(b) CONQUER: Secara rekursif, terapkan
algoritma D-and-C pada masing-masing
bagian.
(c) MERGE: gabung hasil pengurutan kedua
bagian sehingga diperoleh tabel A yang terurut.
(b) Insertion Sort
Prosedur Merge dapat diganti dengan prosedur penyisipan sebuah elemen
pada tabel yang sudah terurut (lihat algoritma Insertion Sort versi iteratif).
Kompleksitas waktu algoritma Insertion Sort:
• Algoritma greedy merupakan metode yang
paling populer untuk memecahkan persoalan
optimasi.
• Persoalan optimasi (optimization problems):

 persoalan mencari solusi optimum.
• Hanya ada dua macam persoalan optimasi:

1. Maksimasi (maximization)
2. Minimasi (minimization)
Contoh persoalan optimasi:
( Masalah Penukaran Uang): Diberikan

uang senilai A. Tukar A dengan koin-koin
uang yang ada. Berapa jumlah minimum
koin yang diperlukan untuk penukaran
tersebut?
 Persoalan minimasi
Contoh 1: tersedia banyak koin 1, 5, 10, 25
• Uang senilai A = 32 dapat ditukar dengan

banyak cara berikut:
32 = 1 + 1 + … + 1 (32 koin)
32 = 5 + 5 + 5 + 5 + 10 + 1 + 1 (7 koin)
32 = 10 + 10 + 10 + 1 + 1 (5 koin)
… dst
• Minimum: 32 = 25 + 5 + 1 + 1 (4 koin)
• Greedy = rakus, tamak, loba, …
• Prinsip greedy: “take what you can get now!”.
• Algoritma greedy membentuk solusi langkah per

langkah (step by step).
• Pada setiap langkah, terdapat banyak pilihan yang

perlu dieksplorasi. Oleh karena itu, pada setiap
langkah harus dibuat keputusan yang terbaik dalam
menentukan pilihan.
• Algoritma greedy adalah algoritma yang
memecahkan masalah langkah per langkah;
pada setiap langkah:

1. mengambil pilihan yang terbaik yang
dapat diperoleh pada saat itu tanpa
memperhatikan konsekuensi ke depan
(prinsip “take what you can get now!”)
2. berharap bahwa dengan memilih optimum

lokal pada setiap langkah akan berakhir
dengan optimum global.
• Tinjau masalah penukaran uang:
Strategi greedy:
Pada setiap langkah, pilihlah koin dengan nilai
terbesar dari himpunan koin yang tersisa.
• Misal: A = 32, koin yang tersedia: 1, 5, 10, dan 25

Langkah 1: pilih 1 buah koin 25 (Total = 25)
Langkah 2: pilih 1 buah koin 5 (Total = 25 + 5 = 30)
Langkah 3: pilih 2 buah koin 1 (Total = 25+5+1+1= 32)
• Solusi: Jumlah koin minimum = 4 (solusi optimal!)

Elemen-elemen algoritma greedy:
1. Himpunan kandidat, C.
2. Himpunan solusi, S
3. Fungsi seleksi (selection function)
4. Fungsi kelayakan (feasible)
5. Fungsi obyektif
Dengan kata lain:

algoritma greedy melibatkan pencarian sebuah
himpunan bagian, S, dari himpunan kandidat, C;
yang dalam hal ini, S harus memenuhi beberapa
kriteria yang ditentukan, yaitu menyatakan suatu solusi
dan S dioptimisasi oleh fungsi obyektif.
Pada masalah penukaran uang:
• Himpunan kandidat: himpunan koin yang
merepresentasikan nilai 1, 5, 10, 25, paling sedikit
mengandung satu koin untuk setiap nilai.
• Himpunan solusi: total nilai koin yang dipilih tepat

sama jumlahnya dengan nilai uang yang ditukarkan.
• Fungsi seleksi: pilihlah koin yang bernilai tertinggi dari

himpunan kandidat yang tersisa.
• Fungsi layak: memeriksa apakah nilai total dari

himpunan koin yang dipilih tidak melebihi jumlah uang
yang harus dibayar.
• Fungsi obyektif: jumlah koin yang digunakan minimum.

Skema umum algoritma greedy:
 Pada akhir setiap lelaran, solusi yang terbentuk adalah optimum lokal.
 Pada akhir kalang while-do diperoleh optimum global.
• Warning: Optimum global belum tentu merupakan solusi
optimum (terbaik), tetapi sub-optimum atau pseudo-
optimum.
• Alasan:
1. Algoritma greedy tidak beroperasi secara menyeluruh
terhadap semua alternatif solusi yang ada
(sebagaimana pada metode exhaustive search).
2. Terdapat beberapa fungsi SELEKSI yang berbeda,

sehingga kita harus memilih fungsi yang tepat jika kita
ingin algoritma menghasilkan solusi optiamal.
• Jadi, pada sebagian masalah algoritma greedy tidak

selalu berhasil memberikan solusi yang optimal.
• Contoh 2: tinjau masalah penukaran uang.
(a) Koin: 5, 4, 3, dan 1

Uang yang ditukar = 7.
Solusi greedy: 7 = 5 + 1 + 1 ( 3 koin)  tidak optimal
Solusi optimal: 7 = 4 + 3 ( 2 koin)
(b) Koin: 10, 7, 1

Uang yang ditukar: 15
Solusi greedy: 15 = 10 + 1 + 1 + 1 + 1 + 1 (6 koin)
Solusi optimal: 15 = 7 + 7 + 1 (hanya 3 koin)
(c) Koin: 15, 10, dan 1

Solusi greedy: 20 = 15 + 1 + 1 + 1 + 1 + 1 (6 koin)
Solusi optimal: 20 = 10 + 10 (2 koin)
• Untuk sistem mata uang dollar AS, euro Eropa,
dan crown Swedia, algoritma greedy selalu
memberikan solusi optimum.
• Contoh: Uang $6,39 ditukar dengan uang kertas

(bill) dan koin sen (cent), kita dapat memilih:
- Satu buah uang kertas senilai $5
- Satu buah uang kertas senilai $1
- Satu koin 25 sen
- Satu koin 10 sen
- Empat koin 1 sen
$5 + $1 + 25c + 10c + 1c + 1c + 1c + 1c = $6,39

• Jika jawaban terbaik mutlak tidak
diperlukan, maka algoritma greedy sering
berguna untuk menghasilkan solusi
hampiran (approximation), daripada
menggunakan algoritma yang lebih rumit
untuk menghasilkan solusi yang eksak.
• Bila algoritma greedy optimum, maka

keoptimalannya itu dapat dibuktikan
secara matematis
1. Masalah penukaran uang
Nilai uang yang ditukar: A
Himpunan koin (multiset): {d1, d2, …, dn}.
Himpunan solusi: X = {x1, x2, …, xn},
xi = 1 jika di dipilih, xi = 0 jika di tidak dipilih.
Penyelesaian dengan exhaustive search
• Terdapat 2n kemungkinan solusi

(nilai-nilai X = {x1, x2, …, xn} )
• Untuk mengevaluasi fungsi obyektif = O(n)
• Kompleksitas algoritma exhaustive search

seluruhnya = O(n  2n ).
Penyelesaian dengan algoritma greedy
• Strategi greedy: Pada setiap langkah, pilih koin dengan nilai terbesar
dari himpunan koin yang tersisa.
• Agar pemilihan koin berikutnya optimal, maka
perlu mengurutkan himpunan koin dalam urutan
yang menurun (noninceasing order).
• Jika himpunan koin sudah terurut menurun,

maka kompleksitas algoritma greedy = O(n).
• Sayangnya, algoritma greedy untuk masalah

penukaran uang ini tidak selalu menghasilkan
solusi optimal (lihat contoh sebelumnya).
n

i 1
2. Minimisasi Waktu di dalam Sistem

(Penjadwalan)
• Persoalan: Sebuah server (dapat berupa processor,

pompa, kasir di bank, dll) mempunai n pelanggan
(customer, client) yang harus dilayani. Waktu pelayanan
untuk setiap pelanggan i adalah ti.
Minimumkan total waktu di dalam sistem:
T= (waktu di dalam sistem)
• Ekivalen dengan meminimumkan waktu rata-rata

pelanggan di dalam sistem.
Contoh 3: Tiga pelanggan dengan
t1 = 5, t2 = 10, t3 = 3,
Enam urutan pelayanan yang mungkin:

============================================
Urutan T
============================================
1, 2, 3: 5 + (5 + 10) + (5 + 10 + 3 ) = 38
1, 3, 2: 5 + (5 + 3) + (5 + 3 + 10) = 31
2, 1, 3: 10 + (10 + 5) + (10 + 5 + 3) = 43
2, 3, 1: 10 + (10 + 3) + (10 + 3 + 5) = 41
3, 1, 2: 3 + (3 + 5) + (3 + 5 + 10) = 29  (optimal)
3, 2, 1: 3 + (3 + 10) + (3 + 10 + 5) = 34
============================================
Penyelesaian dengan Exhaustive Search
• Urutan pelangan yang dilayani oleh server

merupakan suatu permutasi
• Jika ada n orang pelanggan, maka tedapat n!

urutan pelanggan
• Untuk mengevaluasi fungsi obyektif : O(n)
• Kompleksitas algoritma exhaustive search =

O(nn!)
• Strategi greedy: Pada setiap langkah, pilih pelanggan yang
membutuhkan waktu pelayanan terkecil di antara pelanggan lain
yang belum dilayani.
• Agar proses pemilihan pelanggan berikutnya optimal,
urutkan pelanggan berdasarkan waktu pelayanan dalam
urutan yang menaik.
• Jika pelanggan sudah terurut, kompleksitas algoritma

greedy = O(n).
• Algoritma greedy untuk penjadwalan pelanggan
akan selalu menghasilkan solusi optimum.
• Teorema. Jika t1  t2  …  tn maka pengurutan

ij = j, 1  j  n meminimumkan
T=
untuk semua kemungkinan permutasi ij.

3. Integer Knapsack (0/1 Knapsack)
• Sudah dijelaskan pada pembahasan

exhaustive search.
• Kompleksitas algoritma exhaustive search

untuk persoalan ini = O(n  2n).
• Masukkan objek satu per satu ke dalam

knapsack. Sekali objek dimasukkan ke
dalam knapsack, objek tersebut tidak bisa
dikeluarkan lagi.
• Terdapat beberapa strategi greedy yang

heuristik yang dapat digunakan untuk
memilih objek yang akan dimasukkan ke
dalam knapsack:
1. Greedy by profit.
- Pada setiap langkah, pilih objek yang
mempunyai keuntungan terbesar.
- Mencoba memaksimumkan keuntungan
dengan memilih objek yang paling
menguntungkan terlebih dahulu.
2. Greedy by weight.
- Pada setiap langkah, pilih objek yang
mempunyai berat teringan.
- Mencoba memaksimumkan keuntungan
dengan dengan memasukkan sebanyak mungkin
objek ke dalam knapsack.
3. Greedy by density.
- Pada setiap langkah, knapsack diisi dengan objek
yang mempunyai pi /wi terbesar.
- Mencoba memaksimumkan keuntungan dengan
memilih objek yang mempunyai keuntungan
per unit berat terbesar.
• Pemilihan objek berdasarkan salah satu dari

ketiga strategi di atas tidak menjamin akan
memberikan solusi optimal.
Contoh 4.
w1 = 6; p1 = 12; w2 = 5; p1 = 15;
w3 = 10; p1 = 50; w4 = 5; p1 = 10
Kapasitas knapsack K = 16
• Solusi optimal: X = (0, 1, 1, 0)

• Greedy by profit dan greedy by density memberikan solusi optimal!
Contoh 5.
w1 = 100; p1 = 40; w2 = 50; p2 = 35; w3 = 45; p3 = 18;
w4 = 20; p4 = 4; w5 = 10; p5 = 10; w6 = 5; p6 = 2
Kapasitas knapsack K = 100
Ketiga strategi gagal memberikan solusi optimal!

Kesimpulan: Algoritma greedy tidak
selalu berhasil menemukan solusi optimal
untuk masalah 0/1 Knapsack.
4. Fractional Knapsack
• Oleh karena 0  xi  1, maka terdapat

tidak berhinga nilai-nilai xi.
• Persoalan Fractional Knapsack menjadi

malar (continuous) sehingga tidak
mungkin dipecahkan dengan algoritma
exhaustive search.
• Ketiga strategi greedy yang telah

disebutkan di atas dapat digunakan untuk
memilih objek yang akan dimasukkan ke
dalam knapsack.
Contoh 6.
w1 = 18; p1 = 25; w2 = 15; p1 = 24
w3 = 10; p1 = 15 Kapasitas knapsack K = 20
 Solusi optimal: X = (0, 1, 1/2)

 yang memberikan keuntungan maksimum = 31,5.
• Strategi pemilihan objek berdasarkan densitas pi
/wi terbesar akan selalu memberikan solusi
optimal.
• Agar proses pemilihan objek berikutnya optimal,

maka kita urutkan objek berdasarkan pi /wi yang
menurun, sehingga objek berikutnya yang dipilih
adalah objek sesuai dalam urutan itu.
Teorema 3.2. Jika p1/w1  p2/w2  ...  pn/wn

maka algoritma greedy dengan strategi
pemilihan objek berdasarkan pi /wi terbesar
menghasilkan solusi yang optimum.
• Algoritma persoalan fractional knapsack:
1. Hitung harga pi/wi , i = 1, 2, ..., n

2. Urutkan seluruh objek berdasarkan
nilai pi/wi dari besar ke kecil
3. Panggil FractinonalKnapsack
Kompleksitas waktu algoritma = O(n).
SESSION #1
ALGORITHM
Analysis & Design
With
Dr. Mufid Nilmada, SSi., MMSI

WHY?
WHY?
WHY?
https://norbertbiedrzycki.pl/en/only-god-can-
count-that-fast-the-world-of-quantum-computing/
TUGAS #1 :
Daftar keanggotaan perpustakaan nasional via online
http://keanggotaan.perpusnas.go.id/daftar.aspx
dengan menunjukkan bukti screenshot konfirmasi
keanggotaan.
TUGAS #1 :
MILIKI BUKU AJAR/TEXT-BOOK UNTUK MATA
KULIAH PAA, PILIH SALAH SATU DARI 3 BUKU INI,
MILIKI KETIGANYA LEBIH BAIK :
Introduction to Algorithms
by Thomas H. Cormen, Charles
E. Leiserson, Ronald L.
Rivest, Clifford Stein
TUGAS #1 :
Discrete Mathematics and Its

Applications Seventh Edition
(Higher Math) 7th Edition
by Kenneth H Rosen
TUGAS #1 :
An Introduction to the Analysis of

Algorithms 2nd Edition,
by : Robert Sedgewick, Philippe

Flajolet
Rinaldi M/IF2120 Matdis 27
Pendahuluan
Sebuah masalah dapat mempunyai banyak algoritma
penyelesaian. Contoh: masalah pengurutan (sort),
ada puluhan algoritma pengurutan
Sebuah algoritma tidak saja harus benar, tetapi juga

harus mangkus (efisien).
Algoritma yang bagus adalah algoritma yang

mangkus (efficient).
Kemangkusan algoritma diukur dari waktu (time)

eksekusi algoritma dan kebutuhan ruang (space)
memori.

Algoritma yang mangkus ialah algoritma yang
meminimumkan kebutuhan waktu dan ruang.
Kebutuhan waktu dan ruang suatu algoritma

bergantung pada ukuran masukan (n), yang
menyatakan jumlah data yang diproses.
Kemangkusan algoritma dapat digunakan

untuk menilai algoritma yang bagus dari
sejumlah algoritma penyelesaian masalah.

Mengapa kita memerlukan algoritma yang
mangkus? Lihat grafik di bawah ini.
10-4 x 2n
Waktu komputasi (dalam detik)
105 1 hari 10-6 x 2n
104
1 jam
103 10-4 x n3
102
1 menit
10 10-6 x n3
1 detik
1
5 10 15 20 25 30 35 40
10-1 Ukuran masukan

Model Perhitungan Kebutuhan Waktu
Menghitung kebutuhan waktu algoritma dengan
mengukur waktu sesungguhnya (dalam satuan detik)
ketika algoritma dieksekusi oleh komputer bukan
cara yang tepat.
Alasan:
1. Setiap komputer dengan arsitektur berbeda mempunyai
bahasa mesin yang berbeda  waktu setiap operasi
antara satu komputer dengan komputer lain tidak sama.
2. Compiler bahasa pemrograman yang berbeda

menghasilkan kode mesin yang berbeda  waktu setiap
operasi antara compiler dengan compiler lain tidak sama.

Model abstrak pengukuran waktu/ruang
harus independen dari pertimbangan mesin
dan compiler apapun.
Besaran yang dipakai untuk menerangkan

model abstrak pengukuran waktu/ruang ini
adalah kompleksitas algoritma.
Ada dua macam kompleksitas algoritma,

yaitu: kompleksitas waktu dan
kompleksitas ruang.

Kompleksitas waktu, T(n), diukur dari jumlah tahapan
komputasi yang dibutuhkan untuk menjalankan
algoritma sebagai fungsi dari ukuran masukan n.
Kompleksitas ruang, S(n), diukur dari memori yang

digunakan oleh struktur data yang terdapat di dalam
algoritma sebagai fungsi dari ukuran masukan n.
Dengan menggunakan besaran kompleksitas

waktu/ruang algoritma, kita dapat menentukan laju
peningkatan waktu (ruang) yang diperlukan algoritma
dengan meningkatnya ukuran masukan n.

Ukuran masukan (n): jumlah data yang diproses oleh
sebuah algoritma.
Contoh: algoritma pengurutan 1000 elemen larik,

maka n = 1000.
Contoh: algoritma TSP pada sebuah graf lengkap

dengan 100 simpul, maka n = 100.
Contoh: algoritma perkalian 2 buah matriks

berukuran 50 x 50, maka n = 50.
Dalam praktek perhitungan kompleksitas, ukuran

masukan dinyatakan sebagai variabel n saja.

Kompleksitas Waktu
Jumlah tahapan komputasi dihitung dari berapa kali
suatu operasi dilaksanakan di dalam sebuah
algoritma sebagai fungsi ukuran masukan (n)..
Di dalam sebuah algoritma terdapat bermacam jenis

operasi:
Operasi baca/tulis
Operasi aritmetika (+, -, *, /)
Operasi pengisian nilai (assignment)
Operasi pengakasesan elemen larik
Operasi pemanggilan fungsi/prosedur
dll
Dalam praktek, kita hanya menghitung jumlah operasi

khas (tipikal) yang mendasari suatu algoritma.

Contoh operasi khas di dalam algoritma
Algoritma pencarian di dalam larik
Operasi khas: perbandingan elemen larik
Algoritma pengurutan
Operasi khas: perbandingan elemen, pertukaran
elemen
Algoritma penjumlahan 2 buah matriks

Operasi khas: penjumlahan
Algoritma perkalian 2 buah matriks

Operasi khas: perkalian dan penjumlahan

Contoh 1. Tinjau algoritma menghitung rerata
sebuah larik (array).
sum 0
for i  1 to n do
sum  sum + a[i]
endfor
rata_rata  sum/n
Operasi yang mendasar pada algoritma tersebut

adalah operasi penjumlahan elemen-elemen ai (yaitu
sumsum+a[i]) yang dilakukan sebanyak n kali.
Kompleksitas waktu: T(n) = n.

Contoh 2. Algoritma untuk mencari elemen terbesar di dalam
sebuah larik (array) yang berukuran n elemen.
procedure CariElemenTerbesar(input a1, a2, ..., an : integer, output

maks : integer)
{ Mencari elemen terbesar dari sekumpulan elemen larik integer a1, a2,
..., an.
Elemen terbesar akan disimpan di dalam maks.
Masukan: a1, a2, ..., an
Keluaran: maks (nilai terbesar)
}
Deklarasi
k : integer
Algoritma
maksa1
k2
while k  n do
if ak > maks then
maksak
endif
ii+1
endwhile
{ k > n }
Kompleksitas waktu algoritma dihitung berdasarkan jumlah

operasi perbandingan elemen larik (A[i] > maks).
Kompleksitas waktu CariElemenTerbesar : T(n) = n – 1.

Kompleksitas waktu dibedakan atas tiga macam :
1. Tmax(n) : kompleksitas waktu untuk kasus terburuk (worst case),
 kebutuhan waktu maksimum.
2. Tmin(n) : kompleksitas waktu untuk kasus terbaik (best case),
 kebutuhan waktu minimum.
3. Tavg(n): kompleksitas waktu untuk kasus rata-rata (average case)
 kebutuhan waktu secara rata-rata

Contoh 3. Algoritma sequential search.
procedure PencarianBeruntun(input a1, a2, ..., an : integer, x : integer,

output idx : integer)
Deklarasi
k : integer
ketemu : boolean { bernilai true jika x ditemukan atau false jika x
tidak ditemukan }
Algoritma:
k1
ketemu  false
while (k  n) and (not ketemu) do
if ak = x then
ketemutrue
else
k  k + 1
endif
endwhile
{ k > n or ketemu }
if ketemu then { x ditemukan }

idxk
else
idx 0 { x tidak ditemukan }
endif

Jumlah operasi perbandingan elemen tabel:
1. Kasus terbaik: ini terjadi bila a1 = x.

Tmin(n) = 1
2. Kasus terburuk: bila an = x atau x tidak ditemukan.
Tmax(n) = n
3. Kasus rata-rata: Jika x ditemukan pada posisi ke-j, maka operasi

perbandingan (ak = x)akan dieksekusi sebanyak j kali.
1
n(1  n)
(1  2  3  ...  n) 2 (n  1)
Tavg(n) =  
n n 2

Cara lain: asumsikan bahwa P(aj = x) = 1/n. Jika aj = x maka Tj
yang dibutuhkan adalah Tj = j. Jumlah perbandingan elemen larik
rata-rata:
n n 1 1 n
Tavg(n) =  T j P( A[ j ]  X )   T j   T j
j 1 j 1 n n j 1
1 n 1 n(n  1) n 1
=  = j ( ) 
n j 1 n 2 2

Contoh 4. Algoritma pencarian biner (bynary search).
procedure PencarianBiner(input a1, a2, ..., an : integer, x : integer,

output idx : integer)
Deklarasi
i, j, mid : integer
ketemu : boolean
Algoritma
i1
jn
ketemufalse
while (not ketemu) and ( i  j) do
mid  (i+j) div 2
if amid = x then
ketemu  true
else
if amid < x then { cari di belahan kanan }
imid + 1
else { cari di belahan kiri }
jmid - 1;
endif
endif
endwhile
{ketemu or i > j }
if ketemu then
idxmid
else
idx0
endif

1. Kasus terbaik
Tmin(n) = 1
2. Kasus terburuk:
Tmax (n) = 2log n + 1

Contoh 5. Algoritma pengurutan seleksi (selection sort).
procedure Urut(input/output a1, a2, ..., an : integer)

Deklarasi
i, j, imaks, temp : integer
Algoritma
for in downto 2 do { pass sebanyak n – 1 kali }
imaks1
for j2 to i do
if aj > aimaks then
imaksj
endif
endfor
{ pertukarkan aimaks dengan ai }
tempai
aiaimaks
aimakstemp
endfor

(i) Jumlah operasi perbandingan elemen
Untuk setiap pass ke-i,
i=n  jumlah perbandingan = n – 1
i = n – 1  jumlah perbandingan = n – 2
i=n–2  jumlah perbandingan = n – 3

i = 2  jumlah perbandingan = 1
Jumlah seluruh operasi perbandingan elemen-elemen larik adalah

n 1
n(n  1)
T(n) = (n – 1) + (n – 2) + … + 1 =  n  k 
i 1 2
Ini adalah kompleksitas waktu untuk kasus terbaik dan terburuk,

karena algoritma Urut tidak bergantung pada batasan apakah data
masukannya sudah terurut atau acak.

(ii) Jumlah operasi pertukaran
Untuk setiap i dari 1 sampai n – 1, terjadi satu kali pertukaran
elemen, sehingga jumlah operasi pertukaran seluruhnya adalah
T(n) = n – 1.
Jadi, algoritma pengurutan seleksi membutuhkan n(n – 1 )/2 buah

operasi perbandingan elemen dan n – 1 buah operasi pertukaran.

Latihan
Contoh 6. Hitung kompleksitas waktu algoritma berikut
berdasarkan jumlah operasi kali.
procedure Kali(input x:integer, n:integer, output jumlah : integer)

{Mengalikan x dengan i = 1, 2, …, j, yang dalam hal ini j = n, n/2, n/4, …,1
Masukan: x dan n (n adalah perpangakatan dua).
Keluaran: hasil perkalian (disimpan di dalam peubah jumlah).
}
Deklarasi
i, j, k : integer
Algoritma
j  n
while j  1 do
for i  1 to j do
x  x * i
endfor
j  d div 2
endwhile
{ j > 1 }
jumlahx

Jawaban
Untuk
j = n, jumlah operasi perkalian = n
j = n/2, jumlah operasi perkalian = n/2
j = n/4, jumlah operasi perkalian = n/4
…
j = 1, jumlah operasi perkalian = 1
Jumlah operasi perkalian seluruhnya adalah
= n + n/2 + n/4 + … + 2 + 1  deret geometri
2
log n 1
n(1  2 )
=  2(n  1)
1
1
2

Kompleksitas Waktu Asimptotik
 Tinjau T(n) = 2n2 + 6n + 1
Perbandingan pertumbuhan T(n) dengan n2
n T(n) = 2n2 + 6n + 1 n2
10 261 100
100 2061 1000
1000 2.006.001 1.000.000
10.000 2.000.060.001 1.000.000.000
 Untuk n yang besar, pertumbuhan T(n) sebanding dengan n2.

Pada kasus ini, T(n) tumbuh seperti n2 tumbuh.
 T(n) tumbuh seperti n2 tumbuh saat n bertambah. Kita

katakan bahwa T(n) berorde n2 dan kita tuliskan
T(n) = O(n2)
Notasi “O” disebut notasi “O-Besar” (Big-O) yang merupakan
notasi kompleksitas waktu asimptotik.
DEFINISI. T(n) = O(f(n)) (dibaca “T(n) adalah O(f(n)” yang

artinya T(n) berorde paling besar f(n) ) bila terdapat konstanta C
dan n0 sedemikian sehingga
T(n)  C(f (n))
untuk n  n0.
f(n) adalah batas lebih atas (upper bound) dari T(n) untuk n yang
besar.

Cf(n)
T(n)
n0 n

Contoh 7. Tunjukkan bahwa T(n) = 2n2 + 6n + 1 = O(n2).
Penyelesaian:
2n2 + 6n + 1 = O(n2)
karena
2n2 + 6n + 1  2n2 + 6n2 + n2 = 9n2 untuk semua n  1 (C =9

dan n0 = 1).
atau karena
2n2 + 6n + 1  n2 + n2 + n2 = 3n2 untuk semua n  6 (C =3

dan n0 = 6).

Contoh 8. Tunjukkan bahwa T(n) = 3n + 2 = O(n).
Penyelesaian:
3n + 2 = O(n)
karena
3n + 2  3n + 2n = 5n untuk semua n  1 (C = 5 dan n0 = 1).

Contoh-contoh Lain
1. Tunjukkan bahwa T(n) = 5 = O(1).
Penyelesaian:
5 = O(1) karena 5  6.1 untuk n  1.
(C = 6 dan n0 = 1)
Kita juga dapat memperlihatkan bahwa
5 = O(1) karena 5  10  1 untuk n  1

2. Tunjukkan bahwa kompleksitas waktu
algoritma pengurutan seleksi (selection sort)
adalah T(n) = n(n – 1)/2 =O (n2).
Penyelesaian:
n(n – 1)/2 =O (n2) karena
n(n – 1)/2  n2/2 + n2/2 = n2
untuk semua n  1 (C = 1 dan n0 = 1).

3. Tunjukkan T(n) = 6*2n + 2n2 = O(2n)
Penyelesaian:
6*2n + 2n2 = O(2n) karena
6*2n + 2n2  6*2n + 2*2n = 8*2n
untuk semua n  1 (C = 8 dan n0 = 1).

4. Tunjukkan T(n) = 1 + 2 + .. + n = O(n2)
Penyelesaian:
1 + 2 + .. + n  n + n + … + n = n2 untuk n  1
5. Tunjukkan T(n) = n! = O(nn)
Penyelesaian:
n! = 1 . 2 . … . n  n . n . … . n =nn untuk n  1

Teorema: Bila T(n) = am nm + am-1 nm-1 + ... + a1n+
a0 adalah polinom derajat m maka T(n) = O(nm ).
Jadi, cukup melihat suku (term) yang mempunyai

pangkat terbesar.
Contoh:
T(n) = 5 = 5n0 = O(n0) = O(1)
T(n) = n(n – 1)/2 = n2/2 – n/2 = O(n2)
T(n) = 3n3 + 2n2 + 10 = O(n3)

Teorema tersebut digeneralisasi untuk suku
dominan lainnya:
1. Eksponensial mendominasi sembarang
perpangkatan (yaitu, yn > np , y > 1)
2. Perpangkatan mendominasi ln n (yaitu n p > ln n)
3. Semua logaritma tumbuh pada laju yang sama
(yaitu a log(n) = b log(n)
4. n log n tumbuh lebih cepat daripada n tetapi lebih
lambat daripada n2
Contoh: T(n) = 2n + 2n2 = O(2n).

T(n) = 2n log(n) + 3n = O(n log(n))
T(n) = log(n3) = 3 log(n) = O(log(n))
T(n) = 2n log(n) + 3n2 = O(n2)

Perhatikan….(1)
Tunjukkan bahwa T(n) = 5n2 = O(n3), tetapi
T(n) = n3  O(n2).
Penyelesaian:
5n2 = O(n3) karena 5n2  n3 untuk semua n  5.
Tetapi, T(n) = n3  O(n2) karena tidak ada

konstanta C dan n0 sedemikian sehingga
n3  Cn2  n  C untuk semua n0 karena n
dapat berupa sembarang bilangan yang besar.

Perhatikan …(2)
Defenisi: T(n) = O(f(n) jika terdapat C dan n0
sedemikian sehingga T(n)  C.f(n) untuk n  n0
 tidak menyiratkan seberapa atas fungsi f itu.
Jadi, menyatakan bahwa

T(n) = 2n2 = O(n2)  benar
T(n) = 2n2 = O(n3)  juga benar
T(n) = 2n2 = O(n4)  juga benar
Namun, untuk alasan praktis kita memilih fungsi yang
sekecil mungkin agar O(f(n)) memiliki makna
Jadi, kita menulis 2n2 = O(n2), bukan O(n3) atau O(n4)

TEOREMA. Misalkan T1(n) = O(f(n)) dan T2(n) = O(g(n)), maka
(a) T1(n) + T2(n) = O(f(n)) + O(g(n)) = O(max(f(n), g(n))
(b) T1(n)T2(n) = O(f(n))O(g(n)) = O(f(n)g(n))
(c) O(cf(n)) = O(f(n)), c adalah konstanta
(d) f(n) = O(f(n))
Contoh 9. Misalkan T1(n) = O(n) dan T2(n) = O(n2), maka

(a) T1(n) + T2(n) = O(max(n, n2)) = O(n2)
(b) T1(n)T2(n) = O(n.n2) = O(n3)
Contoh 10. O(5n2) = O(n2)

n2 = O(n2)

Pengelompokan Algoritma Berdasarkan Notasi O-Besar
Kelompok Algoritma Nama

O(1) konstan
O(log n) logaritmik
O(n) lanjar
O(n log n) n log n
O(n2) kuadratik
O(n3) kubik
O(2n) eksponensial
O(n!) faktorial
Urutan spektrum kompleksitas waktu algoritma adalah :
O(1)  O(log n)  O(n)  O(n log n)  O(n 2 )  O(n 3 )  ...  O(2 n )  O(n!)
  
algoritma polinomial algoritma eksponensial

Penjelasan masing-masing kelompok algoritma adalah sebagai
berikut:
O(1) Kompleksitas O(1) berarti waktu pelaksanaan algoritma

adalah tetap, tidak bergantung pada ukuran masukan.
Contohnya prosedur tukar di bawah ini:
procedure tukar(var a:integer; var b:integer);
var
temp:integer;
begin
temp:=a;
a:=b;
b:=temp;
end;
Di sini jumlah operasi penugasan (assignment) ada tiga buah dan

tiap operasi dilakukan satu kali. Jadi, T(n) = 3 = O(1).

O(log n) Kompleksitas waktu logaritmik berarti laju pertumbuhan
waktunya berjalan lebih lambat daripada pertumbuhan n.
Algoritma yang termasuk kelompok ini adalah algoritma
yang memecahkan persoalan besar dengan
mentransformasikannya menjadi beberapa persoalan yang
lebih kecil yang berukuran sama (misalnya algoritma
pencarian_biner). Di sini basis algoritma tidak
terlalu penting sebab bila n dinaikkan dua kali semula,
misalnya, log n meningkat sebesar sejumlah tetapan.

O(n) Algoritma yang waktu pelaksanaannya lanjar umumnya
terdapat pada kasus yang setiap elemen masukannya
dikenai proses yang sama, misalnya algoritma
pencarian_beruntun. Bila n dijadikan dua kali
semula, maka waktu pelaksanaan algoritma juga dua kali
semula.

O(n log n) Waktu pelaksanaan yang n log n terdapat pada
algoritma yang memecahkan persoalan menjadi beberapa
persoalan yang lebih kecil, menyelesaikan tiap persoalan
secara independen, dan menggabung solusi masing-
masing persoalan. Algoritma yang diselesaikan dengan
teknik bagi dan gabung mempunyai kompleksitas
asimptotik jenis ini. Bila n = 1000, maka n log n mungkin
20.000. Bila n dijadikan dua kali semual, maka n log n
menjadi dua kali semula (tetapi tidak terlalu banyak)

O(n2) Algoritma yang waktu pelaksanaannya kuadratik hanya
praktis digunakan untuk persoalana yang berukuran kecil.
Umumnya algoritma yang termasuk kelompok ini
memproses setiap masukan dalam dua buah kalang
bersarang, misalnya pada algoritma urut_maks. Bila n =
1000, maka waktu pelaksanaan algoritma adalah
1.000.000. Bila n dinaikkan menjadi dua kali semula,
maka waktu pelaksanaan algoritma meningkat menjadi
empat kali semula.

O(n3) Seperti halnya algoritma kuadratik, algoritma kubik
memproses setiap masukan dalam tiga buah kalang
bersarang, misalnya algoritma perkalian matriks. Bila n =
100, maka waktu pelaksanaan algoritma adalah 1.000.000.
Bila n dinaikkan menjadi dua kali semula, waktu
pelaksanan algoritma meningkat menjadi delapan kali
semula.

O(2n) Algoritma yang tergolong kelompok ini mencari solusi
persoalan secara "brute force", misalnya pada algoritma
mencari sirkuit Hamilton (lihat Bab 9). Bila n = 20, waktu
pelaksanaan algoritma adalah 1.000.000. Bila n dijadikan
dua kali semula, waktu pelaksanaan menjadi kuadrat kali
semula!

O(n!) Seperti halnya pada algoritma eksponensial, algoritma
jenis ini memproses setiap masukan dan
menghubungkannya dengan n - 1 masukan lainnya,
misalnya algoritma Persoalan Pedagang Keliling
(Travelling Salesperson Problem - lihat bab 9). Bila n = 5,
maka waktu pelaksanaan algoritma adalah 120. Bila n
dijadikan dua kali semula, maka waktu pelaksanaan
algoritma menjadi faktorial dari 2n.

Nilai masing-masing fungsi untuk setiap bermacam-macam nilai n
log n n n log n n2 n3 2n n!
0 1 0 1 1 2 1
1 2 2 4 8 4 2
2 4 8 16 64 16 24
3 9 24 64 512 256 362880
4 16 64 256 4096 65536 20922789888000
5 32 160 1024 32768 4294967296 (terlalu besar )

Kegunaan Notasi Big-Oh
Notasi Big-Oh berguna untuk membandingkan
beberapa algoritma dari untuk persoalan yang sama
 menentukan yang terbaik.
Contoh: masalah pengurutan memiliki banyak

algoritma penyelesaian,
Selection sort, insertion sort  T(n) = O(n2)
Quicksort  T(n) = O(n log n)
Karena n log n < n2 untuk n yang besar, maka

algoritma quicksort lebih cepat (lebih baik, lebih
mangkus) daripada algoritma selection sort dan
insertion sort.

Notasi Omega-Besar dan
Tetha-Besar
Definisi -Besar adalah:
T(n) = (g(n)) (dibaca “T(n) adalah Omega (g(n)” yang

artinya T(n) berorde paling kecil g(n) ) bila terdapat tetapan C
dan n0 sedemikian sehingga
T(n)  C g(n)
untuk n  n0.
Definisi -Besar,
T(n) = (h(n)) (dibaca “T(n) adalah tetha h(n)” yang artinya

T(n) berorde sama dengan h(n) jika T(n) = O(h(n)) dan T(n) =
(h(n)).
Contoh: Tentukan notasi  dan  untuk T(n) = 2n2 + 6n + 1.
Jawab:
Karena 2n2 + 6n + 1  2n2 untuk n  1,
maka dengan C = 2 kita memperoleh
2n2 + 6n + 1 = (n2)
Karena 2n2 + 5n + 1 = O(n2) dan 2n2 + 6n + 1 = (n2),

maka 2n2 + 6n + 1 = (n2).

Contoh: Tentukan notasi notasi O,  dan  untuk T(n) = 5n3 + 6n2
log n.
Jawab:
Karena 0  6n2 log n  6n3, maka 5n3 + 6n2 log n  11n3 untuk n 
1. Dengan mengambil C = 11, maka
5n3 + 6n2 log n = O(n3)
Karena 5n3 + 6n2 log n  5n3 untuk n  1, maka maka dengan

mengambil C = 5 kita memperoleh
5n3 + 6n2 log n = (n3)
Karena 5n3 + 6n2 log n = O(n3) dan 5n3 + 6n2 log n = (n3), maka
5n3 + 6n2 log n = (n3)

Contoh: Tentukan notasi notasi O,  dan  untuk T(n) = 1 + 2 +
… + n.
Jawab:
1 + 2 + … + n = O(n2) karena
1 + 2 + … + n  n + n + … + n = n2 untuk n  1.
1 + 2 + … + n = (n) karena
1 + 2 + … + n  1 + 1 + … + 1 = n untuk n  1.
1 + 2 + … + n  n/2 + … + (n – 1) + n
 n/2 + … + n/2 + n/2
= (n + 1)/2 n/2
 (n/2)(n/2)
= n2/4
Kita menyimpulkan bahwa
1 + 2 + … + n = (n2)
Oleh karena itu,
1 + 2 + … + n = (n2)
Latihan
Tentukan kompleksitas waktu dari algoritma
dibawah ini jika melihat banyaknya operasi a←a+1
for i ← 1 to n do
for j ← 1 to i do
for k ← j to n do
a ← a + 1
endfor
endfor
endfor
Tentukan pula nilai O-besar, Ω-besar, dan Θ-besar

dari algoritma diatas (harus penjelasan)

Jawaban
Untuk i = 1,
Untuk j = 1, jumlah perhitungan = n kali
Untuk i = 2,
Untuk j = 2, jumlah perhitungan = n – 1 kali
...
Untuk i = n,
Untuk j = 2, jumlah perhitungan = n – 1 kali
...
Untuk j = n, jumlah perhitungan = 1 kali.
Jadi jumlah perhitungan = T(n) = n2 + (n – 1)2 + (n – 2)2 + ... + 1

T(n) = O(n3) = Ω(n3) = Θ(n3).
Salah satu cara penjelasan:

T(n) = n2 + (n – 1)2 + (n – 2)2 + ... + 1
= n(n + 1)(2n + 1)/6
= 2n3 + 3n2 + 1.
Diperoleh T(n) ≤ 3n3 untuk n ≥ 4 dan

T(n) ≥ 2n3 untuk n ≥ 1.

TEOREMA. Bila T(n) = am nm + am-1 nm-1 +
... + a1n+ a0 adalah polinom derajat m maka
T(n) adalah berorde nm.

Latihan Soal
Di bawah ini adalah algoritma (dalam notasi Pascal-like) untuk menguji apakah dua buah matriks, A dan B,
yang masing-masing berukuran n  n, sama.
function samaMatriks(A, B : matriks; n : integer)  boolean
{ true jika A dan B sama; sebaliknya false jika A  B }
Deklarasi
i, j : integer
Algoritma:
for i  1 to n do
for j  1 to n do
if Ai,j  Bi,j then
return false
endif
endfor
endfor
return true
(a) Apa kasus terbaik dan terburuk untuk algoritma di atas?

(b) Tentukan kompleksitas waktu terbaik dan terburuk dalam notasi O.

2. Berapa kali instruksi assignment pada potongan
program dalam notas Bahasa Pascal di bawah ini
dieksekusi? Tentukan juga notasi O-besar.
for i := 1 to n do
for j := 1 to n do
for k := 1 to j do
x := x + 1;
Jawaban: T(n) = n(1 + 2 + … + n)

= n(n(n+1)/2)= (n3 + n2)/2 = O(n3)

3. Untuk soal (a) dan (b) berikut, tentukan C, f (n), n0, dan
notasi O-besar sedemikian sehingga T(n) = O(f(n)) jika T(n)
 C  f(n) untuk semua n  n0:
(a) T(n) = 2 + 4 + 6 + … + 2n
(b) T(n) = (n + 1)(n + 3)/(n + 2)
Jawaban:
(a) 2 + 4 + 6 … + 2n = 2(1 + 2 + 3 + … + n)
 2(n + n + n + … + n) untuk n ≥ 1
= 2n2 = O(n2)
(b) (n + 1)(n + 3)/(n + 2) =(n2 + 4n + 3)/(n + 2)
 8n untuk n ≥ 1
= O(n)
4. Algoritma di bawah ini menghitung nilai polinom:
p(x) = a0 + a1x + a2x2 + … + anxn
function p(input x:real)real
{ Mengembalikan nilai p(x)}
Deklarasi
j, k : integer
jumlah, suku : real
Algoritma
jumlah  a0
for j  1 to n do
{ hitung ajxj }
suku  aj
for k  1 to j do
suku  suku * x
endfor
jumlah  jumlah + suku
endfor
return jumlah
Hitunglah berapa operasi perkalian dan berapa operasi penjumlahan

yang dilakukan oleh algoritma di atas? Jumlahkan kedua hitungan
tersebut, lalu tentukan juga kompleksitas waktu asimptotik algoritma
tersebut dalam notasi O-Besar.
Jawab:
Operasi penjumlahan: n kali (loop for j1 to n)
Operasi perkalian: 1 + 2 + … + n = n(n +1)/2
Operasi penjumlahan + operasi perkalian = n + n(n+1)/2

= O(n2)

Algoritma mengevaluasi polinom yang lebih baik dapat dibuat
dengan metode Horner berikut:
p(x) = a0 + x(a1 + x(a2 + x(a3 + … + x(an-1 + anx)))…))
function p2(input x:real)real
{ Mengembalikan nilai p(x) dengan metode Horner}
Deklarasi
k : integer
b1, b2, ..., bn : real
Algoritma
bnan
for kn-1 downto 0 do
bkak + bk+1 * x
endfor
return b0
Hitunglah berapa operasi perkalian dan berapa operasi penjumlahan yang

dilakukan oleh algoritma di atas? Jumlahkan kedua hitungan tersebut, lalu
tentukan juga kompleksitas waktu asimptotik algoritma tersebut dalam
notasi O-Besar. Manakah yang terbaik, algoritma p atau p2?

Jawab:
Operasi penjumlahan: n kali (loop for kn-1 downto 0)
Operasi perkalian: n kali
Operasi penjumlahan + operasi perkalian = n + n = 2n

= O(n)
Karena O(n) < O(n2), maka algoritma yang terbaik adalah p2

Bahan Kuliah
IF2211 Strategi Algoritma
Algoritma Brute Force

(Bagian 1)
Oleh: Rinaldi Munir
Program Studi Informatika

Sekolah Teknik Elektro dan Informatika, ITB, 2021
1
2
Definisi Algoritma Brute Force
• Algoritma Brute force : pendekatan yang lempang (straightforward) untuk
memecahkan suatu persoalan
• Biasanya algoritma brute force didasarkan pada:

• pernyataan pada persoalan (problem statement)
• Definisi/konsep yang dilibatkan.
• Algoritma brute force memecahkan persoalan dengan

• sangat sederhana,
• langsung,
• jelas caranya (obvious way).
• Just do it! atau Just Solve it! 3
Contoh-contoh
(Berdasarkan pernyataan persoalan)
1. Mencari elemen terbesar (terkecil)
Persoalan: Diberikan sebuah senarai yang

berisi n buah bilangan bulat (a1, a2, …, an).
Carilah elemen terbesar di dalam senarai
tersebut.
Algoritma brute force: bandingkan setiap elemen

senarai mulai dari a1 sampai an untuk menemukan
elemen terbesar
4
procedure CariElemenTerbesar(input a1, a2, ..., an : integer, output maks : integer)
{ Mencari elemen terbesar di antara elemen a1, a2, ..., an.
Elemen terbesar disimpan di dalam maks.
Luaran: maks
}
Deklarasi
k : integer
Algoritma:
maksa1
for k2 to n do
if ak > maks then
maksak
endif
endfor
Jumlah operasi perbandingan elemen senarai: n – 1 kali

Kompleksitas waktu algoritma: O(n).
5
2. Pencarian beruntun (Sequential Search)
Persoalan: Diberikan senarai yang berisi n

buah bilangan bulat (a1, a2, …, an). Carilah
nilai x di dalam senarai tersebut. Jika x
ditemukan, maka luarannya adalah indeks
elemen senarai, jika x tidak ditemukan, maka
luarannya adalah -1.
Algoritma brute force: setiap elemen senarai

dibandingkan dengan x. Pencarian selesai jika
x ditemukan atau seluruh elemen senarai
sudah habis diperiksa.
6
procedure PencarianBeruntun(input a1, a2, ..., an : integer, x : integer; output idx : integer)
{ Mencari elemen bernilai x di dalam senarai a1, a2, ..., an. Lokasi (indeks elemen) tempat x
ditemukan diisi ke dalam idx. Jika x tidak ditemukan, maka idx diisi dengan 0.
Luaran: idx
}
Deklarasi
k : integer
Algoritma:
k1
while (k < n) and (ak  x) do
kk+1
endwhile
{ k = n or ak = x }
if ak = x then { x ditemukan }
idx  k
else
idx  –1 { x tidak ditemukan }
endif
Jumlah operasi perbandingan elemen senarai maksimal sebanyak: n kali

Adakah algoritma pencarian elemen yang lebih mangkus daripada brute force? 7
Contoh-contoh
(Berdasarkan definisi/konsep yang terlibat)
1. Menghitung an (a > 0, n adalah bilangan bulat tak-negatif)
Definisi:
an = a  a  …  a (n kali) , jika n > 0
=1 , jika n = 0
Algoritma brute force: kalikan 1 dengan a sebanyak n kali
8
function pangkat(a : real, n : integer) → real
{ Menghitung an }
Deklarasi
i : integer
hasil : real
Algoritma:
hasil  1
for i  1 to n do
hasil  hasil * a
endfor
return hasil
Jumlah operasi kali: n

Adakah algoritma perpangkatan yang lebih mangkus daripada brute force?
9
2. Menghitung n! (n bilangan bulat tak-negatif)
Definisi:
n! = 1 × 2 × 3 × … × n , jika n > 0
=1 , jika n = 0
Algoritma brute force: kalikan n buah bilangan,

yaitu 1, 2, 3, …, n, bersama-sama
10
function faktorial(n : integer) → integer
{ Menghitung n! }
Deklarasi
k : integer
fak : real
Algoritma:
fak  1
for k  1 to n do
fak  fak * k
endfor
return fak
Jumlah operasi kali: n

11
3. Mengalikan dua buah matriks, A dan B, berukuran n x n
Misalkan C = A × B dan elemen-elemen matrik dinyatakan sebagai
cij, aij, dan bij
Definisi perkalian matriks:
n
cij = ai1b1 j + ai 2b2 j +  + ain bnj =  aik bkj
k =1
Algoritma brute force: hitung setiap elemen hasil perkalian satu per
satu, dengan cara mengalikan dua vektor yang panjangnya n.
12
procedure PerkalianMatriks(input A, B : Matriks, input n : integer, output C : Matriks)
{Mengalikan matriks A dan B yang berukuran n × n, menghasilkan matriks C yang juga berukuran n × n
Masukan: matriks integer A dan B, ukuran matriks n
Luaran: matriks C
}
Deklarasi
i, j, k : integer
Algoritma:
for i1 to n do
for j1 to n do
C[i, j]0 { inisialisasi penjumlah }
for k  1 to n do
C[i, j]C[i, j] + A[i, k]*B[k, j]
endfor
endfor
endfor
Jumlah operasi kali: n3 dan operasi tambah: n3, total 2n3

Kompleksitas waktu algoritma: O(n3)
Adakah algoritma perkalian matriks yang lebih mangkus daripada brute force?
13
4. Uji Bilangan Prima
Persoalan: Diberikan sebuah bilangan bilangan bulat positif n. Ujilah

apakah n merupakan bilangan prima.
Definisi: bilangan prima adalah bilangan yang hanya habis dibagi

oleh 1 dan dirinya sendiri.
Algoritma brute force: bagi n dengan 2 sampai n – 1. Jika semuanya

tidak habis membagi n, maka n adalah bilangan prima.
14
function IsPrima(n : integer) → boolean
{ Menguji apakah n bilangan prima atau bukan. True jika n prima, atau false jika n tidak prima. }
Deklarasi
k : integer
test : boolean
Algoritma:
testtrue
k2
while (test) and (k  n – 1) do
if n mod k = 0 then
testfalse
else
kk+1
endif
endwhile
{ not test or k = n }
return test
endif
Kompleksitas waktu algoritma (kasus terburuk): O(n)

Adakah algoritma uji bilangan prima yang lebih mangkus daripada brute force?
15
Perbaikan: bagi n dengan 2 sampai n. Jika semuanya tidak habis membagi n,
maka n adalah bilangan prima.
function IsPrima(n : integer) → boolean
{ Menguji apakah n bilangan prima atau bukan. True jika n prima, atau false jika n tidak prima. }
Deklarasi
k : integer
test : boolean
Algoritma:
if n < 2 then { 1 bukan prima }
return false
else
testtrue
k2
while (test) and (k  n) do
if n mod k = 0 then
testfalse
else
kk+1
endif
endwhile
{ not test or k >  n } Kompleksitas waktu algoritma (kasus terburuk): O(n)
return test
endif
16
Contoh-contoh lainnya
5. Algoritma Pengurutan Brute Force
• Algoritma apa yang memecahkan

persoalan pengurutan secara brute force?
Bubble sort dan selection sort!
• Kedua algoritma ini memperlihatkan

metode brute force dengan sangat jelas.
17
Selection Sort
Pass ke –1:
1. Cari elemen terkecil di dalam s[1..n]
2. Letakkan elemen terkecil pada posisi ke-1 (lakukan pertukaran)
Pass ke-2:
1. Cari elemen terkecil di dalam s[2..n]
2. Letakkan elemen terkecil pada posisi 2 (pertukaran)
Ulangi sampai hanya tersisa 1 elemen
Semuanya ada n –1 kali pass
18
Sumber gambar: Prof. Amr Goneid
Department of Computer Science, AUC
19
procedure SelectionSort(input/output s1, s2, ..., sn : integer)
{ Mengurutkan s1, s2, ..., sn sehingga tersusun menaik dengan metode pengurutan seleksi.
Masukan: s1, s2, ..., sn
Luaran: s1, s2, ..., sn (terurut menaik) }
Deklarasi
i, j, imin, temp : integer
Algoritma:
for i  1 to n – 1 do { jumlah pass sebanyak n – 1 }
{ cari elemen terkecil di dalam s[i], s[i+1, ..., s[n] }
imin  i { elemen ke-i diasumsikan sebagai elemen terkecil sementara }
for j  i+1 to n do
if s[j] < s[imin] then
imin  j
endif
endfor
{pertukarkan s[imin] dengan s[i] }
temp  s[i]
s[i]  s[imin]
s[imin]  temp
endfor
Jumlah operasi perbandingan elemen larik: n(n – 1)/2

Jumlah operasi pertukaran: n – 1
Kompleksitas waktu algoritma diukur dari jumlah operasi perbandingan elemen larik: O(n2).
Adakah algoritma pengurutan yang lebih mangkus daripada Selection Sort? 20
Bubble Sort
• Mulai dari elemen ke-1:

1. Jika s2 < s1, pertukarkan
2. Jika s3 < s2, pertukarkan
satu kali pass
…
3. Jika sn < sn – 1, pertukarkan
• Ulangi lagi untuk pass ke-2, 3, .., n – 1 dst

• Semuanya ada n – 1 kali pass
21
Sumber gambar: Prof. Amr Goneid
Department of Computer Science, AUC
22
procedure BubbleSort (input/output s1, s2, ..., sn : integer, input n : integer)
{Mengurutkan s1, s2, ..., sn sehingga terurut menaik dengan metode pengurutan bubble sort.
Masukan: s1, s2, ..., sn
Luaran: s1, s2, ..., sn (terurut menaik) }
Deklarasi
i : integer { pencacah untuk jumlah langkah }
k : integer { pencacah,untuk pengapungan pada setiap langkah }
temp : integer { peubah bantu untuk pertukaran }
Algoritma:
for i  n – 1 downto 1 do
for k  1 to i do
if s[k+1] < s[k] then
{pertukarkan s[k] dengan s[k+1]}
temp  s[k]
s[k]  s[k+1]
s[k+1]  temp
endif
endfor
endfor
Jumlah perbandingan elemen: n(n – 1 )/2

Jumlah pertukaran (kasus terburuk): n(n – 1)/2
Kompleksitas waktu algoritma diukur dari jumlah perbandingan: O(n2).
Adakah algoritma pengurutan yang lebih mangkus? 23
6. Mengevaluasi polinom
• Persoalan: Hitung nilai polinom

p(x) = anxn + an – 1xn – 1 + … + a1x + a0
pada x = t.
• Algoritma brute force: xk dihitung secara brute force (seperti pada

perhitungan an). Kalikan nilai xk dengan ak, lalu jumlahkan dengan
suku-suku lainnya.
24
function polinom(t : real)→real
{ Menghitung nilai p(x) pada x = t. Koefisien-koefisein polinom sudah disimpan di dalam a[0..n].
Masukan: t
Keluaran: nilai polinom pada x = t. }
Deklarasi
i, j : integer
p, pangkat : real
Algoritma:
p0
for i  n downto 0 do
pangkat  1
for j  1 to i do {hitung ti }
pangkat  pangkat * t
endfor
p  p + a[i] * pangkat
endfor
return p
Jumlah operasi perkalian: n(n + 1)/2 + (n + 1)

Kompleksitas waktu algoritma: O(n2).
25
Perbaikan (improve): Nilai pangkat pada suku sebelumnya (xn – 1) digunakan untuk
perhitungan pangkat pada suku sekarang
function polinom2(t : real)→real

{ Menghitung nilai p(x) pada x = t. Koefisien-koefisein polinom sudah disimpan di dalam a[0..n].
Masukan: t
Keluaran: nilai polinom pada x = t. }
Deklarasi
i, j : integer
p, pangkat : real
Algoritma:
p  a[0]
pangkat  1
for i  1 to n do
pangkat  pangkat * t
p  p + a[i] * pangkat
endfor
Jumlah operasi perkalian: 2n

Adakah algoritma perhitungan nilai polinom yang lebih mangkus daripada brute force?
26
7. Pencocokan String (String Matching/Pattern Matching)
Diberikan
a. teks (text), yaitu (long) string dengan panjang n karakter
b. pattern, yaitu string dengan panjang m karakter (asumsi: m < n)
Carilah lokasi pertama di dalam teks yang cocok (match) dengan
pattern.
Contoh:
Teks: Di mana-mana banyak orang berjualan bakso
Pattern: jual
27
Algoritma brute force:
1. Mula-mula pattern disejajarkan (alignment) pada awal teks.
2. Dengan menelusuri dari kiri ke kanan pada pattern, bandingkan setiap

karakter pada pattern dengan karakter yang bersesuaian di dalam teks sampai:
• semua karakter yang dibandingkan cocok atau sama (pencarian berhasil),

atau
• dijumpai sebuah ketidakcocokan karakter (pencarian belum berhasil)
3. Bila pattern belum ditemukan kecocokannya dan teks belum habis, geser
pattern satu karakter ke kanan dan ulangi kembali langkah 2.
28
Contoh 1:
Teks: NOBODY NOTICED HIM
Pattern: NOT
NOBODY NOTICED HIM

1 NOT
2 NOT
3 NOT
4 NOT
5 NOT
6 NOT
7 NOT
8 NOT
29
Contoh 2 (string biner):
Teks: 10010101001011110101010001
Pattern: 001011
10010101001011110101010001
1 001011
2 001011
3 001011
4 001011
5 001011
6 001011
7 001011
8 001011
9 001011
30
function PencocokanString(input P : string, T : string, m, n : integer, output idx : integer) → integer)
{ Luaran: lokasi awal kecocokan (idx) }
Deklarasi
i : integer
ketemu : boolean
Algoritma:
i0
ketemu  false
while (i  n – m) and (not ketemu) do
j1
while (j  m) and (Pj = Ti + j ) do
jj+1
endwhile
{ j > m or Pj  Ti+j }
if j = m then { kecocokan string ditemukan }

ketemu  true
else
i  i + 1 {geser pattern satu karakter ke kanan teks }
endif
endwhile
{ i > n – m or ketemu }
if ketemu then return i + 1 else return –1 endif

31
Brute Force in Java
public static int brutematch(String T, String P)
{ int n = T.length(); // n is length of text
int m = P.length();; // m is length of pattern
int j;
for(int i=0; i <= (n-m); i++) {

j = 0;
while ((j < m) && (T.charAt(i+j)== P.charAt(j)) ) {
j++;
}
if (j == m)
return i; // match at i
}
return -1; // no match
}
// end of brutematch()
Analisis Pencocokan String dengan Brute Force
Worst Case.
• Pada setiap kali pencocokan pattern, semua karakter di pattern dibandingkan
dengan karakter di text pada posisi yang bersesuaian.
• Jadi, setiap kali pencocokan dilakukan m kali perbandingan karakter
• Jumlah pergeseran sampai pattern mencapai ujung teks = (n – m + 1)
• Total jumlah perbandingan karakter = m(n – m + 1) = nm – m2 + m = O(mn)
• Contoh:
• T: aaaaaaaaaaaaaaaaaaaaaaaaaaa
• P: aaah
aaah
….
… aaah
Best Case
• Best case terjadi bila karakter pertama pattern P tidak pernah sama dengan
karakter teks T yang dicocokkan.
• Jumlah pergeseran pattern = (n – m + 1)
• Jumlah perbandingan karakter sebanding dengan jumlah pergeseran pattern
• Jumlah perbandingan maksimal n kali:
• Kompleksitas kasus terbaik adalah O(n).
• Contoh:
T: String ini berakhir dengan zzzz
P: zzzz
Average Case
• Pencarian pada teks normal (teks biasa)

• Kompleksitas O(m + n)
• Contoh:
• T: Pada bulan Januari, hujan hampir turun setiap hari
• P: hujan
8. Mencari Pasangan Titik yang Jaraknya Terdekat (Closest Pairs Problem)
Persoalan: Diberikan n buah titik (pada 2-D atau 3-D), tentukan dua
buah titik yang terdekat satu sama lain.
36
• Jarak dua buah titik, p1 = (x1, y1) dan p2 = (x2, y2) dihitung dengan rumus Euclidean:
𝑑= (𝑥1 − 𝑥2 )2 +(𝑦1 − 𝑦2 )2
• Algoritma brute force:

1. Untuk setiap titik k, k = 1, 2, …, n, hitung jaraknya dengan titik-titik lainnya
2. Pasangan titik yang mempunyai jarak terpendek itulah jawabannya.
• Ada n buah titik, maka untuk setiap titik dihitung jaraknya dengan n – 1 titik lainnya. Jadi
ada n(n – 1) perhitungan jarak dengan rumus Euclidean.
• Untuk setiap titik akan terhitung dua kali dalam perhitungan jarak, jadi sebenarnya hanya
terdapat sebanyak n(n – 1)/2 perhitungan jarak dengan rumus Euclidean.
• Kompleksitas algoritma adalah O(n2).
37
procedure CariDuaTitikTerdekat(input P : SetOfPoint, n : integer, output P1, P2 : Point)
{ Mencari dua buah titik di dalam himpunan P yang jaraknya terdekat.
Masukan: P = himpunan titik, dengan struktur data sebagai berikut
type Point = record(x : real, y : real)
type SetOfPoint = array [1..n] of Point
Luaran: dua buah titik, P1 dan P2 yang jaraknya terdekat. }
Deklarasi
d, dmin : real
i, j : integer
Algoritma:
dmin9999
for i  1 to n – 1 do
for j  i + 1 to n do
d((Pi.x – Pj.x)2 + ((Pi.y – Pj.y)2)
if d < dmin then { perbarui jarak terdekat }
dmin  d
P1  Pi
P2  Pj
endif
endfor
endfor
Kompleksitas algoritma: O(n2). 38

Karakteristik Algoritma Brute Force
1. Algoritma brute force umumnya tidak “cerdas”
dan tidak mangkus, karena ia membutuhkan
volume komputasi yang besar dan waktu yang
lama dalam penyelesaiannya.
Kata “force” mengindikasikan “tenaga”

ketimbang “otak”
Kadang-kadang algoritma brute force disebut

juga algoritma naif (naïve algorithm).
39
2. Algoritma brute force lebih cocok untuk persoalan yang
ukuran masukannya (n) kecil.
Pertimbangannya:
- sederhana,
- implementasinya mudah
Algoritma brute force sering digunakan sebagai basis

pembanding dengan algoritma lain yang lebih mangkus.
40
3. Meskipun bukan metode problem solving yang mangkus, hampir semua
persoalan dapat diselesaikan dengan algoritma brute force. Ini adalah
kelebihan brute force
Sukar menunjukkan persoalan yang tidak dapat diselesaikan dengan

metode brute force.
Bahkan, ada persoalan yang hanya dapat diselesaikan dengan brute force.
Contoh: mencari elemen terbesar di dalam senarai.
Contoh lainnya?
“When in doubt, use brute force” (Ken Thompson, penemu sistem

operasi UNIX)
41
Kekuatan dan Kelemahan Algoritma Brute Force
Kekuatan:
1. Algoritma brute force dapat diterapkan untuk memecahkan hampir sebagian besar
masalah (wide applicability).
2. Algoritma brute force sederhana dan mudah dimengerti.
3. Algoritma brute force menghasilkan algoritma yang layak untuk beberapa masalah
penting seperti pencarian, pengurutan, pencocokan string, perkalian matriks.
4. Algoritma brute force menghasilkan algoritma baku (standard) untuk tugas-tugas

komputasi seperti penjumlahan/perkalian n buah bilangan, menentukan elemen
minimum atau maksimum di dalam senarai (larik).
42
Kelemahan:
1. Algoritma brute force jarang menghasilkan algoritma yang

mangkus.
2. Algoritma brute force umumnya lambat untuk masukan

berukuran besar sehingga tidak dapat diterima.
3. Tidak sekontruktif/sekreatif strategi pemecahan masalah

lainnya.
43
Algoritma Brute Force dalam Sudoku
• Sudoku adalah adalah permainan teka-teki (puzzle) logik yang
berasal dari Jepang. Permainan ini sangat populer di seluruh dunia.
• Contoh sebuah Sudoku:
44
• Kotak-kotak di dalam Sudoku harus diisi dengan angka 1 sampai 9
sedemikian sehingga:
1. tidak ada angka yang sama (berulang) pada setiap baris;
2. tidak ada angka yang sama (berulang) pada setiap kolom;
3. tidak ada angka yang sama (berulang) pada setiap bujursangkar (persegi)
yang lebih kecil.
45
Algoritma Brute Force untuk Sudoku:
1. Tempatkan angka “1” pada sel kosong pertama. Periksa apakah
penempatan “1” dibolehkan (dengan memeriksa baris, kolom,
dan kotak).
2. Jika tidak ada pelanggaran, maju ke sel berikutnya. Tempatkan

“1” pada sel tersebut dan periksa apakah ada pelanggaran.
3. Jika pada pemeriksaan ditemukan pelanggaran, yaitu

penempatan “1” tidak dibolehkan, maka coba dengan
menempatkan “2”.
4. Jika pada proses penempatan ditemukan bahwa tidak satupun

dari 9 angka diperbolehkan, maka tinggalkan sel tersebut dalam
keadaan kosong, lalu mundur satu langkah ke sel sebelumnya.
Nilai di sel tersebut dinaikkan 1.
5. Ulangi Langkah 1 sampai 81 sel sudah terisi solusi yang benar.
Exhaustive Search
Exhaustive search:
• adalah teknik pencarian solusi secara solusi brute force untuk
persoalan-persoalan kombinatorik;
• yaitu persoalan di antara objek-objek kombinatorik seperti

permutasi, kombinasi, atau himpunan bagian dari sebuah himpunan.
47
• Langkah-langkah di dalam exhaustive search:
1. Enumerasi (list) setiap kemungkinan solusi dengan cara yang sistematis.
2. Evaluasi setiap kemungkinan solusi satu per satu, simpan solusi terbaik yang
ditemukan sampai sejauh ini (the best solution found so far).
3. Bila pencarian berakhir, umumkan solusi terbaik (the winner)
• Meskipun exhaustive search secara teoritis menghasilkan solusi,

namun waktu atau sumberdaya yang dibutuhkan dalam pencarian
solusinya sangat besar.
48
Contoh-contoh exhaustive search
1. Travelling Salesperson Problem (TSP)
Persoalan: Diberikan n buah kota serta diketahui jarak antara setiap kota
satu sama lain. Temukan perjalanan (tour) dengan jarak terpendek yang
dilakukan oleh seorang pedagang sehingga ia melalui setiap kota tepat
hanya sekali dan kembali lagi ke kota asal keberangkatan.
49
• Persoalan TSP tidak lain adalah menemukan sirkuit Hamilton dengan
bobot minimum.
• Algoritma exhaustive search untuk TSP:

1. Enumerasikan (list) semua sirkuit Hamilton dari graf lengkap dengan n buah
simpul.
2. Hitung (evaluasi) bobot setiap sirkuit Hamilton yang ditemukan pada

langkah 1.
3. Pilih sirkuit Hamilton yang mempunyai bobot terkecil. Itulah solusinya.
50
Contoh 3:
TSP dengan n = 4, simpul awal = a
a 12 b No. Rute perjalanan (tour) Bobot

1. a→b→c→d→a 12+8+15+10 = 45
5 9 2. a→b→d→c→a 12+9+15+5 = 41
10 8 3. a→c→b→d→a 5+8+9+10 = 32 → optimal
4. a→c→d→b→a 5+15+9+12 = 41
5. a→d→b→c→a 10+9+8+5 = 32 → optimal
d 15 c
6 a→d→c→b→a 10+15+8+12 = 45
Rute perjalananan terpendek adalah

a→c→b→d→a
a→d→b→c→a
dengan bobot = 32.
51
• Untuk graf lengkap n buah simpul semua rute perjalanan dibangkitkan
dengan permutasi dari n – 1 buah simpul.
No. Rute perjalanan (tour) Bobot
1. a→b→c→d→a 12+8+15+10 = 45
• Permutasi n – 1 buah simpul adalah 2. a→b→d→c→a 12+9+15+5 = 41
3. a→c→b→d→a 5+8+9+10 = 32
4. a→c→d→b→a 5+15+9+12 = 41
5. a→d→b→c→a 10+9+8+5 = 32
(n – 1)! 6 a→d→c→b→a 10+15+8+12 = 45
• Pada contoh di atas, untuk n = 4 akan terdapat
(4 – 1)! = 3! = 6
buah rute perjalanan.

52
• Jika TSP diselesaikan dengan exhaustive search, maka kita harus
mengenumerasi sebanyak (n – 1)! buah sirkuit Hamilton,
menghitung bobot setiap sirkuitnya, lalu memilih sirkuit Hamilton
dengan bobot terkecil.
• Kompleksitas waktu algoritma exhaustive search untuk persoalan

TSP sebanding dengan (n – 1)! dikali dengan waktu untuk
menghitung bobot setiap sirkuit Hamilton.
• Menghitung bobot setiap sirkuit Hamilton membutuhkan waktu

O(n), sehingga kompleksitas waktu algoritma exhaustive search
untuk persoalan TSP adalah O(n  n!).
53
• Perbaikan: setengah dari semua rute perjalanan adalah hasil pencerminan
dari setengah rute yang lain, yakni dengan mengubah arah rute perjalanan
No. Rute perjalanan (tour) Bobot
1 dan 6 1. a→b→c→d→a 12+8+15+10 = 45
12+9+15+5 = 41
2. a→b→d→c→a
5+8+9+10 = 32
2 dan 4 3.
4.
a→c→b→d→a
a→c→d→b→a 5+15+9+12 = 41
5. a→d→b→c→a 10+9+8+5 = 32
3 dan 5 6 a→d→c→b→a 10+15+8+12 = 45
• maka dapat dihilangkan setengah dari jumlah permutasi (dari 6 menjadi 3).
• Ketiga buah sirkuit Hamilton yang dihasilkan:

a 12 b a 12 b a b
5 9 5 9
10 8 10 8
d 15 c d 15 c d c
Bobot = 45 Bobot = 32 54
Bobot = 41
• Untuk graf lengkap dengan n buah simpul, kita hanya perlu
mengevaluasi (n – 1)!/2 sirkuit Hamilton.
• Untuk TSP dengan n yang besar, jelas algoritma exhaustive search

menjadi sangat tidak mangkus.
• Pada persoalan TSP, untuk n = 20 akan terdapat (19!)/2 = 6  1016

sirkuit Hamilton yang harus dievaluasi satu per satu.
• Jika untuk mengevaluasi satu sirkuit Hamilton dibutuhkan waktu 1

detik, maka waktu yang dibutuhkan untuk mengevaluasi 6  1016
sirkuit Hamilton adalah sekitar 190 juta tahun
55
• Sayangnya, untuk persoalan TSP belum ada algoritma lain yang lebih
baik daripada algoritma exhaustive search.
• Jika anda dapat menemukan algoritma yang mangkus untuk TSP,

anda akan menjadi terkenal dan kaya!
• Algoritma yang mangkus selalu mempunyai kompleksitas waktu

dalam orde polinomial.
56
2. 1/0 Knapsack Problem
• Persoalan: Diberikan n buah objek dan sebuah
knapsack dengan kapasitas bobot K. Setiap objek
memiliki properti bobot (weigth) wi dan
keuntungan(profit) pi.
Bagaimana cara memilih objek-objek yang

dimasukkan ke dalam knapsack sedemikian
sehingga diperoleh total keuntungan yang
maksimal. Total bobot objek yang dimasukkan
tidak boleh melebihi kapasitas knapsack.
• Disebut 1/0 knapsack problem karena suatu

objek dapat dimasukkan ke dalam knapsack
(1) atau tidak dimasukkan sama sekali (0) 57
• Persoalan 0/1 Knapsack dapat kita pandang sebagai mencari
himpunan bagian (subset) dari himpunan n objek yang dapat dimuat
ke dalam knapsack dan memberikan total keuntungan terbesar.
58
• Solusi persoalan dinyatakan sebagai X = {x1, x2, …, xn}
xi = 1, jika objek ke-i dipilih,
xi = 0, jika objek ke-i tidak dipilih.
• Formulasi persoalan knapsack secara matematis:

n
Maksimasi F =  p x i i
i =1
dengan kendala (constraint)

n
w x  K
i =1
i i
yang dalam hal ini, xi = 0 atau 1, i = 1, 2, …, n

59
Algoritma exhaustive search untuk persoalan 1/0 Knapsack:
1. Enumerasikan (list) semua himpunan bagian dari himpunan dengan

n objek.
2. Hitung (evaluasi) total keuntungan dari setiap himpunan bagian dari

langkah 1.
3. Pilih himpunan bagian yang memberikan total keuntungan terbesar

namun total bobotnya tidak melebihi kapasitas knapsack.
60
Contoh 4: Misalkan terdapat n = 4 buah objek dan sebuah knapsack
dengan kapasitas K = 16. Properti setiap objek adalah sbb
Objek Bobot Profit ($)

1 2 20
2 5 30
3 10 50
4 5 10
Langkah-langkah pencarian solusi 0/1 Knapsack secara exhaustive

search dirangkum dalam tabel di bawah ini:
61
Himpunan Bagian Total Bobot Total keuntungan
{} 0 0
{1} 2 20
{2} 5 30
{3} 10 50
{4} 5 10
{1, 2} 7 50
{1, 3} 12 70
{1, 4} 7 30
{2, 3} 15 80 → optimal
{2, 4} 10 40
{3, 4} 15 60
{1, 2, 3} 17 tidak layak
{1, 2, 4} 12 60
{1, 2, 3, 4} 22 tidak layak
• Himpunan bagian objek yang memberikan keuntungan maksimum

adalah {2, 3} dengan total keuntungan adalah 80.
• Solusi: X = {0, 1, 1, 0}
62
• Banyaknya himpunan bagian dari sebuah himpunan dengan n
elemen adalah 2n.
Waktu untuk menghitung total bobot di dalam himpunan bagian

adalah O(n)
Sehingga, Kompleksitas algoritma exhaustive search untuk persoalan

0/1 Knapsack adalah O(n. 2n).
• TSP dan 0/1 Knapsack, adalah contoh persoalan dengan

kompleksitas eksponensial.
63
Bersambung ke bagian 2
Bahan Kuliah
IF2211 Strategi Algoritma
Algoritma Brute Force

(Bagian 2)
Oleh: Rinaldi Munir
Program Studi Informatika

Sekolah Teknik Elektro dan Informatika, ITB, 2021
1
Latihan
(yang diselesaikan secara exhaustive search)
1. (Persoalan Penugasan) Misalkan terdapat n orang dan n buah pekerjaan (job).
Setiap orang akan di-assign dengan sebuah pekerjaan. Penugasan orang ke-i
dengan pekerjaan ke-j membutuhkan biaya sebesar c(i, j). Bagaimana
melakukan penugasan sehingga total biaya penugasan adalah seminimal
mungkin? Misalkan instansiasi persoalan dinyatakan sebagai matriks C sebagai
berikut
 Job 1 Job 2 Job 3 Job 4

 9 2 7 8  Orang a

C= 6 4 3 7  Orang b
 
 5 8 1 4  Orang c
 7 6 9 4  Orang d
2
2. (Persoalan partisi). Diberikan n buah bilangan bulat positif. Bagilah
menjadi dua himpunan bagian disjoint sehingga setiap bagian
mempunyai jumlah nilai yang sama (catatan: masalah ini tidak
selalu mempunyai solusi).
Contoh: n = 6, yaitu 3, 8, 4, 6, 1, 2, dibagidua menjadi {3, 8, 1} dan
{4, 6, 2} yang masing-masing jumlahnya 12.
Rancang algoritma exhaustive search untuk masalah ini. Cobalah
mengurangi jumlah himpunan bagian yang perlu dibangkitkan.
3
3. (Bujursangkar ajaib). Bujursangkar ajaib (magic square) adalah
pengaturan n buah bilangan dari 1 hingga n2 di dalam bujursangkar
yang berukuran n x n sedemikian sehingga jumlah nilai setiap
kolom,baris, dan diagonal sama. Rancanglah algoritma exhaustive
search untuk membangkitkan bujursangkar ajaib orde n.
4
Exhaustive Search di dalam Kriptografi
• Di dalam kriptografi, exhaustive search merupakan teknik yang digunakan
penyerang untuk menemukan kunci dekripsi dengan cara mencoba semua
kemungkinan kunci.
Serangan semacam ini dikenal dengan nama exhaustive key search attack atau
brute force attack.
• Serangan yang sama juga digunakan dalam menemukan password, PIN, dan
kode rahasia lainnya.
5
Contoh 5: Panjang kunci enkripsi di dalam algoritma DES (Data Encryption
Standard) adalah 64 bit.
• Dari 64 bit tersebut, hanya 56 bit yang digunakan (8 bit paritas lainnya
tidak dipakai).
• Jumlah kombinasi kunci yang harus dicoba (dievaluasi) oleh pihak

lawan adalah sebanyak
(2)(2)(2)(2)(2) … (2)(2) = 256 = 72.057.594.037.927.936
• Jika untuk percobaan dengan satu kunci memerlukan waktu 1 detik,

maka untuk jumlah kunci sebanyak itu diperlukan waktu komputasi
kurang lebih selama 2.284.931.317 tahun!
6
• Algoritma exhaustive search tidak mangkus sebagaimana ciri
algoritma brute force pada umumnya, karena membutuhkan volume
komputasi yang besar untuk menyelesaikan persoalan dengan
meningkatnya ukuran masukan.
• Namun, nilai plusnya terletak pada keberhasilannya yang selalu

menemukan solusi (jika diberikan waktu yang mencukupi).
7
Teknik Heuristik
• Algoritma exhaustive search dapat diperbaiki kinerjanya sehingga
tidak perlu melakukan pencarian solusi dengan mengeksplorasi
semua kemungkinan solusi.
• Salah satu teknik yang digunakan untuk mempercepat pencarian

solusi di dalam exhaustive search adalah teknik heuristik (heuristic).
Terkadang disebut juga fungsi heuristik.
• Dalam exhaustive search, teknik heuristik digunakan untuk

mengeliminasi beberapa kemungkinan solusi tanpa harus
mengeksplorasi seluruh kemungkinan solusi secara penuh.
8
• Heuristik merupakan teknik yang dirancang untuk memecahkan
persoalan dengan mengabaikan apakah teknik tersebut terbukti
benar secara matematis
• Sebab teknik ini menggunakan pendekatan yang tidak formal,

misalnya berdasarkan penilaian intuitif, terkaan, atau akal sehat.
• Contoh: program antivirus menggunakan pola-pola heuristik untuk

mengidentifikasi dokumen yang terkena virus atau malware.
9
Asal Mula Kata Heuristik
• Heuristik adalah seni dan ilmu menemukan

(art and science of discovery).
• Kata heuristik diturunkan dari Bahasa Yunani

yaitu “eureka” yang berarti “menemukan” (to
find atau to discover).
• Matematikawan Yunani yang bernama Archimedes yang

melontarkan kata "heureka", dari sinilah kita menemukan
kata “eureka” yang berarti “I have found it.”
10
11
12
• Heuristik mengacu pada teknik memecahkan persoalan berbasis pengalaman,
dari proses pembelajaran, dan penemuan solusi meskipun tidak dijamin
optimal.
• Heuristik berbeda dengan algoritma:

- heuristik berlaku sebagai panduan (guideline),
- sedangkan algoritma adalah urutan langkah-langkah penyelesaian
persoalan.
• Teknik heuristik menggunakan terkaan, intuisi, dan common sense. Secara

matematis tidak dapat dibuktikan, namun sangat berguna.
• Teknik heuristik mungkin tidak selalu memberikan hasil optimal, tetapi secara
ekstrim ia berguna pada penyelesaian persoalan.
13
• Heuristik yang bagus dapat secara dramatis mengurangi waktu yang
dibutuhkan untuk memecahkan persoaln dengan cara mengeliminir
kebutuhan untuk mempertimbangkan kemungkinan solusi yang tidak
perlu.
• Heuristik tidak menjamin selalu dapat memecahkan persoalan, tetapi

seringkali memecahkan persoalan dengan cukup baik untuk
kebanyakan persoalan, dan seringkali pula lebih cepat daripada
pencarian solusi secara exhaustive search.
• Sudah sejak lama heuristik digunakan secara intensif di dalam bidang

intelijensia buatan (artificial intelligence), misalnya di dalam metode
hill climbing, best first search, algoritma A*, dan lain-lain.
14
Contoh penggunaan heuristik untuk mempercepat algoritma exhaustive search
Contoh 6: Persoalan anagram. Anagram adalah penukaran huruf dalam sebuah

kata atau kalimat sehingga kata atau kalimat yang baru mempunyai arti lain.
Contoh-contoh anagram (semua contoh dalam Bahasa Inggris):

lived → devil
listen → silent
tea → eat
charm → march
15
• Bila diselesaikan secara exhaustive search, kita harus mencari semua
permutasi huruf-huruf pembentuk kata atau kalimat, lalu memerika apakah
kata atau kalimat yang terbentuk mengandung arti (mengacu ke kamus).
• Teknik heuristik dapat digunakan untuk mengurangi jumlah pencarian solusi.
• Salah satu teknik heuristik yang digunakan misalnya membuat aturan bahwa
dalam Bahasa Inggris huruf c dan h selalu digunakan berdampingan sebagai ch
(lihat contoh charm dan march), sehingga kita hanya membuat permutasi
huruf-huruf dengan c dan h berdampingan.
• Dengan demikian, semua permutasi dengan huruf c dan h tidak berdampingan

ditolak dari pencarian → mengurangi volume komputasi
16
Contoh 7: Kubus ajaib 3 x 3 mempunyai 8 buah solusi sbb
Dengan exhaustive search, kita perlu memeriksa 9! = 362,880 susunan solusi yang
mungkin, kemudian memeriksa apakah bahwa jumlah setiap baris, setiap kolom, atau
setiap diagonal selalu 15.
Teknik heuristik: pada setiap pembangkitan permutasi, periksa apakah nilai 3 buah angka
pertama jumlahnya 15. Jika ya → teruskan, jika tidak → tolak
17
Contoh 8: Pada permainan 8-puzzle, fungsi heuristik digunakan untuk
menentukan cost minimal dari suatu status ke status lainnya di dalam
ruang pencarian.
3 2 8 1 2 3
5 4 4 5 6
7 6 1 7 8
Status awal Status akhir
Fungsi heuristik:
h(n) = jumlah ubin yang tidak terdapat pada status akhir
=5
= dibutuhkan minimal 5 pergerakan ubin untuk mencapai status akhir
dari status awal
18
Latihan Soal Brute Force dan Exhaustive Search
1. Soal UTS 2014
• Diberikan sebuah larik (array) integer a1, a2, …, an. Anda diminta
menemukan sub-sequence yang kontigu (berderetan) dari larik tersebut
yang memiliki nilai maksimum. Nilai maksimum sub-sequence adalah
nol jika semua elemen larik adalah negatif. Sebagai contoh instansiasi:
larik [–2 , 11, –4 , 13, –5 , 2, –1, 3] memiliki nilai maksimum sub-
sequence kontigu adalah 20, yaitu dari elemen ke-2 hingga elemen ke-4
(yaitu [11, –4 , 13]).
• Jika diselesaikan dengan algoritma brute force bagaimana caranya?

Berapa kompleksitas algoritma brute force tersebut dalam notasi O-
besar?
19
Jawaban:
• Alternatif 1 (Exhaustive Search)
- Nyatakan larik sebagai sebuah himpuan
- Tuliskan semua upa-himpunan (sub-set) dari himpunan tersebut, lalu sesuaikan
urutan elemen di dalam upa-himpunan dengan urutan elemen di dalam larik.
Contoh sub-set dari [–2 , 11, –4 , 13, –5 , 2, –1, 3] → {13, –4, 11} → [11, –4, 13]
- Buang upa-himpunan yang elemen-elemennya tidak berurutan.
Contoh sub-set dari [–2 , 11, –4 , 13, –5 , 2, –1, 3] → {11, 2, 3} → dibuang
- Hitung jumlah nilai di dalam setiap upa-himpunan.
- Pilih upa-himpunan yang mempunyai nilai maksimum.
Jumlah semua upa-himpunan adalah 2n, menghitung jumlah nilai di dalam upa-
himpunan adalah O(n), maka kompleksitas algoritmanya adalah O(n. 2n).
20
• Alternatif 2 (Exhaustive Search), lebih baik
- Tuliskan semua sub-sequence dengan 1 elemen (ada n buah), sub-sequence
dengan 2 elemen (ada n – 1 buah), dan seterusnya hingga sub-sequence dengan n
elemen (1 buah). Seluruhnya ada
n + (n – 1) + (n – 2) + … + 2 + 1 = n(n + 1)/2 sub-sequence.
Contoh: [8 , –6, 4 , 3, –5] → n = 5
Sub-sequence dengan 1 elemen: [8] , [–6], [4], [3] , [–5] → 5 sub-sequence
Sub-sequence dengan 2 elemen: [8, –6], [–6, 4], [4, 3], [3, –5] → 4 sub-sequence
dst …
- Hitung jumlah nilai pada setiap sub-sequence
- Pilih sub-sequence yang jumlahnya maksimum
Menghitung jumlah nilai di dalam sub-sequence adalah O(n), maka kompleksitas

algoritmanya adalah O(n. n(n + 1)/2) = O(n3).
21
2. Soal UTS tahun 2019
22
23
3. Soal UTS 2011
• Misalkan kita menempuh perjalanan sejauh 100 km, dimulai dari titik
0 dan berakhir pada kilometer 100. Di sepanjang jalan terdapat SPBU
pada jarak 10, 25, 30, 40, 50, 75, dan 80 km dari titik awal. Tangki
bensin pada awalnya hanya cukup untuk berjalan sejauh 30 km.
Bagaimana kita menempuh tempat pemberhentian agar kita berhenti
sesedikit mungkin?
• Bagaimana penyelesaian dengan algoritma Brute Force? Jelaskan!
24
TAMAT
25
Bahan Kuliah IF2211 Strategi Algoritma
Algoritma Greedy
(Bagian 1)
Oleh: Rinaldi Munir
Program Studi Teknik Informatika

Sekolah Teknik Elektro dan Informatika ITB
2021
Pendahuluan
• Algoritma greedy merupakan metode yang paling populer dan
sedehana untuk memecahkan persoalan optimasi.
• Persoalan optimasi (optimization problems):

➔ persoalan mencari solusi optimal.
• Hanya ada dua macam persoalan optimasi:

1. Maksimasi (maximization)
2. Minimasi (minimization)
2
Contoh persoalan optimasi:
Persoalan Penukaran Uang

(Coin exchange problem):
Diberikan uang senilai A. Tersedia
uang koin-koin dalam jumlah yang
banyak. Tukar A dengan koin-koin
uang yang ada. Berapa jumlah
minimum koin yang diperlukan untuk
penukaran tersebut?
➔ Persoalan minimasi
3
Contoh 1: tersedia banyak koin 1, 5, 10, 25
• Uang senilai A = 32 dapat ditukar dengan banyak cara berikut:

32 = 1 + 1 + … + 1 (32 koin)
32 = 5 + 5 + 5 + 5 + 10 + 1 + 1 (7 koin)
32 = 10 + 10 + 10 + 1 + 1 (5 koin)
… dst
• Solusi minimum: 32 = 25 + 5 + 1 + 1 (4 koin)
4
• Greedy = rakus, tamak, loba, …
• Prinsip greedy: “take what you can get now!”.
• Algoritma greedy membentuk solusi langkah per langkah (step by step).
• Pada setiap langkah, terdapat banyak pilihan yang perlu dievaluasi.
• Oleh karena itu, pada setiap langkah harus dibuat keputusan yang terbaik dalam
menentukan pilihan. Tidak bisa mundur lagi (kembali) ke langkah sebelumnya.
• Jadi pada setiap langkah, kita memilih optimum lokal (local optimum)
• dengan harapan bahwa langkah sisanya mengarah ke solusi optimum global

(global optimum).
5
Definisi
• Algoritma greedy adalah algoritma yang memecahkan persoalan
secara langkah per langkah (step by step) sedemikian sehingga,
pada setiap langkah:

1. mengambil pilihan yang terbaik yang dapat diperoleh pada saat
itu tanpa memperhatikan konsekuensi ke depan
(prinsip “take what you can get now!”)
2. dan “berharap” bahwa dengan memilih optimum lokal pada

setiap langkah akan berakhir dengan optimum global.
6
• Tinjau masalah penukaran uang:
Strategi greedy:
Pada setiap langkah, pilihlah koin dengan nilai terbesar
dari himpunan koin yang tersisa.
• Misal: A = 32, koin yang tersedia: 1, 5, 10, dan 25 (dalam jumlah banyak)
Langkah 1: pilih 1 buah koin 25 (Total = 25)
Langkah 2: pilih 1 buah koin 5 (Total = 25 + 5 = 30)
Langkah 3: pilih 1 buah koin 1 (Total = 25+5+1 = 31)
Langkah 4: pilih 1 buah koin 1 (Total = 25+5+1 = 32)
• Solusi: Jumlah koin minimum = 4 (solusi optimal!)

7
• Elemen-elemen algoritma greedy:
1. Himpunan kandidat, C : berisi kandidat yang akan dipilih pada setiap Langkah
(misal: simpul/sisi di dalam graf, job, task, koin, benda, karakter, dsb)
2. Himpunan solusi, S : berisi kandidat yang sudah dipilih
3. Fungsi solusi: menentukan apakah himpunan kandidat yang dipilih sudah
memberikan solusi
4. Fungsi seleksi (selection function): memilih kandidat berdasarkan strategi greedy
tertentu. Strategi greedy ini bersifat heuristik.
5. Fungsi kelayakan (feasible): memeriksa apakah kandidat yang dipilih dapat
dimasukkan ke dalam himpunan solusi (layak atau tidak)
6. Fungsi obyektif : memaksimumkan atau meminimumkan
• Dengan menggunakan elemen-elemen di atas, maka dapat dikatakan bahwa:

Algoritma greedy melibatkan pencarian sebuah himpunan bagian, S, dari himpunan
kandidat, C; yang dalam hal ini, S harus memenuhi beberapa kriteria yang ditentukan,
yaitu S menyatakan suatu solusi dan S dioptimisasi oleh fungsi obyektif. 8
Tinjau kembali persoalan penukaran uang. Pada persoalan penukaran uang:
• Himpunan kandidat: himpunan koin atau pecahan uang yang

merepresentasikan nilai 1, 5, 10, 25, paling sedikit mengandung satu koin
untuk setiap nilai.
• Himpunan solusi: koin-koin yang terpilih.
• Fungsi solusi: memeriksa apakah total nilai koin yang dipilih tepat sama
jumlahnya dengan nilai uang yang ditukarkan.
• Fungsi seleksi: pilihlah koin yang bernilai tertinggi dari himpunan koin yang
tersisa.
• Fungsi kelayakan: memeriksa apakah koin yang baru dipilih apabila
dijumlahkan dengan semua koin yang sudah berada di dalam himpunan tidak
melebihi jumlah uang yang harus dibayar.
• Fungsi obyektif: jumlah koin yang digunakan minimum.
9
Skema umum algoritma greedy:
function greedy(C : himpunan_kandidat) → himpunan_solusi
{ Mengembalikan solusi dari persoalan optimasi dengan algoritma greedy }
Deklarasi
x : kandidat
S : himpunan_solusi
Algoritma:
S  {} { inisialisasi S dengan kosong }
while (not SOLUSI(S)) and (C  {} ) do
x  SELEKSI(C) { pilih sebuah kandidat dari C}
C  C – {x} { buang x dari C karena sudah dipilih }
if LAYAK(S  {x}) then { x memenuhi kelayakan untuk dimasukkan ke dalam himpunan solusi }
S  S  {x} { masukkan x ke dalam himpunan solusi }
endif
endwhile
{SOLUSI(S) or C = {} }
if SOLUSI(S) then { solusi sudah lengkap }

return S
else
write(’tidak ada solusi’)
endif
• Pada akhir setiap lelaran (iterasi), solusi yang terbentuk adalah optimum lokal.
• Pada akhir kalang while-do diperoleh optimum global (jika ada). 10
• Warning: Optimum global belum tentu merupakan solusi optimum (terbaik), bisa
jadi merupakan solusi sub-optimum atau pseudo-optimum.
• Alasan:
1. Algoritma greedy tidak beroperasi secara menyeluruh
terhadap semua kemungkinan solusi yang ada
(sebagaimana pada metode exhaustive search).
2. Terdapat beberapa fungsi SELEKSI yang berbeda,

sehingga kita harus memilih fungsi yang tepat jika kita
ingin algoritma menghasilkan solusi optiamal.
• Jadi, pada sebagian persoalan, algoritma greedy tidak selalu berhasil

memberikan solusi yang optimal, namun sub-optimal. Perhatikan Contoh 2
berikut.
11
• Contoh 2: Tinjau pesoalan penukaran uang berikut:
(a) Koin: 5, 4, 3, dan 1 (dalam jumlah yang banyak)

Uang yang ditukar A = 7.
Solusi greedy: 7 = 5 + 1 + 1 ( 3 koin) → tidak optimal
Solusi optimal: 7 = 4 + 3 ( 2 koin)
(b) Koin: 10, 7, 1 (dalam jumlah yang banyak)

Solusi greedy: 15 = 10 + 1 + 1 + 1 + 1 + 1 (6 koin) → tidak optimal
Solusi optimal: 15 = 7 + 7 + 1 (hanya 3 koin)
(c) Koin: 15, 10, dan 1 (dalam jumlah yang banyak)

Solusi greedy: 20 = 15 + 1 + 1 + 1 + 1 + 1 (6 koin) → tidak optimal
Solusi optimal: 20 = 10 + 10 (2 koin)
12
Catatan: Untuk sistem mata uang dollar AS, euro Eropa, dan crown Swedia,
rupiah Indonesia, algoritma greedy selalu memberikan solusi optimum untuk
persoalan penukaran uang.
• Contoh 3: Uang Rp178.400 dapat dinyatakan dalam jumlah pecahan yang

minimal sebagai berikut:
- Satu lembar uang kertas Rp100.000
- Satu koin uang Rp1000
- Dua koin uang Rp200
100.000 + 50.000 + 20.000 + 5.000 + 2.000 + 1000 + 2x200 = Rp178.400

13
• Jika solusi terbaik mutlak tidak terlalu diperlukan, maka algoritma greedy
dapat digunakan untuk menghasilkan solusi hampiran (approximation),
• daripada menggunakan algoritma yang kebutuhan waktunya

eksponensial untuk menghasilkan solusi yang eksak.
• Misalnya mencari tur dengan bobot minimal pada persoalan TSP untuk
jumlah simpul (n) yang banyak dengan algoritma brute force dibutuhkan
waktu komputasi yang lama untuk menemukannya.
• Dengan algoritma greedy, meskipun tur dengan berbobot minimal tidak

dapat ditemukan, namun solusi dengan algoritma greedy dianggap
sebagai hampiran solusi optimal.
14
• Namun bila algoritma greedy dapat menghasilkan solusi optimal,
maka keoptimalannya itu harus dapat dibuktikan secara matematis.
• Membuktikan optimalitas algoritma greedy secara matematis adalah

tantangan tersendiri.
• Lebih mudah memperlihatkan algoritma greedy tidak selalu optimal

dengan menunjukkan counterexample (contoh kasus yang
menunjukkan solusi yang diperoleh tidak optimal),
• misalnya pada persoalan penukaran uang di atas (kadang-kadang

solusinya optimal kadang-kadang tidak).
Contoh-contoh persoalan yang diselesaikan
dengan Algoritma Greedy
1. Persoalan penukaran uang (coin exchange problem)
2. Persoalan memilih aktivitas (activity selection problem)
3. Minimisasi waktu di dalam sistem
4. Persoalan knapsack (knapsack problem)
5. Penjadwalan Job dengan tenggat waktu (job schedulling with
deadlines)
6. Pohon merentang minimum (minimum spanning tree)
7. Lintasan terpendek (shortest path)
8. Kode Huffman (Huffman code)
9. Pecahan Mesir (Egyptian fraction)
1. Persoalan Penukaran Uang
• Persoalan ini sudah kita bahas sebelumnya
• Di sini kita formulasikan kembali persoalan ini secara matematis
• Persoalan penukaran uang:
Nilai uang yang ditukar: A
Himpunan koin (multiset): {d1, d2, …}.
Himpunan solusi: X = {x1, x2, …, xn}, xi = 1 jika di dipilih, xi = 0 jika di tidak dipilih.
Obyektif persoalan adalah

n
Minimisasi F =  x i
(fungsi obyektif)
i =1
n
dengan kendala  d x = A i i
i =1
17
• Karena X = {x1, x2, …, xn} dan xi bernilai 1 atau 0, maka terdapat 2n

kemungkinan solusi (yaitu terdapat 2n kemungkinan vektor X)
• Untuk mengevaluasi fungsi obyektif kebutuhan waktunya O(n)
• Kompleksitas algoritma exhaustive search seluruhnya = O(n  2n ).
18
• Strategi greedy: Pada setiap langkah, pilih koin dengan nilai terbesar dari himpunan
koin yang tersisa.
function CoinExchange(C : himpunan_koin, A : integer) → himpunan_solusi
{ mengembalikan koin-koin yang total nilainya = A, tetapi jumlah koinnya minimum }
Deklarasi
S : himpunan_solusi
x : koin
Algoritma
S  {}
while ((nilai semua koin di dalam S)  A) and (C  {} ) do
x  koin yang mempunyai nilai terbesar
C  C – {x}
if ((nilai semua koin di dalam S) + nilai koin x  A then
S  S  {x}
endif
endwhile
if ((nilai semua koin di dalam S) = A then
return S
else
write(’tidak ada solusi’)
endif
19
• Memilih koin bernilai terbesar dari himpunan dengan n koin kompleksitasnya
adalah O(n), menjumlahkan semua koin di dalam S juga O(n).
• Kalang while diulang maksimal sebanyak jumlah koin di dalam himpunan, yaitu n
kali.
• Sehingga kompleksitas algoritma CoinExchange adalah O(n2)
• Agar pemilihan koin uang berikutnya optimal, maka kita perlu mengurutkan
himpunan koin dalam urutan yang menurun (noninceasing order).
• Jika himpunan koin sudah terurut menurun, maka kompleksitas algoritma

CoinExchange adalah O(n). Namun jika kompleksitas algoritma pengurutan
diperhitungkan, maka kompleksitas algoritma CoinExchange adalah O(n2) jika
algoritma pengurutan yang digunakan adalah algoritma brute force.
• Sayangnya, algoritma greedy untuk persoalan penukaran uang ini tidak selalu
menghasilkan solusi optimal (lihat contoh-contoh sebelumnya).
20
2. Persoalan memilih aktivitas
(activity selection problem)
• Persoalan: Misalkan terdapat n buah aktivitas, S = {1, 2, …, n}, yang ingin
menggunakan sebuah resource (misalnya ruang pertemuan, studio, prosesor,
dll). Resource hanya dapat digunakan oleh satu aktivitas dalam satu waktu.
Setiap kali suatu aktivitas memakai (occupy) resource, maka aktivitas lain tidak
dapat menggunakannya sebelum aktivitas tersebut selesa.
Setiap aktivitas i memiliki waktu mulai si dan waktu selesai fi, yang dalam hal ini
si  fi. Dua aktivitas i dan j dikatakan kompatibel jika interval [si, fi] dan [sj, fj]
tidak beririsan.
Persoalan activity selection problem ialah bagaimana memilih sebanyak

mungkin aktivitas yang dapat dilayani oleh resource.
21
Contoh 4: Contoh instansiasi persoalan. Misalkan terdapat n = 11 buah aktivitas
dengan waktu mulai dan waktu selesai masing-masing sebagai berikut:
i si fi
------------------------
1 1 4
2 3 5
3 4 6
4 5 7
5 3 8
6 7 9
7 10 11
8 8 12
9 8 13
10 2 14
11 13 15
22
Langkah-langkah:
• Tentukan semua himpunan bagian dari himpunan dengan n aktivitas.
• Evaluasi setiap himpunan bagian apakah semua aktivitas di dalamnya

kompatibel.
• Jika kompatibel, maka himpunan bagian tersebut adalah salah satu kandidat
solusinya.
• Pilih kandidat solusi yang memiliki jumlah aktivitas paling banyak.
• Kompleksitas waktu algoritmanya O(n  2n). Mengapa?

23
Penyelesaian dengan Algoritma Greedy
• Apa strategi greedy-nya?

1. Urutkan semua aktivitas berdasarkan waktu selesainya terurut dari
kecil ke besar
2. Pada setiap langkah, pilih aktivitas yang waktu mulainya lebih besar
atau sama dengan waktu selesai aktivitas yang sudah dipilih
sebelumnya
24
------------- Solusi:
i si fi
------------- A = {1}, fj = 4
1 1 4 A = {1, 3}, fj = 6
2 3 5 A = {1, 3, 6}, fj = 9
3 4 6 A = {1, 3, 6, 7}, fj = 11
4 5 7
5 3 8 A = {1, 3, 6, 7, 11}, fj = 15
6 7 9
7 10 11
8 8 12
9 8 13
10 2 14
11 13 15
-------------
Solusi: aktivitas yang dipilih adalah 1, 3, 6, 7, dan 11 (5 aktivitas)

25
Contoh 5: Contoh lain untuk n = 12 aktivitas
Sumber: http://scanftree.com/Data_Structure/activity-selection-problem
26
• Solusi dengan Algoritma Greedy:
27
Algoritma greedy untuk activity selection problem
function Greedy-Activity-Selector(s1, s2, …, sn : integer, f1, f2, …, fn : integer) → set of integer
{ Asumsi: aktivitas sudah diurut terlebih dahulu berdasarkan waktu selesai: f1 <= f2 <= … <= fn }
Deklarasi
i, j, n : integer
A : set of integer
Algoritma:
n ← length(s)
A ← {1} { aktivitas nomor 1 selalu terpilih }
j←1
for i ← 2 to n do
if si  fj then
A ← A  {i]
j←i
endif
endif
Kompleksitas algoritma: O(n) {jika waktu pengurutan tidak diperhtungkan}

28
Pembuktian optimalitas algoritma greedy untuk persoalan activity
selection problem
• Misalkan S = {1, 2,…, n} adalah himpunan aktivitas yang sudah diurutkan
berdasarkan waktu selesai.
• Asumsikan A  S adalah solusi optimal, juga diurutkan berdasarkan waktu
selesai dan aktivitas pertama di dalam A adalah “k1”
• Jika k1 = 1, maka A dimulai dengan pilihan greedy
• Jika k1  1, maka solusi optimal ini tidak dimulai dengan pilihan greedy.
• Kita akan menunjukkan bahwa B = (A – { k1}) ∪ {1}, yang dimulai dengan
pilihan greedy (aktivitas 1), adalah solusi optimal lainnya.
• Karena f1 ≤ fk1, dan aktivitas-aktivitas di dalam A kompatibel, aktivitas-
aktivitas di dalam B juga kompatibel. Karena |A| = |B|, maka B juga
optimal.
• Karena itu kita menyimpulkan selalu terdapat solusi optimal yang dimulai
dengan pilihan greedy.
• Usulan strategi greedy yang kedua: pilih aktivitas yang durasinya
paling kecil lebih dahulu dan waktu mulainya tidak lebih besar
dari waktu selesai aktivitas lain yang telah terpilih
→Boleh juga, karena tetapi harus bisa dibuktikan secara

matematis bahwa strategi ini juga optimal.
→Adakah yang bisa membuktikannya?
30
Solusi dengan strategi greedy yang kedua: memilih aktivitas yang
paling kecil lebih dahulu
i si fi durasi
----------------------------------
1 1 4 3
2 3 5 2
3 4 6 2
4 5 7 2
5 3 8 5
6 7 9 2
7 10 11 1
8 8 12 4
9 8 13 5
10 2 14 12
11 13 15 2
-----------------------------------
Solusi: aktivitas yang dipilih adalah 7, 2, 4, 6, dan 11 (5 aktivitas) 31
3. Minimisasi waktu di dalam sistem
• Persoalan: Sebuah server (dapat berupa processor, pompa, kasir di bank, tukang
cukur, dll) mempunyai n pelanggan (customer, client) yang harus dilayani. Waktu
pelayanan untuk setiap pelanggan i adalah ti.
Bagaimana cara meminimumkan total waktu di dalam sistem:
n
T=  (waktu di dalam sistem)
i =1
• Persoalan ini ekivalen dengan meminimumkan waktu rata-rata pelanggan di

dalam sistem.
32
Contoh 6: Tiga pelanggan dengan
t1 = 5, t2 = 10, t3 = 3,
Enam urutan pelayanan pelanggan yang mungkin adalah:

============================================
Urutan pelanggan T
============================================
1, 2, 3: 5 + (5 + 10) + (5 + 10 + 3 ) = 38
1, 3, 2: 5 + (5 + 3) + (5 + 3 + 10) = 31
2, 1, 3: 10 + (10 + 5) + (10 + 5 + 3) = 43
2, 3, 1: 10 + (10 + 3) + (10 + 3 + 5) = 41
3, 1, 2: 3 + (3 + 5) + (3 + 5 + 10) = 29  (optimal)
3, 2, 1: 3 + (3 + 10) + (3 + 10 + 5) = 34
============================================ 33
• Contoh persoalan lain yang mirip dengan miniminasi waktu di dalam sistem
adalah optimal storage on tapes (penyimpanan program secara optimal di dalam
pita) atau penyimpanan lagu (musik) di dalam pita kaset.
• Pita kaset adalah media penyimpanan sinyal analog pada masa lalu. Pita kaset
merupakan media penyimpanan yang bersifat sekuensial.
• Lagu-lagu (atau program-program) disimpan di dalam pita kaset secara sekuensial.
Panjang setiap lagu i adalah ti (dalam satuan menit atau detik). Untuk menemukan
(retrieve) dan memainkan sebuah lagu, pita pada mulanya diposisikan pada bagian
awal.
• Jika lagu-lagu di dalam pita disimpan dalam urutan I = i1, i2, …, in, maka lama waktu
yang dibutuhkan untuk memainkan lagu ij sampai selesai adalah σ𝑖≤𝑘≤𝑗 𝑡𝑖𝑘
• Jika semua lagu sering dimainkan, maka waktu rata-rata retrieval (mean retrieval
1
time atau MRT) adalah σ𝑖≤𝑗≤𝑛 𝑡𝑗 .
𝑛
• Pada persoalan optimal storage on tapes, kita diminta menemukan permutasi n

buah lagu sedemikian sehingga bila lagu-lagu itu disimpan di dalam pita kaset akan
meminimumkan MRT.
• Meminimumumkan MRT ekivalen dengan meminimumkan d(I) = σ1≤𝑗≤𝑛 σ1≤𝑘≤𝑗 𝑡𝑖𝑘

• Perhatikan bahwa urutan pelanggan yang dilayani oleh server

merupakan suatu permutasi
• Jika ada n orang pelanggan, maka tedapat n! urutan pelanggan
• Untuk mengevaluasi fungsi obyektif : O(n)
• Kompleksitas algoritma exhaustive search = O(nn!)
36
• Strategi greedy: Pada setiap langkah, pilih pelanggan yang membutuhkan
waktu pelayanan terkecil di antara pelanggan lain yang belum dilayani.
function PenjadwalanPelanggan(C : himpunan_pelanggan) → himpunan_pelanggan

{ mengembalikan urutan jadwal pelayanan pelanggan yang meminimumkan waktu di dalam sistem }
Deklarasi
S : himpunan_pelanggan
i : pelanggan
Algoritma
S  {}
while (C  {}) do
i  pelanggan yang mempunyai t[i] terkecil
C  C – {i}
S  S  {i}
endwhile
return S
37
• Agar proses pemilihan pelanggan berikutnya optimal, urutkan pelanggan
berdasarkan waktu pelayanan dalam urutan yang menaik.
• Jika pelanggan sudah terurut, kompleksitas algoritma greedy = O(n).
procedure PenjadwalanPelanggan(input n : integer)

{ Mencetak informasi deretan pelanggan yang akan diproses oleh server tunggal
Masukan: n pelangan, setiap pelanggan dinomori 1, 2, …, n. Pelanggan sudah terurut berdasarkan
ti yang menaik
Luaran: urutan pelanggan yang dilayani }
Deklarasi
i : integer
Algoritma:
{pelanggan 1, 2, ..., n sudah diurut menaik berdasarkan ti}
for i1 to n do
write(i)
endfor
38
• Algoritma greedy untuk penjadwalan pelanggan berdasarkan waktu layanan
yang terurut menaik akan selalu menghasilkan solusi optimal .
• Hal ini dinyatakan di dalam teorema berikut:
Teorema. Jika t1  t2  …  tn maka pengurutan ij = j, 1  j  n meminimumkan

n k
T=  t
k =1 j =1
ij
untuk semua kemungkinan permutasi ij.
Bukti untuk teorema ini dapat dibaca pada slide berikut (Sumber: Ellis Horrowitz
& Sartaj Sahni, Computer Algorithms, 1998)
39
(Sumber: Ellis Horrowitz & Sartaj Sahni,
Computer Algorithms, 1998)
4. Integer Knapsack Problem
• Persoalan: Diberikan n buah objek dan sebuah
knapsack dengan kapasitas bobot K. Setiap objek
memiliki properti bobot (weigth) wi dan
keuntungan(profit) pi.

dimasukkan ke dalam knapsack sedemikian
sehingga diperoleh total keuntungan yang
maksimal. Total bobot objek yang dimasukkan
tidak boleh melebihi kapasitas knapsack.
• Disebut 1/0 knapsack problem karena suatu

objek dapat dimasukkan ke dalam knapsack
(1) atau tidak dimasukkan sama sekali (0)
41
• Formulasi matematis persoalan Integer Knapsack:
n
i =1

n
w x  K
i =1
i i

Penyelesaian dengan algoritma brute force (exhaustive search)
• Sudah dijelaskan pada Bab Algoritma Brute Force (pembahasan

exhaustive search)
• Kompleksitas algoritma exhaustive search untuk persoalan integer

knapsack adalah O(n  2n).
43
• Masukkan objek satu per satu ke dalam knapsack. Sekali objek

dimasukkan ke dalam knapsack, objek tersebut tidak bisa
dikeluarkan lagi.
• Terdapat beberapa strategi greedy yang heuristik yang dapat

digunakan untuk memilih objek yang akan dimasukkan ke dalam
knapsack:
44
1. Greedy by profit.
- Pada setiap langkah, pilih objek yang mempunyai keuntungan terbesar.
- Strategi ini mencoba memaksimumkan keuntungan dengan memilih objek yang paling
menguntungkan terlebih dahulu.
2. Greedy by weight.
- Pada setiap langkah, pilih objek yang mempunyai berat teringan.
- Mencoba memaksimumkan keuntungan dengan dengan memasukkan sebanyak
mungkin objek ke dalam knapsack.
3. Greedy by density.
- Pada setiap langkah, knapsack diisi dengan objek yang mempunyai pi /wi terbesar.
- Mencoba memaksimumkan keuntungan dengan memilih objek yang mempunyai
keuntungan per unit berat terbesar.
45
• Pemilihan objek berdasarkan salah satu dari ketiga strategi di atas
tidak menjamin akan memberikan solusi optimal.
46
Contoh 7. Diberikan 4 buah objek sbb:
(w1, p1) = (6, 12); (w2, p2) = (5, 15); (w3, p3) = (10, 50); (w4, p4) = (5, 10);
dan sebuah knapsack dengan kapasitas K = 16.
Solusi dengan algoritma greedy:
Properti objek Greedy by Solusi

i wi pi pi /wi profit weight density Optimal
1 6 12 2 0 1 0 0
2 5 15 3 1 1 1 1
3 10 50 5 1 0 1 1
4 5 10 2 0 1 0 0
Total bobot 15 16 15 15
Total keuntungan 65 37 65 65
• Solusi optimal: X = (0, 1, 1, 0)

• Greedy by profit dan greedy by density memberikan solusi optimal! Apakah
untuk kasus lain juga optimal? Perhatikan Contoh 8 berikut.
47
(w1, p1) = (100, 40); (w2, p2) = (50, 35); (w3, p3) = (45, 18);
(w4, p4) = (20, 4); (w5, p5) = (10, 10); (w6, p6) = (5, 2);
dan sebuah knapsack dengan kapasitas K = 100. Solusi dengan algoritma greedy:
Properti objek Greedy by Solusi

i wi pi pi /wi profit weight density Optimal
1 100 40 0,4 1 0 0 0
2 50 35 0,7 0 0 1 1
3 45 18 0,4 0 1 0 1
4 20 4 0,2 0 1 1 0
5 10 10 1,0 0 1 1 0
6 5 2 0,4 0 1 1 0
Total bobot 100 80 85 100
Total keuntungan 40 34 51 55
• Ketiga strategi gagal memberikan solusi optimal!

48
Kesimpulan: Algoritma greedy tidak selalu berhasil menemukan
solusi optimal untuk persoalan integer knapsack.
49
5. Fractional Knapsack Problem
• Fractional knapsack problem merupakan varian persoalan knapsack tetapi dengan
solusi yang boleh berbentuk pecahan atau fraksi
• Objek yang dimasukkan ke dalam knapsack dapat berupa sebagian saja (0  xi  1)
n
i =1

n
w x  K
i =1
i i
yang dalam hal ini, 0  xi  1, i = 1, 2, …, n
50
• Oleh karena 0  xi  1, maka terdapat tidak berhinga nilai-nilai xi.
• Persoalan Fractional Knapsack menjadi malar (continuous) sehingga

tidak mungkin dipecahkan dengan algoritma exhaustive search.
51
• Ketiga strategi greedy yang telah disebutkan pada integer knapsack

dapat digunakan untuk memilih objek yang akan dimasukkan ke
dalam knapsack.
• Mari kita bahas satu per satu

52
(w1, p1) = (18, 25); (w2, p2) = (15, 24); (w3, p3) = (10, 15);
dan sebuah knapsack dengan kapasitas K = 20.
Solusi dengan algoritma greedy:
Properti objek Greedy by

i wi pi pi /wi profit weight density
1 18 25 1,4 1 0 0
2 15 24 1,6 2/15 2/3 1
3 10 15 1,5 0 1 1/2
Total bobot 20 20 20
Total keuntungan 28,2 31,0 31,5
• Solusi optimal: X = (0, 1, 1/2)

• yang memberikan keuntungan maksimum = 31,5.
53
• Strategi pemilihan objek ke dalam knapsack berdasarkan densitas pi /wi
terbesar selalu memberikan solusi optimal.
• Agar proses pemilihan objek berikutnya optimal, maka kita urutkan objek
berdasarkan pi /wi yang menurun, sehingga objek berikutnya yang dipilih
adalah objek sesuai dalam urutan itu.
Teorema 2. Jika p1/w1  p2/w2  ...  pn/wn maka algoritma greedy dengan
strategi pemilihan objek berdasarkan pi /wi terbesar menghasilkan solusi
yang optimum.
• Kesimpulan: Algoritma greedy selalu berhasil menemukan solusi optimal

untuk persoalan fractional knapsack jika strategi memilih objek adalah
berdasarkan densitas terbesar lebih dahulu.
54
• Algoritma persoalan fractional knapsack:
1. Hitung harga pi/wi , i = 1, 2, ..., n

2. Urutkan seluruh objek berdasarkan nilai pi/wi dari besar ke kecil
3. Panggil prosedur FractinonalKnapsack
55
function FractionalKnapsack(C : himpunan_objek, K : real) → himpunan_solusi
{ Menghasilkan solusi persoalan fractional knapsack dengan algoritma greedy yang menggunakan strategi
pemilihan objek berdasarkan density (pi/wi). Solusi dinyatakan sebagai vektor X = x[1], x[2], …, x[n].
Asumsi: Seluruh objek sudah terurut berdasarkan nilai pi/wi yang menurun }
Deklarasi
i, TotalBobot : integer
MasihMuatUtuh : boolean
x : himpunan_solusi
Algoritma:
for i  1 to n do
x[i]  0 { inisialisasi setiap fraksi objek i dengan 0 }
endfor
….
56
i0
TotalBobot  0
MasihMuatUtuh  true
while (i  n) and (MasihMuatUtuh) do

{ tinjau objek ke-i }
ii+1
if TotalBobot + w[i]  K then
{ masukkan objek i ke dalam knapsack }
x[i]  1
TotalBobot  TotalBobot + w[i]
else { masukkan fraksi objek tersebut }
MasihMuatUtuh  false
x[i]  (K – TotalBobot)/w[i]
endif
endwhile
{ i > n or not MasihMuatUtuh }
return x
Kompleksitas waktu algoritma (jika pengurutan tidak diperhitungkan) = O(n).

6. Penjadwalan Job dengan Tenggat Waktu (Job
Schedulling with Deadlines)
Deskripsi persoalan:
• Ada n buah job yang akan dikerjakan oleh sebuah mesin;
• Tiap job diproses oleh mesin selama 1 satuan waktu dan tenggat
waktu (deadline) pengerjaan setiap job i adalah di  0;
• Job i akan memberikan keuntungan sebesar pi jika dan hanya jika job
tersebut diselesaikan tidak melebihi tenggat waktunya;
• Bagaimana memilih job-job yang akan dikerjakan oleh mesin sehingga

keuntungan yang diperoleh dari pengerjaan itu maksimum?
58
Contoh 10. Misalkan terdapat 4 job (n = 4):
(p1, p2, p3, p4) = (50, 10, 15, 30)
(d1, d2, d3, d4) = (2, 1, 2, 1)
Andaikan mesin mulai bekerja jam 6.00 pagi, maka itu artinya:
Job Tenggat Harus selesai

(di) sebelum pukul
1 2 jam 8.00
2 1 jam 7.00
3 2 jam 8.00
4 1 jam 7.00
59
• Misalkan J adalah himpunan job yang diproses oleh mesin. Maka,
fungsi obyektif persoalan ini:
Maksimasi F =  pi
iJ
• Solusi layak: himpunan J yang berisi urutan job yang sedemikian

sehingga setiap job di dalam J selesai dikerjakan sebelum tenggat
waktunya.
• Solusi optimum ialah solusi layak yang memaksimumkan F.
60
Cari himpunan bagian (subset) job yang layak dan memberikan total keuntungan terbesar.
Barisan job Urutan pemrosesan Total keuntungan (F) Keterangan
{} - 0 layak
{1} 1 50 layak
{2} 2 10 layak
{3} 3 15 layak
{4} 4 30 layak
{1, 2} 2, 1 60 layak
{1, 3} 1, 3 atau 3, 1 65 layak
{1, 4} 4, 1 80 layak → optimal
{2, 3} 2, 3 25 layak
{2, 4} - - tidak layak
{3, 2} - - tidak layak
{3, 4} 4, 3 45 layak
{1, 2, 3} - - tidak layak
{1, 2, 3, 4} - - tidak layak
Kompleksitas algoritma: O(n  2n) 61

Pemecahan Masalah dengan Algoritma Greedy
• Strategi greedy untuk memilih job:
“Pada setiap langkah, pilih job i dengan pi yang terbesar untuk

menaikkan nilai fungsi obyektif F “
• Misalkan himpunan yang berisi job-job yang sudah dipilih disimpan di

dalam himpunan J. Tempatkan job i di dalam J dalam suatu urutan
sedemikian sehingga semua job selesai dikerjakan sebelum deadline.
62
Contoh 11: Misalkan terdapat 4 job dengan profit dan deadline
sebagai berikut:
(p1, p2, p3, p4) = (50, 10, 15, 30)
(d1, d2, d3, d4) = (2, 1, 2, 1)
Langkah J F = pi Keterangan

0 {} 0 -
1 {1} 50 layak
2 {4,1} 50 + 30 = 80 layak
3 {4, 1, 3} - tidak layak
4 {4, 1, 2} - tidak layak
Solusi optimal: J = {4, 1} dengan F = 80.

63
function JobSchedulling(d[1..n] : array of integer, p[1..n] : array of integer) → himpunan_job
{ Menghasilkan barisan job yang akan diproses oleh mesin }
Deklarasi
i, k : integer
J : himpunan_job { solusi }
Algoritma
J  {}
for i  1 to n do
k  job yang mempunyai profit terbesar
if (semua job di dalam J  {k} layak) then
J  J  {k}
endif
endfor
return J
Memilih job yang mempunyai pi terbesar : O(n)

Pengulangan while dilakukan sebanyak n kali (sebanyak himpunan job di dalam C)
Kompleksitas algoritma JobSchedulling: O(n2). 64
• Agar pencarian solusi lebih sangkil (effective), maka job-job diurut terlebih dahulu
berdasarkan profitnya dari profit terbesar ke profit kecil.
• Algoritmanya menjadi sebagai berikut:
function JobSchedulling2(d[1..n] : array of integer, p[1..n] : array of integer) → himpunan_job

{ Menghasilkan barisan job yang akan diproses oleh mesin
{ Job-job sudah diurutkan terlebih dahulu berdasarkan profit dari besar ke kecil }
Deklarasi
i : integer
J : himpunan_job { solusi }
Algoritma
J  {1} { job 1 selalu terpilih}
for i  2 to n do
if (semua job di dalam J  {i} layak) then
J  J  {i}
endif
endfor
return J
• Algoritma yang lebih detil:
(Sumber: Ellis Horrowitz & Sartaj Sahni,

Computer Algorithms, 1998)
67
(Sumber: Ellis Horrowitz & Sartaj Sahni, Computer Algorithms, 1998)
Algoritma Greedy
(Bagian 2)
Oleh: Rinaldi Munir

2021
7. Pohon Merentang Minimum
1 10 2
50
30 45 40 3
35
4
25
5
20 55
15
(a) Graf G = (V, E) (b) Pohon merentang minimum
2
(a) Algoritma Prim
• Misalkan pohon merentang minimum yang dibangun adalah

himpunan T.
• Strategi greedy yang digunakan di dalam Algoritma Prim:
“Pada setiap langkah, pilih sisi e = (v1, v2) dari graf G(V, E)
yang memiliki bobot terkecil dan bersisian (incidency)
dengan simpul-simpul di T tetapi e tidak membentuk
sirkuit di T. Masukkan e ke dalam T. “
3
Algoritma Prim
Langkah 1: ambil sisi dari graf G yang berbobot minimum,
masukkan ke dalam T.
Langkah 2: pilih sisi (u, v) yang mempunyai bobot minimum dan

bersisian dengan simpul di T, tetapi (u, v) tidak
membentuk sirkuit di T. Masukkan (u, v) ke dalam T.
Langkah 3: ulangi langkah 2 sebanyak n – 2 kali.

procedure Prim(input G : graf, output T : pohon)
{ Membentuk pohon merentang minimum T dari graf berbobot G.
Masukan: graf-berbobot terhubung G = (V, E), dengan V= n
Luaran: pohon rentang minimum T = (V, E’) }
Deklarasi
i, p, q, u, v : integer
Algoritma
Cari sisi (p, q) dari E yang berbobot terkecil
T  {(p, q)}
for i1 to n – 2 do
Pilih sisi (u, v) dari E yang bobotnya terkecil namun bersisian dengan simpul di T
T  T  {(u, v)}
endfor
Komplesitas algoritma: O(n2)

5
Langkah Sisi Bobot Pohon rentang
Contoh 12:
1 10 2
1 (1, 2) 10
1 10 2 2
1 10
50
2 (2, 6) 25
30 45 40 3
35 25
4
25
5 6
20 55 15
1 10
3 (3, 6)
15
3
25
6
15
1 10 2
4 (4, 6) 20
3
4
25
20
15
1 10 2
5 (3, 5) 35
45 3
35
4
25
5
20 55
15
6
6
(b) Algoritma Kruskal
• Urutkan terlebih dahulu sisi-sisi di dalam graf berdasarkan bobotnya

dari kecil ke besar
• Strategi greedy yang digunakan:
“Pada setiap langkah, pilih sisi e = (v1, v2) dari graf G = (V, E) yang
memiliki bobot minimum. Jika e tidak membentuk sirkuit di T, maka
masukkan e ke dalam T”
7
Algoritma Kruskal
( Langkah 0: sisi-sisi dari graf sudah diurut menaik berdasarkan
bobotnya – dari bobot kecil ke bobot besar)
Langkah 1: T masih kosong
Langkah 2: pilih sisi (u, v) dengan bobot minimum yang tidak

membentuk sirkuit di T. Tambahkan (u, v) ke dalam
T.
Langkah 3: ulangi langkah 2 sebanyak n – 1 kali.

procedure Kruskal(input G : graf, output T : pohon)
{ Membentuk pohon merentang minimum T dari graf berbobot G.
Masukan: graf-berbobot terhubung G = (V, E), dengan V= n
Luaran: pohon rentang minimum T = (V, E’) }
Deklarasi
i, u, v : integer
Algoritma
{ Asumsi: sisi-sisi dari graf sudah diurut menaik berdasarkan bobotnya dari kecil ke besar}
T  {}
while jumlah sisi di dalam T < n – 1 do
Pilih sisi (u, v) dari E yang bobotnya terkecil
if (u, v) tidak membentuk sirkuit di T then
T  T  {(u, v)}
endif
endfor
Kompleksitas algoritma: O(|E| log |E|)

9
Sisi-sisi diurut menaik:
Contoh 13:
Sisi (1,2) (3,6) (4,6) (2,6) (1,4) (3,5) (2,5) (1,5) (2,3) (5,6)
1 10 2 Bobot 10 15 20 25 30 35 40 45 50 55
50
30 45 40 3 Langkah Sisi Bobot Hutan merentang
35
4
25
5 0 1 2 3 4 5 6
20 55
15
6 1 (1, 2) 10
1 2
2 (3, 6) 15
1 2 3 4 5
3 (4, 6) 20
1 2 3 5
4
6
4 (2, 6) 25
1 2 3 5
4
10
5 (1, 4) 30 ditolak
6 (3, 5) 35
1 2
3
5
4
6
Pohon merentang minimum yang dihasilkan:

1 10 2
45 3
35
4
25
5
20 55
15
Bobot = 10 + 25 + 15 + 20 + 35 = 105
11
12
(Sumber: Ellis Horrowitz & Sartaj Sahni, Computer Algorithms, 1998)
8. Lintasan Terpendek (Shortest Path)
Beberapa macam persoalan lintasan terpendek:
a) Lintasan terpendek antara dua buah simpul tertentu (a pair
shortest path).
b) Lintasan terpendek antara semua pasangan simpul (all pairs
shortest path).
c) Lintasan terpendek dari simpul tertentu ke semua simpul yang
lain (single-source shortest path).
d) Lintasan terpendek antara dua buah simpul yang melalui
beberapa simpul tertentu (intermediate shortest path).
→ Yang akan dibahas adalah persoalan c)

13
Persoalan lintasan terpendek:
Diberikan graf berbobot G = (V, E). Tentukan lintasan terpendek
dari sebuah simpul asal a ke setiap simpul lainnya di G.
Asumsikan semua sisi di dalam graf berbobot positif.
Berapa jarak terpendek

berikut lintasannya dari:
a ke b?
a ke c?
a ke d?
a ke e?
a ke f?
14
• Misalkan ingin menentukan jarak terpendek dari a ke b

• Enumerasi semua lintasan yang mungkin dibentuk dari a ke b,
hitung total bobotnya
• Lintasan yang memiliki bobot terkecil adalah lintasan terpendek
dari a ke b
• Ulangi cara yang sama untuk jarak terpendek dari a ke c, dari a
ke d, dan seterusnya.
15
Penyelesaian dengan Algoritma Greedy
• Misalkan ingin menentukan jarak terpendek dari a ke b
• Strategi greedy: pada setiap langkah, pilih sisi (u, v) dengan

bobot terkecil
• Ulangi cara yang sama untuk jarak terpendek dari a ke c, dari a

ke d, dan seterusnya.
16
• Namun, strategi greedy di atas tidak selalu menjamin solusi optimal
• Contoh: Lintasan terpendek dari 1 ke 10 pada graf di bawah ini!
7
2 5
1
2 4 3 4
6 8 3
6
4
1 3 2 6 3 10
3 9 4
4
3 1
4
3
4 7
5
Greedy: 1 – 2 – 6 – 9 – 10 dengan bobot = 2 + 4 + 3 + 4 = 13 → Tidak optimal

Solusi optimal: 1 – 3 – 5 – 8 – 10 dengan bobot = 4 + 3 + 1 + 2 = 11
17
Algoritma Dijkstra
• Merupakan algoritma yang optimal untuk menentukan lintasan terpendek.
• Lintasan terpendek dibangun langkah per langkah. Pada langkah pertama

bangun lintasan terpendek pertama, pada langkah kedua bangun lintasan
terpendek kedua, demikian seterusnya.
• Strategi greedy yang digunakan:

“Pada setiap langkah, pilih lintasan berbobot minimum yang menghubungkan
simpul yang sudah terpilih dengan sebuah simpul lain yang belum terpilih.
Lintasan dari simpul asal ke simpul yang baru haruslah merupakan lintasan yang
terpendek diantara semua lintasannya ke simpul-simpul yang belum terpilih.”
18
Edsger W. Dijkstra (1930–2002)
• Edsger Wybe Dijkstra was one of the most
influential members of computing science's
founding generation. Among the domains in which
his scientific contributions are fundamental are
• algorithm design
• programming languages
• program design
• operating systems
• distributed processing
In addition, Dijkstra was intensely interested in teaching, and in the

relationships between academic computing science and the software
industry. During his forty-plus years as a computing scientist, which included
positions in both academia and industry, Dijkstra's contributions brought
him many prizes and awards, including computing science's highest honor,
the ACM Turing Award.
Sumber: http://www.cs.utexas.edu/users/EWD/ 19
procedure Dijkstra (input G: weighted_graph, input a: intial_vertex, output L : array [1..n] of real)
{ Mencari lintasan terpendek dari simpul a ke semua simpul lain di dalam graf berbobot G.
Masukan: graf-berbobot yang terhubung, G = (V, E) dengan V= n
Luaran: L[1..n], L[i] berisi panjang terpendek dari simpul a ke simpul vi }
Deklarasi:
i : integer
u, v : vertex
S : set of vertex { himpunan solusi untuk mencatat simpul-simpul yang sudah dipilih di dalam tur }
Algoritma
for i1 to n
L(vi)  
endfor
L(a)  0 { jarak dari a ke a adalah 0 }
S{}
for k  1 to n do
u  pilih simpul yang belum terdapat di dalam S dan memiliki L(u) minimum
S  S  {u} { masukkan u ke dalam S }
for semua simpul v yang tidak terdapat di dalam S
{ update jarak yang baru dari a ke v }
if L(u) + G(u, v) < L(v) then { jarak dari a ke u ditambah bobot sisi dari u ke v lebih kecil dari jarak a ke v }
L(v)  L(u) + G(u, v) { jarak dari a ke v yang baru diganti dengan L(u) + G(u, v) }
endif
endfor
enfor
20
Contoh 14: Diberikan graf G di bawah ini. Carilah lintasan terpendek dari simpula a
ke semua simpul lainnya.
(Sumber: Rosen, Discrete Mathematics and Its Application, 7th Edition)

Penyelesaian: (Sumber: Rosen, Discrete Mathematics and Its Application, 7th Edition)
Jadi, lintasan terpendek (dimulai dari lintasan yang bobot terkecil) dari:
a ke c adalah a, c dengan bobot = 2
a ke b adalah a, c, b dengan bobot = 3
a ke d adalah a, c, b, d dengan bobot = 8
a ke e adalah a, c, b, d, e dengan bobot = 10
a ke z adalah a, c, b, d, e, z dengan bobot = 13
• Kompleksitas Algoritma Dijkstra ditentukan oleh kalang (loop) berikut:
for k  1 to n do
u  pilih simpul yang belum terdapat di dalam S dan memiliki L(u) minimum
S  S  {u} { masukkan u ke dalam S }
for semua simpul v yang tidak terdapat di dalam S
{ update jarak yang baru dari a ke v }
if L(u) + G(u, v) < L(v) then
L(v)  L(u) + G(u, v)
endif
endfor
endfor
(i) Memilih simpul u yang bukan di dalam S dan memiliki L(u) minimum
→ membutuhkan paling banyak n – 1 perbandingan: O(n)
(ii) Memperbarui (update) jarak yang baru dari a ke v:
→ membutuhkan paling banyak n – 1 perbandingan dan n – 1 penjumlahan: O(n)
(ii) Pengulangan for k dari 1 sampai n dilakukan sebanyak n kali
Kompleksitas waktu algoritma Dijkstra: T(n) = n { O(n) + O(n) } = O(n2)

Aplikasi algoritma Dijkstra:
→Routing pada jaringan komputer
25
• Pesan yang dikirim dari satu komputer ke komputer lainnya umumnya
dipecah menjadi sejumlah paket (packet) data yang berukuran lebih
kecil.
• Untuk menyampaikan paket data dari dari satu komputer ke komputer

lainnya, sistem jaringan komputer harus dapat melakukan pemilihan
rute yang tepat agar paket dapat sampai ke komputer tujuan dalam
waktu yang cepat.
• Yang dimaksud dengan perutean (routing) adalah menentukan lintasan

yang dilalui oleh paket dari komputer pengirim (asal) ke komputer
penerima (tujuan).
26
• Router adalah komputer yang didedikasikan untuk mengarahkan pesan
dari suatu simpul ke simpul lainnya.
• Setiap router memelihara sebuah tabel yang disebut tabel rute (routing
table). Tabel rute berisi alamat komputer asal, alamat komputer tujuan,
dan simpul antara (via) yang dilalui.
27
Contoh sebuah jaringan router:
Router 1
Mencari lintasan terpendek dari router asal ke router tujuan dapat diartikan
sebagai menentukan lintasan terpendek dari simpul asal ke simpul tujuan di
dalam jaringan komputer.
28
Lintasan terpendek (berdasarkan delay time):
Router Asal Router Tujuan Lintasan Terpendek
1 1 -
2 1, 4, 2
3 1, 4, 6, 3
4 1, 4
5 1, 4, 2, 5
6 1, 4, 6
2 1 2, 4, 1
2 -
3 2, 4, 6, 3
4 2, 4
5 2, 5
6 2, 4, 6
3 1 3, 6, 4, 1
2 3, 6, 4, 2
3 -
4 3, 6, 4
5 3, 5
6 3, 6
4 1 4, 1
2 4, 2
3 4, 6, 2
4 4, 6, 3
5 4, 2, 5
6 4, 6
29
Router 1
30
Algoritma Greedy
(Bagian 3)
Oleh: Rinaldi Munir

2021
9. Kode Huffman
(pemampatan data dengan algoritma Huffman
• Prinsip kode Huffman:
- karakter yang paling sering muncul di dalam data dengan kode yang
lebih pendek;
- sedangkan karakter yang relatif jarang muncul dikodekan dengan kode
yang lebih panjang.
2
Fixed-length code
Misalkan terdapat sebuah pesan yang panjangnya 100.000 karakter dengan

frekuensi kemunculan huruf-huruf (hanya a, b, c, d, e, f) di dalam pesan tersebut
adalah sbb:
Karakter a b c d e f
---------------------------------------------------------------------------
Frekuensi 45% 13% 12% 16% 9% 5%
Kode 000 001 010 011 100 111
Pesan ‘bad’ dikodekan sebagai ‘001000011’
Pengkodean 100.000 karakter pesan membutuhkan 300.000 bit.

3
Variable-length code (Huffman code)
-----------------------------------------------------------------------------
Frekuensi 45% 13% 12% 16% 9% 5%
-----------------------------------------------------------------------------
Kode 0 101 100 111 1101 1100
‘bad’ dikodekan sebagai ‘1010111 ’
Pengkodean 100.000 karakter membutuhkan

(0,45  1 + 0,13  3 + 0,12  3 + 0,16  3 +
0,09  4 + 0,05  4)  100.000 = 224.000 bit
Nisbah (ration) pemampatan: (300.000 – 224.000)/300.000  100% = 25,3%

4
• Algoritma greedy untuk membentuk kode Huffman bertujuan untuk
meminimumkan panjang kode biner untuk setiap simbol karakter di
dalam pesan (M1, M2, …, Mn).
• Pembentukan kode Huffman menggunakan pohon biner (binary tree)

berbobot. Setiap simpul daun pada pohon biner menyatakan simbol
karakter di dalam pesan, sedangkan simpul bukan daun (internal nodes)
menyatakan penggabungan simbol-simbol.
• Setiap sisi pada pohon biner diberi nilai (label) 0 atau 1 secara konsisten
(misalnya sisi cabang kiri dengan 0, sisi cabang kanan dengan 1)
• Lintasan dari akar ke daun sama dengan barisan bi-bit biner yang
merepresentasikan simbol karakter pada daun.
• Meminimumkan panjang kode biner untuk setiap symbol karakter

ekivalen dengan dengan meminimumkan panjang lintasan dari akar ke
daun.
5
Langkah-langkah pembentukan pohon biner di dalam Algoritma Huffman:
1. Baca semua karakter di dalam data untuk menghitung frekuensi kemunculan

setiap karakter. Setiap karakter penyusun data dinyatakan sebagai pohon
bersimpul tunggal. Setiap simpul di-assign dengan frekuensi kemunculan karakter
tersebut.
2. Terapkan strategi greedy sebagai berikut: pada setiap langkah gabungkan dua
buah pohon yang mempunyai frekuensi terkecil pada sebuah akar. Akar
mempunyai frekuensi yang merupakan jumlah dari frekuensi dua buah pohon
penyusunnya.
3. Ulangi langkah 2 sampai hanya tersisa satu buah pohon Huffman.
4. Selanjutnya, beri label sisi-sisi di dalam pohon biner dengan 0 atau 1 secara
konsisten.
5. Lintasan dari akar ke daun merepresentasikan string biner untuk setiap karakter
Kompleksitas algoritma Huffman: O(n log n)

Contoh 15. Misalkan sebuah pesan panjangnya 100 karakter. Pesan
hanya disusun oleh huruf-huruf a, b, c, d, e, f. Frekuensi setiap huruf di
dalam pesan adalah sebagai berikut:
-------------------------------------------------------------------
Frekuensi 45 13 12 16 9 5
Carilah kode Huffman untuk setiap karakter di dalam pesan tersebut.
7
Penyelesaian:
1. f:5 e:9 c:12 b:13 d:16 a:45
2. c:12 b:13 fe:14 d:16 a:45
f:5 e:9
3. fe:14 d:16 cb:25 a:45
f:5 e:9 c:12 b:13

8
4. cb:25 fed:30 a:45
c:12 b:13 fe:14 d:16
f:5 e:9
9
5. cbfed:55 a:45
cb:25 fed:30
c:12 b:13 fe:14 d:16
f:5 e:9
Kode Huffman:
a=0
b = 101
6 acbfed:100
c = 100
0 1 d = 111
a:45 cbfed:55 e = 1101
0 1 f = 1100
cb:25 fed:30
0 1 0 1
c:12 b:13 fe:14 d:16
0 1
f:5 e:9 10
10. Pecahan Mesir (Egyptian Fraction)
Pecahan Mesir adalah pecahan, dalam bentuk p/q, yang dapat didekomposisi
pecahan menjadi jumlah dari sejumlah pecahan yang berbeda:
p 1 1 1
= + + ... +
q k1 k 2 kn
yang dalam hal ini, k1 < k2 < … < kn.
Contoh 16: Beberapa pecahan Mesir
2 1 1 5 1 1 1 87 1 1 1
= + = + + = + +
5 3 15 7 2 5 70 100 2 5 11
11
• Pecahan yang diberikan mungkin mempunyai lebih dari satu
representasi Mesir
Contoh: 8/15 = 1/3 + 1/5
8/15 = 1/2 + 1/30
• Persoalannya adalah, bagaimana mendekompoisinya dengan jumlah

unit pecahan sesedikit mungkin.
Contoh: 2 1 1
= + → didekomposisi menjadi hanya dua unit pecahan
5 3 15
12
Strategi greedy: pada setiap langkah, tambahkan unit pecahan terbesar ke
representasi yang baru terbentuk yang jumlahnya tidak melebihi nilai pecahan
yang diberikan
Algoritma:
Input: p/q
1. Mulai dengan i = 1
2. Jika p = 1, maka ki = q. STOP
3. 1/ki = pecahan terbesar yang lebih kecil dari p/q
4. p/q = p/q – 1/ki
5. Ulangi langkah 2.
13
• Contoh hasil:
8/15 = 1/2 + 1/30 (optimal)
5/7 = 1/2 + 1/5 + 1/70 (optimal)
tetapi, counterexample dengan algoritma greedy:

26/133 = 1/6 + 1/35 + 1/3990 (tidak optimal)
seharusnya (dengan brute force)

26/133 = 1/7 + 1/19 (optimal)
• Kesimpulan: algoritma greedy untuk masalah pecahan Mesir tidak

selalu optimal
14
11. Travelling Salesperson Problem (TSP)
Persoalan: Diberikan n buah kota serta diketahui jarak antara setiap
kota satu sama lain. Temukan perjalanan (tour) dengan jarak terpendek
yang dilakukan oleh seorang pedagang sehingga ia melalui setiap kota
tepat hanya sekali dan kembali lagi ke kota asal keberangkatan.
Persoalan TSP Solusi TSP (lintasan yang dicetak tebal)

• Misalkan graf berbobot memiliki n buah simpul, v1, v2, …, vn.
• Misalkan tur dimulai dari simpul v1, mengunjungi simpul-simpul lainnya

tepat sekali dan kembali lagi ke v1.
• Dari simpul v1, tur akan memilih n – 1 simpul-simpul lainnya yang

dikunjungi.
• Dengan algoritma greedy, pada setiap langkah kita memilih simpul

berikutnya yang akan dikunjungi.
• Strategi greedy: pada setiap langkah i, pilih sisi dari vi ke vj yang memiliki
bobot terkecil
Contoh 17: Diberikan sebuah graf berbobot dengan lima simpul sebagai berikut
A
12 10
15 9
E 11 B
10
13
12 11
D 11 C Tentukan tur terpendek dari simpul A!
Dengan algoritma greedy: Bobot (jarak) = 58
Solusi optimal adalah: Bobot (jarak) = 56
Kesimpulan: Algoritma greedy tidak memberikan solusi optimal untuk persoalan TSP
Aplikasi Algoritma Greedy pada
Permainan Othello (Riversi)
18
Othello
• Othello atau Riversi adalah permainan yang
menggunakan papan (board game) dan
sejumlah koin yang berwarna gelap (misalnya
hitam) dan terang (misalnya putih).
• Ukuran papan biasanya 8 x 8 kotak (grid) dan

jumlah koin gelap dan koin terang masing-
masing sebanyak 64 buah. Sisi setiap koin
memiliki warna yang berbeda (sisi pertama
gelap dan sisi kedua terang).
• Pada permainan ini kita asumsikan warna

hitam dan putih. Jumlah pemain 2 orang.
19
• Dalam permainan ini setiap pemain berusaha mengganti warna koin lawan dengan
warna koin miliknya (misalnya dengan membalikkan koin lawan) dengan cara
“menjepit” atau memblok koin lawan secara vertikal, horizontal, atau diagonal.
• Barisan koin lawan yang terletak dalam satu garis lurus yang diapit oleh sepasang koin
pemain yang current diubah (reverse) warnanya menjadi warna pemain current.
20
• Setiap pemain bergantian meletakkan koinnya. Jika seorang pemain tidak
dapat meletakan koin karena tidak ada posisi yang dibolehkan,
permainan kembali ke pemain lainnya.
• Jika kedua pemain tidak bisa lagi meletakkan koin, maka permainan
berakhir. Hal ini terjadi jika seluruh kotak telah terisi, atau ketika seorang
pemain tidak memiliki koin lagi, atau ketika kedua pemain tidak dapat
melakukan penempatan koin lagi.
• Pemenangnya adalah pemain yang memiliki koin paling banyak di atas

papan.
21
• Algoritma Greedy dapat diaplikasikan untuk memenangkan
permainan.
• Algoritma greedy berisi sejumlah langkah untuk melakukan

penempatan koin yang menghasilkan jumlah koin maksimal pada
akhir permainan.
• Algoritma Greedy dipakai oleh komputer pada tipe permainan

komputer vs manusia.
22
Dua strategi greedy heuristik:
1. Greedy by jumlah koin
Pada setiap langkah, koin pemain menuju koordinat yang menghasilkan
sebanyak mungkin koin lawan. Strategi ini berusaha memaksimalkan jumlah
koin pada akhir permainan dengan menghasilkan sebanyak-banyaknya koin
lawan pada setiap langkah.
2. Greedy by jarak ke tepi

Pada setiap langkah, koin pemain menuju ke koordinat yang semakin dekat
dengan tepi arena permainan. Strategi ini berusaha memaksimumkan jumlah
koin pada akhir permainan dengan menguasai daerah tepi yang sulit untuk
dilangkahi koin lawan. Bahkan untuk pojok area yang sulit dilangkahi lawan.
23
Greedy by Jumlah Koin
1. Himpunan kandidat
Langkah-langkah yang menghasilkan jumlah koin yang diapit.
2. Himpunan solusi
Langkah-langkah dari Himpunan kandidat yang memiliki jumlah
koin diapit paling besar.
3. Fungsi seleksi
Pilih langkah yang memiliki jumlah koin diapit paling besar
4. Fungsi kelayakan
Semua langkah adalah layak
5. Fungsi obyektif
Maksimumkan jumlah koin lawan
24
25
Sumber: Roger Crawfis, CSE 680 Introduction
to AlgorithmsGreedy Algorithms
Soal-soal Latihan
1. Connecting wires
• There are n white dots and n black dots, equally spaced, in a line
• You want to connect each white dot with some one black dot, with a minimum
total length of “wire”
• Example:
• Total wire length above is 1 + 1 + 1 + 5 = 8

• Do you see a greedy algorithm for doing this?
• Does the algorithm guarantee an optimal solution?
• Can you prove it?
• Can you find a counterexample?
26
Sumber: Roger Crawfis, CSE 680 Introduction
to Algorithms: Greedy Algorithms
2. Collecting coins
• A checkerboard has a certain number of coins on it
• A robot starts in the upper-left corner, and walks to the bottom left-hand
corner
• The robot can only move in two directions: right and down
• The robot collects coins as it goes
• You want to collect all the coins using the minimum number of robots
• Example:
• Do you see a greedy algorithm for doing this?

• Does the algorithm guarantee an optimal solution?
• Can you prove it?
• Can you find a counterexample?
3. Persoalan Penugasan (assignment problem)
Misalkan terdapat n orang dan n buah pekerjaan (job). Setiap orang akan di-
assign dengan sebuah pekerjaan. Penugasan orang ke-i dengan pekerjaan ke-
j membutuhkan biaya sebesar c(i, j). Bagaimana algoritma greedy untuk
melakukan penugasan sehingga total biaya penugasan adalah seminimal
mungkin? Buatlah dua algoritma, algoritma pertama meng-assign job
dengan orang, dan algoritma kedua meng-assign orang dengan job. Misalkan
instansiasi persoalan dinyatakan sebagai matriks C sebagai berikut:
 Job 1 Job 2 Job 3 Job 4
 9 2 7 8  Orang a

C= 6 4 3 7  Orang b
 
 5 8 1 4  Orang c
 7 6 9 4  Orang d
Tunjukkan dengan counterexample bahwa kedua algoritma tersebut tidak

menjamin menghasilkan solusi optimal.
4. Soal UTS 2020
5. Soal UTS 2020
6. Soal UTS 2018
7. Soal UTS 2011
Misalkan kita menempuh perjalanan sejauh 100 km, dimulai dari titik 0
dan berakhir pada kilometer 100. Di sepanjang jalan terdapat SPBU
pada jarak 10, 25, 30, 40, 50, 75, dan 80 km dari titik awal. Tangki
bensin pada awalnya hanya cukup untuk berjalan sejauh 30 km.
Bagaimana kita menempuh tempat pemberhentian agar kita berhenti
sesedikit mungkin?
• Bagaimana penyelesaian dengan algoritma greedy? Jelaskan!

TAMAT
Breadth/Depth First Search
(BFS/DFS) (Bagian 1)
Bahan Kuliah IF2211 Strategi Algoritmik
Oleh: Rinaldi Munir & Nur Ulfa Maulidevi

2021
1
Traversal Graf
• Algoritma traversal graf:
mengunjungi simpul dengan cara
yang sistematik
• Pencarian melebar (breadth first
search/BFS)
social graph
• Pencarian mendalam (depth first
http://www.oreilly.de/catalog/9780596518172/toc.html
search/DFS)
• Asumsi: graf terhubung
• Graf: representasi persoalan
➔ Traversal graf: pencarian solusi
Web page network
2
Algoritma Pencarian Solusi
• Tanpa informasi (uninformed/blind search)
• Tidak ada informasi tambahan
• Contoh: DFS, BFS, Depth Limited Search, Iterative Deepening Search, Uniform
Cost Search
• Dengan informasi (informed Search)

• Pencarian berbasis heuristik
• Mengetahui non-goal state “lebih menjanjikan” daripada yang lain
• Contoh: Best First Search, A*
3
Representasi Graf dalam Proses Pencarian
Dalam proses pencarian solusi, terdapat dua pendekatan:
1. Graf statis: graf yang sudah terbentuk sebelum proses pencarian

dilakukan
- graf direpresentasikan sebagai struktur data
2. Graf dinamis: graf yang terbentuk saat proses pencarian dilakukan

- graf tidak tersedia sebelum pencarian, graf dibangun selama pencarian solusi
4
Graf Statis
5
Pencarian Melebar (BFS)
• Traversal dimulai dari simpul v. 1
• Algoritma:
1. Kunjungi simpul v 2 3
2. Kunjungi semua simpul yang
bertetangga dengan simpul
v terlebih dahulu.
3. Kunjungi simpul yang belum 4 5 6 7
dikunjungi dan bertetangga
dengan simpul-simpul yang
tadi dikunjungi, demikian
seterusnya. 8
6
BFS: Struktur Data
1. Matriks ketetanggaan A = [aij] yang berukuran nxn,
aij= 1, jika simpul i dan simpul j bertetangga,
aij= 0, jika simpul i dan simpul j tidak bertetangga.
2. Antrian q untuk menyimpan simpul yang telah dikunjungi.
3. Tabel Boolean, diberi nama “dikunjungi”

dikunjungi : array[l..n] of boolean
dikunjungi[i] = true jika simpul i sudah dikunjungi
dikunjungi[i] = false jika simpul i belum dikunjungi
7
8
BFS: Ilustrasi
1 Iterasi V Q dikunjungi
1 2 3 4 5 6 7 8
Inisialisasi 1 {1} T F F F F F F F
2 3 Iterasi 1 1 {2,3} T T T F F F F F
Iterasi 2 2 {3,4,5} T T T T T F F F
Iterasi 3 3 {4,5,6,7} T T T T T T T F
Iterasi 4 4 {5,6,7,8} T T T T T T T T
4 5 6 7 Iterasi 5 5 {6,7,8} T T T T T T T T
Iterasi 6 6 {7,8} T T T T T T T T
Iterasi 7 7 {8} T T T T T T T T
Iterasi 8 8 {} T T T T T T T T
8
Urutan simpul2 yang dikunjungi: 1, 2, 3, 4, 5, 6, 7, 8

9
10
11
Pencarian Mendalam (DFS)
• Traversal dimulai dari simpul v. 1
• Algoritma:
1. Kunjungi simpul v 2 3
2. Kunjungi simpul w yang bertetangga dengan simpul v.

3. Ulangi DFS mulai dari simpul w.
4. Ketika mencapai simpul u sedemikian sehingga semua
simpul yang bertetangga dengannya telah dikunjungi, 4 5 6 7
pencarian dirunut-balik (backtrack) ke simpul terakhir
yang dikunjungi sebelumnya dan mempunyai simpul w
yang belum dikunjungi.
5. Pencarian berakhir bila tidak ada lagi simpul yang belum 8
dikunjungi yang dapat dicapai dari simpul yang telah
dikunjungi.
12
DFS
13
DFS: Ilustrasi 1
1 • DFS(1): v=1; dikunjungi[1]=true; DFS(2)
• DFS(2): v=2; dikunjungi[2]=true; DFS(4)
2 3 • DFS(8): v=8; dikunjungi[8]=true; DFS(5)
• DFS(5): v=5; dikunjungi[5]=true
4 5 6 7
8 Urutan simpul2 yang dikunjungi: 1, 2, 4, 8, 5, 6, 3, 7
14
DFS: Ilustrasi 2
1 • DFS(1): v=1; dikunjungi[1]=true; DFS(2)
2 3 • DFS(6): v=6; dikunjungi[6]=true; DFS(8)
• DFS(4): v=4; dikunjungi[4]=true;
DFS(8): DFS(5)
4 5 6 7 DFS(8): DFS(7)
8
Urutan simpul2 yang dikunjungi: 1, 2, 3, 6, 8, 4, 5, 7
15
16
17
18
Contoh (hal 113)
1 2
• Khusus untuk graf berarah,
beberapa simpul mungkin tidak
dapat dicapai dari simpul awal.
3 4 Coba dengan simpul yang belum
dikunjungi sebagai simpul awal.
6 (hal 113)
5 7
• DFS (1): 1-2-4-3-5-6-7
• BFS (1): 1-2-4-3-5-7-6
19
Contoh Lain
• Bagaimana penelusuran graf

dengan BFS?
• Bagaimana Penelusuran graf

dengan DFS
20
Penerapan BFS dan DFS: Citation Map
21
Citation Map:
22
Sumber: Teufel (1999), Argumentative Zoning
Penerapan BFS dan DFS: Web Spider
query
23
Penerapan BFS dan DFS: Web Spider
Arsitektur umum mesin pencari • Secara periodik, web
spider menjejalahi
internet untuk
mengunjungi halaman-
halaman web
http://www.ibm.com/developerworks/web/library/wa-lucene2/
24
Web Spider: Penjelajahan Web
• Halaman web dimodelkan sebagai
graf berarah
• Simpul menyatakan halaman web
(web page)
• Sisi menyatakan link ke halaman web
• Bagaimana teknik menjelajahi
web? Secara DFS atau BFS
• Dimulai dari web page awal, lalu
setiap link ditelusuri secara DFS
sampai setiap web page tidak
http://introcs.cs.princeton.edu/java/16pagerank/ mengandung link.
25
DFS dan BFS untuk penelusuran direktori (folder)
26
Pencarian dokumen di dalam direktori (folder) secara BFS
27
Pencarian dokumen di dalam direktori (folder) secara DFS
28
BERSAMBUNG
29
Breadth/Depth First Search
(BFS/DFS)
(Bagian 2)
Bahan Kuliah IF2211 Strategi Algoritmik
Oleh: Rinaldi Munir & Nur Ulfa Maulidevi

2021
1
Graf Dinamis
2
Pencarian Solusi dengan BFS/DFS
• Menyelesaikan persoalan dengan melakukan pencarian
• Pencarian solusi  pembentukan pohon dinamis
• Setiap simpul diperiksa apakah solusi (goal) telah dicapai atau tidak. Jika simpul merupakan
solusi , pencarian dapat selesai (satu solusi) atau dilanjutkan mencari solusi lain (semua
solusi).
• Representasi pohon dinamis:
• Pohon ruang status (state space tree)
• Simpul: problem state (layak membentuk solusi)
• Akar: initial state
• Daun: solution/goal state
• Cabang: operator/langkah dalam persoalan
• Ruang status (state space): himpunan semua simpul
• Ruang solusi: himpunan status solusi
• Solusi: path ke status solusi
3
Pohon Dinamis: Permutasi A,B,C
• Operator: add X
• Akar : status awal (status “kosong”)
• Simpul: problem state
• Status persoalan (problem state): simpul-
simpul di dalam pohon dinamis yang
memenuhi kendala (constraints).
• Daun: status solusi
• Status solusi (solution state): satu atau
lebih status yang menyatakan solusi
persoalan.
• Ruang solusi:
• Ruang solusi (solution space): himpunan
semua status solusi.
• Ruang status (state space): Seluruh
simpul di dalam pohon dinamis dan
Pohon ruang status pohonnya dinamakan juga pohon
ruang status (state space tree).
4
Pembangkitan Status
• Pembangkitan status baru dengan cara mengaplikasikan operator
(langkah legal) kepada status (simpul) pada suatu jalur
• Jalur dari simpul akar sampai ke simpul (daun) goal berisi

rangkaian operator yang mengarah pada solusi persoalan
5
BFS untuk Pembentukan Pohon Ruang Status
• Inisialisasi dengan status awal sebagai akar, lalu

tambahkan simpul anaknya, dst.
• Semua simpul pada level d dibangkitkan terlebih dahulu
sebelum simpul-simpul pada level d+1
6
BFS untuk Permutasi
Add(A) Add(B) Add(C)
Add(B) Add(C) Add(A) Add(C) Add(A) Add(B)
Add(C) Add(B) Add(C) Add(A) Add(B) Add(A)
7
DFS untuk Pembentukan Pohon Ruang Status
DFS:
BFS:
8
DFS Permutasi A,B,C
Add(A)
Add(B)
Add(C)
9
Evaluasi dari Teknik Pencarian
• Aspek untuk melihat seberapa ‘baik’ suatu teknik pencarian
• Completeness: apakah menjamin ditemukannya solusi jika memang ada
• Optimality: apakah teknik menjamin mendapatkan solusi yang optimal (e.g: lowest
path cost)?
• Time Complexity: waktu yang diperlukan untuk mencapai solusi
• Space Complexity: memory yang diperlukan ketika melakukan pencarian
• Kompleksitas waktu dan ruang diukur dengan menggunakan istilah berikut.

• b: (branching factor) maksimum pencabangan yang mungkin dari suatu simpul
• d: (depth) kedalaman dari solusi terbaik (cost terendah)
• m: maksimum kedalaman dari ruang status (bisa ∞)
10
Permainan 8-Puzzle
11
• State berdasarkan ubin kosong (blank)
• Operator: up, down, left, right
12
8-Puzzle: Pohon Ruang Status
13
BFS untuk 8-Puzzle
Catatan:
Urutan operator yang
digunakan harus konsisten.
14
Bagaimana property dari BFS?
• Completeness?
• Ya (selama nilai b terbatas )
• Optimality?
• Ya, jika langkah = biaya
• Kompleksitas waktu:
• 1+b+b2+b3+…+bd = O(bd)
• Kompleksitas ruang:
• O(bd)
• Kurang baik dalam kompleksitas ruang

15
DFS untuk 8-Puzzle
16
Bagaimana property dari DFS?
• Completeness?
• Ya (selama nilai b terbatas, dan ada penanganan ‘redundant paths’ dan ‘repeated
states’ )
• Optimality?
• Tidak
• O(bm)
• O(bm)
• Kurang baik dalam kompleksitas waktu, lebih baik dalam kompleksitas ruang
17
Aplikasi Backtracking di dalam DFS untuk Pencarian Solusi
• Karakteristik backtracking di dalam algoritma DFS berguna untuk memecahkan

persoalan pencarian solusi yang memiliki banyak alternatif pilihan selama pencarian.
• Solusi diperoleh dengan mengekspansi pencarian menuju goal dengan aturan

“depth-first”
• Anda tidak punya cukup informasi untuk mengetahui apa yang akan dipilih
• Tiap keputusan mengarah pada sekumpulan pilihan baru
• Beberapa sekuens pilihan (bisa lebih dari satu) mungkin merupakan solusi
persoalan
18
• Backtracking di dalam algoritma DFS adalah cara yang
metodologis mencoba beberapa sekuens keputusan,
• sampai Anda menemukan sekuens yang “bekerja”
19
Animasi Backtracking *)
dead end
?
dead end
dead end
?
start ? ? dead end
dead end
?
success!
20 *) Sumber: www.cis.upenn.edu/.../35-backtracking.ppt
• Backtracking di dalam algoritma DFS banyak diterapan untuk mencari
solusi persoalan games seperti:
• permainan tic-tac-toe,
• menemukan jalan keluar dalam sebuah labirin,
• Catur, crossword puzzle, sudoku, dan masalah-masalah pada bidang
kecerdasan buatan (artificial intelligence).
21
Crossword puzzle:
22
Tic-Tac-Toe
23
Sudoku
24
Catur
25
Maze Problem
Diberikan sebuah labirin (maze), temukan lintasan dari titik awal sampai
titik akhir
26
• Pada tiap perpotongan, anda harus memutuskan satu diantara
tiga pilihan:
• Maju terus
• Belok kiri
• Belok kanan
• Anda tidak punya cukup informasi untuk memilih pilihan yang

benar (yang mengarah ke titik akhir)
• Tiap pilihan mengarah ke sekumpulan pilihan lain
• Satu atau lebih sekuens pilihan mengarah ke solusi.
27
Penyelesaian Maze Problem dengan DFS:
• Bagi lintasan menjadi sederetan langkah.
• Sebuah langkah terdiri dari pergerakan satu unit sel pada arah
tertentu.
• Arah yang mungkin: lurus (straight), kiri (left), ke kanan (right).
28
Garis besar algoritma DFS:
while belum sampai pada tujuan do

if terdapat arah yang benar sedemikian sehingga kita belum pernah
berpindah ke sel pada arah tersebut
then
pindah satu langkah ke arah tersebut
else
backtrack langkah sampai terdapat arah seperti yang disebutkan
di atas
endif
endwhile
29
• Bagaimana mengetahui langkah yang mana yang perlu dijejaki
kembali?
• Ada dua solusi untuk masalah ini:

1. Simpan semua langkah yang pernah dilakukan, atau
2. gunakan rekursi (yang secara implisit menyimpan semua
langkah).
• Rekursi adalah solusi yang lebih mudah.
30
Depth-First-Search-Kickoff( Maze m )
Depth-First-Search( m.StartCell )
End procedure
Depth-First-Search( MazeCell c )
If c is the goal
Exit
Else
Mark c "Visit In Progress"
Foreach neighbor n of c
If n "Unvisited"
Depth-First-Search( n )
Mark c "Visited"
End procedure
{Source:
https://courses.cs.washington.edu/courses/cse326/03su/homework/hw3/dfs.html}
31
in out
Contoh runut-balik pada sebuah labirin. Runut-balik diperlihatkan dengan

garis putus-putus.
32
Contoh lainnya:
33
Jika kita menggambarkan
sekuens pilihan yang kita
lakukan, maka diagram
berbentuk seperti pohon.
Simpul daun merupakan:

1. Titik backtrack, atau
2. Simpul goal
Pada titik backtrack, simpul

tersebut menjadi mati (tidak
bisa diekspansi lagi)
Aturan pembentukan simpul: DFS

34
Block World Problem
(Soal UTS 2018)
• Terdapat beberapa buah balok berbentuk kubus yang ditempatkan di atas meja atau di
atas balok yang lain sehingga membentuk sebuah kofigurasi. Sebuah robot yang memiliki
lengan bercapit harus memindahkan balok-balok kubus tersebut sehingga membentuk
konfigurasi lain dengan jumlah perpindahan yang minimum. Persyaratannya adalah
hanya boleh memindahkan satu balok setiap kali ke atas balok lain atau ke atas meja.
Gambarkan pohon ruang status pencarian solusi secara BFS dan DFS untuk initial state
dan goal state di bawah ini. Setiap status digambarkan sebagai tumpukan balok kubus
setelah pemindahan satu balok. Beri nomor setiap status sesuai aturan BFS dan DFS.
Hitung berapa banyak status yang dibangkitkan sampai ditemukan goal state.
Initial state Goal state

35
Penyelesaian:
(a) BFS
Salah satu kemungkinan solusi:
36
Kemungkinan lain:
37
(b) DFS
38
Persoalan Missionaris dan Kanibal
• Terdapat 3 misionaris dan 3 kanibal yang harus menyebrang ke sisi
sungai menggunakan sebuah perahu. Perahu hanya boleh berisi
penumpang maksimal 2 orang. Jumlah kanibal tidak boleh lebih
banyak dari jumlah misionaris di salah satu sisi, jika tidak maka
misionaris akan dimakan oleh kanibal.
• Bagaimana menyeberangkan keenam orang tadi sehingga

semuanya selamat sampai di sisi sungai seberangnyya? Selesaikan
dengan BFS dan DFS
39
40
41
Sebagian pohon ruang status dengan BFS
42
Algoritma Pencarian Lainnya
• Depth-limited search
• Iterative deepening search
43
Depth-Limited Search
• BFS: dijamin menemukan path dgn langkah minimum tapi
membutuhkan ruang status yang besar
• DFS: efisien, tetapi tidak ada jaminan solusi dgn langkah minimum
• DFS dapat memilih langkah yang salah, sehingga path panjang bahkan
infinite. Pemilihan langkah sangat penting
• Salah satu solusi: DFS-limited search

• DFS dengan pembatasan kedalaman sampai l
• Simpul pada level l dianggap tidak memiliki successor
• Masalah: penentuan batas level ( shallowest goal)
44
DLS Algorithm
Function DLS (problem, limit)
→rec_DLS(make_node(init_state),problem,limit)
Function Rec_DLS (node,problem, limit)

if isGoal(node) then → solution(node)
else if depth(node)=limit then → cutoff
else
for each successor in Expand(node,problem) do
result rec_DLS(successor,problem,limit)
if result=cutoff then cutoff_occured true
else if result≠failure then → result
if cutoff_occured then → cutoff
else → failure
45
Bagaimana property dari DLS?
• Completeness?
• Tidak
• Optimality?
• Tidak
• O(bl)
• O(bl)
46
Iterative Deepening Search (IDS)
• IDS: melakukan serangkaian DFS, dengan peningkatan nilai kedalaman-cutoff,
sampai solusi ditemukan
• Asumsi: simpul sebagian besar ada di level bawah, sehingga tidak menjadi
persoalan ketika simpul pada level-level atas dibangkitkan berulang kali
Depth  0
Iterate
result DLS(problem,depth)
stop: result ≠ cutoff
depth depth+1
→ result
47
IDS dengan d=1
48
IDS dengan d=2
49
IDS dengan d=3
50
IDS (animasi)
51
Bagaimana property dari IDS?
• Completeness?
• Ya, jika b terbatas
• Optimality?
• Ya, jika langkah = biaya
• O(bd)
• O(bd)
52
Route/Path Planning
Materi Kuliah IF2211 – Strategi Algoritma
Teknik Informatika - ITB
53
Referensi
• Materi kuliah IF3170 Inteligensi Buatan Teknik Informatika ITB, Course
Website:
http://kuliah.itb.ac.id → STEI → Teknik Informatika → IF3170
• Stuart J Russell & Peter Norvig, Artificial Intelligence: A Modern

Approach, 3rd Edition, Prentice-Hall International, Inc, 2010,
Textbook
Site: http://aima.cs.berkeley.edu/ (2nd edition)
• Free online course materials | MIT OpenCourseWare Website:

Site: http://ocw.mit.edu/courses/electrical-engineering-and-
computer-science/
54
Route
Planning
55
Source: Russell’s book
Search O
71 151 F
S 99
Z
75 211
A 140 80
R B
97 P
120
118 101
D
75
T M 146 138
111 L 70
C
S: set of cities
i.s: A (Arad)
g.s: B (Bucharest)
Goal test: s = B ?
Path cost: time ~ distance
56
Breadth-First Search (BFS)
Treat agenda as a queue (FIFO)
O
Z
71 151 S F
99
75 211
A 80
140
R B
97 P
120 101
118 Simpul-E Simpul Hidup
D
75 138
M 146 A ZA,SA,TA
T 111 L 70 ZA SA,TA,OAZ
C SA TA,OAZ,OAS,FAS,RAS
TA OAZ,OAS,FAS,RAS,LAT
Path: A→ S → F → B, OAZ OAS,FAS,RAS,LAT
Path-cost = 450 OAS FAS,RAS,LAT
FAS RAS,LAT,BASF
RAS LAT,BASF,DASR,CASR,PASR
LAT BASF,DASR,CASR,PASR,MATL
BASF Solusi ketemu 57
Depth-First Search (DFS)
Treat agenda as a stack (LIFO)
O
Z
71 151 S F
99
75 211
A 80
140
R B
97 P
120
118 101
D
75
M 146 138
T 111 L 70
Simpul-E Simpul Hidup
C
A ZA,SA,TA
Path: A→ Z → O → S → F → B ZA OAZ, SA,TA
Path-cost = 607 OAZ SAZO,SA,TA

SAZO FAZOS, RAZOS,SA,TA
FAZOS BAZOSF, RAZOS,SA,TA
BAZOSF Solusi ketemu
58
IDS
Z
71 O 151 S F
99
75 211
A 80
140
R B
97 P
120
118 101
D
75
M 146 138
T 111 L 70
Depth=0: A: cutoff C
Depth=1: A → ZA,SA,TA → ZA: cutoff, SA: cutoff, TA: cutoff
Depth=2: A → ZA,SA,TA → OAZ, SA,TA → OAZ : cutoff → FAS, RAS,TA → FAS : cutoff
→ RAS : cutoff → LAT → LAT : cutoff
Depth=3: A → ZA,SA,TA → OAZ, SA,TA → SAZO,SA,TA → SAZO: cutoff → FAS, RAS,TA
→ BASF, RAS,TA → BASF
Stop: B=goal, path: A→ S → F → B, path-cost = 450
59
Contoh path finding lainnya:
Sumber:https: //medium.com/omarelgabrys-blog/path-finding-algorithms-f65a8902eb40
60
BFS:
61
DFS:
62
SELAMAT BELAJAR
63
Algoritma Branch & Bound
(Bagian 1)
Oleh: Rinaldi Munir, Nur Ulfa Maulidevi, Masayu Leylia Khodra

2021
1
Overview
• Pembentukan pohon ruang status (state space tree) dinamis untuk
mencari solusi persoalan
• BFS
• DFS
• DLS
• IDS
• Backtracking
2
Overview
• BFS: solusi dengan minimum step, exponential space
• DFS: lebih efisien (1 solusi) , lintasannya dapat terlalu panjang (pohon
ruang status tidak berhingga kedalamannya)
• DLS: variasi DFS, solusi bisa tidak ketemu (depth-limited)
• IDS: sekuens DLS (depth ++)
• Backtracking: basis DFS, expand simpul jika arahnya benar, fungsi
pembatas
3
Algoritma Branch & Bound (B&B)
• Digunakan untuk persoalan optimisasi → meminimalkan atau
memaksimalkan suatu fungsi objektif, yang tidak melanggar batasan
(constraints) persoalan
• B&B = BFS + least cost search
• BFS murni: Simpul berikutnya yang akan diekspansi berdasarkan urutan
pembangkitannya (FIFO)
• B&B:
• Setiap simpul diberi sebuah nilai cost:
ĉ(i) = nilai taksiran lintasan termurah ke simpul status tujuan yang melalui
simpul status i.
• Simpul berikutnya yang akan di-expand tidak lagi berdasarkan urutan
pembangkitannya, tetapi simpul yang memiliki cost yang paling kecil (least
cost search) – pada kasus minimasi.
4
B&B vs Backtracking
• Persamaan:
• Pencarian solusi dengan pembentukan pohon ruang status
• ‘Membunuh’ simpul yang tidak ‘mengarah’ ke solusi
• Perbedaan:
• ‘nature’ persoalan yang bisa diselesaikan:
• Backtracking: Tak ada batasan (optimisasi/non-optimasi), umumnya untuk
persoalan non-optimisasi
• B&B:
• Persoalan optimisasi
• Untuk setiap simpul pada pohon ruang-status, diperlukan suatu cara
penentuan batas (bound) nilai terbaik fungsi objektif pada setiap solusi yang
mungkin, dengan menambahkan komponen pada solusi sementara yang
direpresentasikan oleh simpul
• Nilai dari solusi terbaik sejauh ini
• Pembangkitan simpul: …
5
B&B vs Backtracking (2)
• Perbedaan:
• Pembangkitan simpul:
• Backtracking: umumnya DFS
• B&B : beberapa ‘aturan’ tertentu → paling umum ‘best-first rule’
6
“Fungsi Pembatas”
• Algoritma B&B juga menerapkan “pemangkasan” pada jalur yang
dianggap tidak lagi mengarah pada solusi.
• Kriteria pemangkasan secara umum:

• Nilai simpul tidak lebih baik dari nilai terbaik sejauh ini (the best solution so far)
• Simpul tidak merepresentasikan solusi yang ‘feasible’ karena ada batasan yang
dilanggar
• Solusi pada simpul tersebut hanya terdiri atas satu titik → tidak ada pilihan
lain; bandingkan nilai fungsi obyektif dengan solusi terbaik saat ini, yang
terbaik yang diambil
7
Persoalan N-Ratu (The N-Queens Problem)
• Tinjau kembali persoalan N-Ratu
• Diberikan sebuah papan permainan

yang berukuran N  N dan N buah
ratu. Bagaimanakah menempatkan
N buah ratu (Q) itu pada petak-
petak papan permainan sedemikian
sehingga tidak ada dua ratu atau
lebih yang terletak pada satu baris
yang sama, atau pada satu kolom
yang sama, atau pada satu diagonal
yang sama.
8
Pohon ruang status persoalan 4-Ratu: Algoritma Backtracking
1
x1=1 x1=2
2 18
x2=2 x2=4 x2=1 x2=4

x2=3
x2=3
3 8 13 19 24 29
B B B
x3=2 x3=3
x3=2 x3=4 x3=1
9 11 14 16 30
B B B
x4=3 x4=3
15 31
9
B
Solusi 4-Ratu dengan BFS-dengan Pembatasan
(FIFO-Branch and Bound)
Solusi pertama: X=(2,4,1,3)
10
Strategi Pencarian Solusi 4-Ratu menggunakan
Algoritma Branch and Bound
• Simpul hidup yang menjadi simpul-E(xpand) ialah simpul yang
mempunyai nilai cost terkecil (least cost search)→ salah satu jenis
aturan
• Untuk setiap simpul X, nilai cost ini dapat berupa:

1. jumlah simpul dalam upapohon X yang perlu dibangkitkan sebelum simpul
solusi ditemukan
2. panjang lintasan dari simpul X ke simpul solusi terdekat (dalam upapohon X
ybs) → misal ini yang dipilih untuk persoalan 4-ratu
11
Solusi 4-Ratu dengan Algoritma Branch and Bound
• Asumsi: letak simpul solusi diketahui

(panjang lintasan solusi = 4)
• Cost simpul X: panjang lintasan dari
simpul X ke simpul solusi terdekat
(subpohon X).
• Cost =  jika tidak ada simpul solusi di
subpohon tersebut. 12
Pembentukan Pohon Ruang Status
4-Ratu dengan Algoritma Branch & Bound
Simpul-Expand Simpul Hidup

1 3,4,2,5
3 11,4,2,5,9,10
11 22,4,2,5,9,10,23 Priority
queue
22 30,4,2,5,9,10,23
30 Solusi ketemu
13
Cost dari Simpul Hidup
• Pada umumnya, untuk kebanyakan persoalan, letak simpul solusi tidak diketahui.
• Persoalan N-Ratu: persoalan yg ideal (letak simpul solusi diketahui)
• Letak simpul solusi diketahui?

• knapsack problem,
• graph colouring,
• permainan 8-puzzle,
• TSP
• Oleh karena itu, nilai cost simpul i merupakan estimasi ongkos termurah
lintasan dari simpul i ke simpul solusi (yang tidak diketahui letaknya),
dilambangkan dengan ĉ(i). Nilai ĉ(i) dihitung secara heuristik.
• Dengan kata lain, ĉ(i) menyatakan batas bawah (lower bound) dari ongkos
pencarian solusi dari status i.
14
Algoritma Global Branch & Bound
1. Masukkan simpul akar ke dalam antrian Q. Jika simpul akar adalah
simpul solusi (goal node), maka solusi telah ditemukan. Stop.
2. Jika Q kosong, tidak ada solusi. Stop.
3. Jika Q tidak kosong, pilih dari antrian Q simpul i yang mempunyai nilai
‘cost’ ĉ(i) paling kecil. Jika terdapat beberapa simpul i yang
memenuhi, pilih satu secara sembarang.
4. Jika simpul i adalah simpul solusi, berarti solusi sudah ditemukan, stop.
Jika simpul i bukan simpul solusi, maka bangkitkan semua anak-
anaknya. Jika i tidak mempunyai anak, kembali ke langkah 2.
5. Untuk setiap anak j dari simpul i, hitung ĉ(j), dan masukkan semua
anak-anak tersebut ke dalam Q.
6. Kembali ke langkah 2.
15
Permainan 15-Puzzle

• Aksi: up, down, left, right
16
Reachable Goal?
• Terdapat 16!  20,9 x 1012 susunan ubin yang berbeda, dan hanya
setengah yang dapat dicapai dari state awal sembarang.
• Teorema : Status tujuan hanya dapat dicapai dari status awal jika
bernilai genap.
• X=1 jika sel kosong pada posisi awal ada pada sel yg diarsir
State awal State akhir

http://www.cs.umsl.edu/~sanjiv/classes/cs5130/lectures/bb.pdf
17
Reachable Goal : KURANG(i)
i Kurang (i)
1 0 • KURANG(i) = banyaknya ubin bernomor j
2 0 sedemikian sehingga j < i dan POSISI(j) > POSISI(i).
3 1
POSISI(i) = posisi ubin bernomor i pada susunan
4 1
5 0
yang diperiksa.
6 0 • KURANG (4) = 1 : terdapat 1 ubin (2)
7 1
8 0 • Kesimpulan: status tujuan tidak dapat dicapai.
9 0
10 0
11 3
16
12
13
6
0
 Kurang (i) + X = 37 + 0 = 37
i =1
14 4
15 11
16 10
18
Reachable Goal ?
i Kurang (i)
1 0
2 0
? 3 0
4 0
5 0
6 0
7 0
8 1
16
 Kurang (i) + X = 15 + 1 = 16
9 1
10 1
i =1
11 0
12 0
13 1
14 1
15 1
16 9
19
Sebagian pohon ruang status untuk 15-Puzzle secara BFS
1
1 2 3 4
5 6 8
9 10 7 11
13 14 15 12
up
left
right down
2 3 4 5
1 2 4 1 2 3 4 1 2 3 4 1 2 3 4
5 6 3 8 5 6 8 5 6 7 8 5 6 8
9 10 7 11 9 10 7 11 9 10 11 9 10 7 11
13 14 15 12 13 14 15 12 13 14 15 12 13 14 15 12
right left up down right down left up left

down
6 7 8 9 10 11 12 13 14 15
1 2 4 1 2 4 1 2 3 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 3 4 1 2 3 4 1 2 3 4
5 6 3 8 5 6 3 8 5 6 8 4 5 6 8 11 5 6 7 8 5 6 7 8 5 6 7 8 5 7 6 8 5 10 6 8 5 6 8
9 10 7 11 9 10 7 11 9 10 7 11 9 10 7 9 10 11 9 10 15 11 9 10 11 9 10 7 11 9 7 11 9 10 7 11
13 14 15 12 13 14 15 12 13 14 15 12 13 14 15 12 13 14 15 12 13 14 12 13 14 15 12 13 14 15 12 13 14 15 12 13 14 15 12
up down
down left
16 19 down left 22 23
down left
1 2 4 8 1 2 3 1 2 3 4 1 2 3 4
5 6 3 5 6 8 4 5 6 7 5 6 7 8
9 10 7 11 9 10 7 11 9 10 11 8 9 10 11 12
13 14 15 12 13 14 15 12 13 14 15 12 13 14 15
17 18 20 21
1 6 2 4 1 2 4 1 2 3 4 1 2 3 4
5 3 8 5 6 3 8 5 6 8 11 5 6 8 11
9 10 7 11 9 10 7 11 9 10 7 12 9 10 7
13 14 15 12 13 14 15 13 14 15 13 14 15 12
20
Pohon Ruang Status untuk DFS
http://chern.ie.nthu.edu.tw/alg2003/alg-2009-chap-7.pdf
21
Cost dari Simpul Hidup (2)
• Pada umumnya, untuk kebanyakan persoalan, letak simpul solusi (tujuan)
tidak diketahui.
root
• Cost setiap simpul umumnya berupa taksiran.
መ
𝑓(i)
i
𝑔(i)
ො
i
goal node
• Cost simpul P pada 15-puzzle: 𝑐Ƹ 𝑃 = 𝑓 𝑃 + 𝑔(𝑃)
ො
22
Cost dari Simpul Hidup 15-Puzzle
Target
C(2)=f(2)+g(2) C(3)=f(3)+g(3) C(4)=f(4)+g(4) C(5)=f(5)+g(5)

C(2)=1+4=5 C(3)=1+4=5 C(4)=1+2=3 C(5)=1+4=5
23
15-Puzzle dengan Algoritma Branch & Bound

1 4,2,3,5
4 10,2,3,5,11,12
10 23,2,3,5,11,12,22
23 Solusi ketemu 24
BERSAMBUNG
25
(Bagian 2)

2021
IF2211 B&B/NUM-MLK-RN 1
Travelling Salesperson Problem (TSP)
Persoalan: Diberikan n buah kota (vertex)

serta diketahui jarak (bobot) antara setiap
kota satu sama lain. Temukan perjalanan
(tour) dengan jarak terpendek yang
dilakukan oleh seorang pedagang sehingga
ia melalui setiap kota tepat hanya sekali dan
kembali lagi ke kota asal keberangkatan.
Terdapat (n – 1)! tur di dalam graf lengkap dengan n simpul
Pohon Ruang Status TSP n = 4 Simpul
12
1 2
4 3
Simpul awal perjalanan = 1
Solusi: 1-3-2-4-1 atau 1-4-2-3-1

Bobot = 5+8+9+10 =32
Penyelesaian TSP dengan B & B
Contoh lain TSP 5 simpul (matriks bobot/cost matrix):
Brute Force:
- 4!=24 sirkuit hamilton
- Solusi: 1-4-2-5-3-1
- Bobot: 10+6+2+7+3=28
Greedy:
- Solusi: 1-4-5-2-3-1 B&B-TSP dgn B&B
- Bobot: 10+3+4+16+3=36 x0 = x5=1
Cost dari Simpul Hidup TSP
• Cost untuk setiap simpul di dalam pohon ruang status menyatakan nilai
batas bawah (lower bound) ongkos mencapai simpul solusi dari simpul
tersebut. .
• Cost setiap simpul dapat dihitung secara heuristik berdasarkan salah satu
dari dua cara:
1. Matriks ongkos-tereduksi (reduced cost matrix) dari graf
2. Bobot minimum tur lengkap
• Masing-masing cara akan dijelaskan satu per satu penggunaannya pada

slide berikut.
1. Cost berdasarkan Reduced Cost Matrix
• Ongkos atau nilai batas untuk setiap simpul dihitung dengan menggunakan
matriks ongkos-tereduksi (reduced cost matrix) dari graf G.
• Sebuah matriks dikatakan tereduksi jika setiap kolom dan setiap barisnya
mengandung paling sedikit satu buah nol dan semua elemen lainnya non-negatif.
Contoh: M’
M
12 20 30 10 11 1 10 17 0 1
15 8 16 4 2 12 6 11 2 0
Reduksi baris
3 5 11 2 4 dan kolom
0 3 6 0 2
19 6 18 9 3 15 3 12 6 0
16 4 7 16 8 11 0 0 12 4
6
• Tinjau sebuah TSP dengan n = 5, graf dinyatakan dalam matriks ketetanggaan:
1
  20 30 10 11 11/16 20/15
15  16 4 2  30/3
  5
2/4 2
3 5  2 4 10/19 4/6
 
 19 6 18  3  3/16 4/7 16/5
16 4 7 16  
4 2/18
3
• Karena perjalanan pedagang di dalam graf melalui sisi (i, j), dengan i = 1, 2, …, 5
dan j = 1, 2, …, 5, maka mengurangkan setiap elemen pada suatu baris atau pada
suatu kolom dengan konstanta t akan mengurangi panjang (bobot) setiap
perjalanan sebesar t.
• Jika t dipilih dari elemen minimum pada baris i (kolom j), maka mengurangkan
seluruh elemen pada baris i (kolom j) dengan t akan menghasilkan sebuah nol
pada baris i (kolom j) tersebut. Dengan mengulangi proses ini berulangkali akan
menghasilkan matriks bobot tereduksi.
Reduced Cost Matrix (2)
8
• Jumlah total elemen pengurang dari semua baris dan kolom menjadi batas bawah
(lower bound) dari tur dengan total bobot minimum. Nilai ini digunakan sebagai
nilai untuk simpul akar pada pohon ruang status.
• Total jumlah semua pengurang = (10 + 2 + 2 + 3 + 4) + (1 + 3) = 25. Nilai 25 ini

adalah nilai batas untuk simpul akar,
cˆ( root ) = 25
Pohon ruang status saat ini:

1
25
R
B&B-TSP dgn Reduced Cost Matrix i
S
• Misalkan:
• Tur (perjalanan) dimulai dari simpul 1 j
• A: matriks tereduksi untuk simpul R.
• S: anak dari simpul R sehingga sisi (R, S) pada pohon ruang status berkoresponden
dengan sisi (i, j) pada perjalanan.
• Jika S bukan simpul daun, maka matriks bobot tereduksi untuk simpul S
dapat dihitung sebagai berikut:
(a) ubah semua nilai pada baris i dan kolom j menjadi . Ini untuk mencegah agar
tidak ada lintasan yang keluar dari simpul i atau masuk pada simpul j;
(b) ubah A(j, 1) menjadi . Ini untuk mencegah penggunaan sisi (j, 1);
(c) reduksi kembali semua baris dan kolom pada matriks A kecuali untuk elemen .
• Jika r adalah total semua pengurang, maka nilai batas untuk simpul S
adalah:
Hasil reduksi ini menghasilkan matriks B.
10
• Secara umum, persamaan fungsi pembatas (bounding function) adalah:
cˆ( S ) = cˆ( R ) + A(i, j ) + r
• Bangkitkan semua anak dari simpul 1:
1
25
x1 = 2 x1= 5
x1 = 3 x1 = 4
2 3 4 5
ĉ(2) =? ĉ(3) =? ĉ(4) =? ĉ(5) =?
• Akan dihitung cost atau bound untuk simpul 2, 3, 4, dan 5
B&B-TSP dgn Reduced Cost Matrix (2)
1. Simpul 2; Lintasan di dalam graf: 1, 2
(a) ubah semua nilai pada baris 1 dan kolom 2 menjadi .
(b) ubah A(2, 1) menjadi . Ini untuk mencegah penggunaan sisi (2, 1)
(c) reduksi kembali semua baris dan kolom pada matriks A kecuali untuk
elemen .
A Kolom2
Baris 1
(a), (b) (c): sudah berbentuk

matriks tereduksi, r = 0
cˆ(2) = cˆ(1) + A(1,2) + r = 25 + 10 + 0 = 35
13
A Kolom 3
Baris 1            
12   2 0  1   2 0
   
  3  0 2  C1 − 11 0 3  0 2 = B
   
 15 3   0  4 3   0
 
11 0  12   0 0  12 
cˆ(3) = cˆ(1) + A(1,3) + r = 25 + 17 + 11 = 53

A Kolom 3
Baris 1            
12  11  0  12  11  0 
   
 0 3   2  0 3   2 = B
   
 3 12  0   3 12  0 
 
11 0 0    11 0 0   
cˆ(4) = cˆ(1) + A(1,4) + r = 25 + 0 + 0 = 25

14
A Kolom 3
Baris 1          
12  11 2   10  9 0 
 R −2  
 0 3  0  2 0 3  0  =B
  R4 − 3  
 15 3 12    12 0 9  
  0 0 12     0 0 12 
cˆ(5) = cˆ(1) + A(1,5) + r = 25 + 1 + 5 = 31
Pohon ruang status yang terbentuk sampai saat ini adalah:
Simpul yang memiliki cost terkecil adalah simpul 4, maka simpul 4 menjadi simpul-E 15
• Simpul-simpul berikutnya yang dibangkitkan adalah simpul 6, 7, dan 8:
ĉ(6) =? ĉ(7) =? ĉ(8) =?
• Akan dihitung nilai cost untuk simpul 6, 7, dan 8
5. Simpul 6; Lintasan di dalam graf: 1, 4, 2
Kolom 2
B
        
    
 
12  11  0     11  0 
   11  0   
 
 0 3   2 0    2 0    2 = C
     
  3 12  0  Baris 4 
         
11 0 0    11  0    11  0   
cˆ(6) = cˆ(4) + B(4,2) + r = 25 + 3 + 0 = 28

B Kolom 3
                       
12  11  0  12    0  12    0  1    0
       
 0 3   2   3   2  R3 − 2   1   0  C1 − 11  1   0  = C
       
  3 12  0                    
Baris 4  
11 0 0    11 0    11 0      0 0   
𝑐(7)
Ƹ = 𝑐(4)
Ƹ + 𝐵(4,3) + 𝑟 = 25 + 12 + 13 = 508
17
B
     
12  11  0 
 
 0 3   2  
 
  3 12  0  Baris 4
11 0 0   
cˆ(8) = cˆ(4) + B(4,5) + r = 25 + 0 + 11 = 36
• Pohon ruang status yang terbentuk hingga saat ini:
1
25
x1=2 x1=5
x1=3 x1=4
2 3 4 5
25
35 53 31
x2=2 x2=5
x2=3
6 7 8
28 50
50 36
• Simpul hidup saat ini adalah 2, 3, 5, 6, 7, dan 8. Simpul hidup yang memiliki nilai
cost terkecil adalah simpul 6.
• Simpul 6 menjadi simpul-E dan akan diekspansi sebagai berikut di bawah ini.
   
B&B-TSP dgn Reduced Cost Matrix 

C = 0
 11  0 
   2

 
    
1
11  0   
8. Simpul 9; Lintasan: 1, 4, 2, 3 25
x1=2 x1=5
x1=3 x1=4
    
    
  R3 − 2 2 3 4 5
    2 =D 25
  R5 − 11 35 53 31
    
x2=2 x2=5
11      x2=3
6 7 8
28
50
50 36
9. Simpul 10; Lintasan: 1, 4, 2, 5 x3=3 x3=5
9 10
52 28
=D
Simpul-simpul hidup: 2, 3, 5, 7, 8, 9, 10
𝑐Ƹ 10 = 𝑐Ƹ 6 + 𝐶 2,5 + 𝑟 = 28 + 0 + 0 = 28 Simpul dengan cost terkecil: simpul 10
Simpul 10 menjadi simpul-E 20
10. Simpul 11; Lintasan: 1, 4, 2, 5, 3 1
25
x1=2 x1=5
x1=3 x1=4
2 3 4 5
25
35 53 31
x2=2 x2=5
x2=3
21
6 7 8
cˆ(11) = cˆ(10) + D(5,3) + r = 28 + 0 + 0 = 28
28
50
50 36
x3=3 x3=5
• Karena simpul 11 adalah simpul solusi, maka solusi 9 10
pertama ditemukan, yaitu 1, 4, 2, 5, 3, 1 dengan 52

28
panjang 28. x4=3
• Solusi ini merupakan solusi terbaik sampai sejauh ini 11
(the best solution so far). 28

IF2211 B&B/NUM-MLK-RN
B&B-TSP dgn Reduced Cost Matrix
1 4,5,2,3
4 6,5,2,8,7,3
6 10,5,2,8,7,9,3
10 11,5,2,8,7,9,3
11 daun
Semua simpul hidup yang nilainya lebih besar dari 28

dibunuh (B) karena tidak mungkin lagi menghasilkan
perjalanan dengan bobot < 28.
Karena tidak ada lagi simpul hidup di dalam pohon ruang

status, maka X = (1, 4, 2, 5, 3, 1) menjadi solusi persoalan
TSP di atas dengan bobot 28.
Latihan
• (TSP) Diberikan sebuah graf lengkap dengan 4
simpul yang dinyatakan dengan matriks berbobot  2 7 8 
sebagai berikut: 6  3 7
C= 
5 8  4
• Simpul diberi nomor 1, 2, 3, dan 4. Jika tur dimulai
 
dari simpul 3 , tentukan tur TSP dengan bobot
 7 6 9 
minimum (dari 3 kembali ke 3 melalui simpul yang
lain tepat sekali). Selesaikan persoalan ini dengan
algoritma branch and bound. Bound atau cost
dihitung dengan matriks ongkos tereduksi
(reduced cost matices). Tuliskan jawaban anda
dengan menggambarkan pohon ruang status
beserta nilai bound untuk setiap simpul, solusi
dalam bentuk vektor X dan total bobot.
Penyelesaian:
Pohon ruang status yang terbentuk:
BERSAMBUNG
(Bagian 3)

2021
1
2. Cost Berdasarkan Bobot Tur Lengkap
• Pada pembahasan algoritma B&B, cost setiap simpul i, yaitu ĉ(i), dihitung sebagai
መ = ongkos dari simpul akar ke simpul i, dan 𝑔ො 𝑖 = ongkos
penjumlahan dari: 𝑓(𝑖)
dari simpul i ke simpul tujuan (goal) , atau 𝑐Ƹ 𝑖 = 𝑓መ 𝑖 + 𝑔(𝑖)
ො
• Pada persoalan TSP dengan cost dihitung berdasarkan matriks ongkos tereduksi,
jika S adalah anak dari simpul R, maka
cˆ( S ) = cˆ( R ) + A(i, j ) + r
መ
𝑓(𝑅) = 𝑐Ƹ 𝑅 = cost dari orangtua simpul S
𝑔(𝑅)
ො = A(i, j) + r
• Terdapat pendekatan heuristik lain dalam menghitung nilai cost untuk setiap
simpul berdasarkan bobot tur lengkap.
Bobot Tur Lengkap (tur dimulai dari a)
12
Tour lengkap:
a,c,d,b,a
Solusi: (a,i2,i3,i4,a)
B&B-TSP dengan Bobot Tur Lengkap
Hasil pengamatan:
Cost Simpul Akar
12
a b c d
Contoh untuk menghitung cost simpul 2:
Untuk i2=b, sisi (a, b) wajib diambil.
12 a b c d
32
a b c d
Simpul hidup berikutnya yang akan diekspansi: simpul 3 atau 4

34.5
a b c d
32 32 a b c d
32
Contoh menghitung cost simpul 5:

Untuk i3=b, sisi (a, c) dan sisi (c, b) wajib diambil.
12

Sisi (a, c), (c, b), dan (b, d) wajib diambil.
12
a b c d
Cost  1/2 [(10 + 5) + (8 + 9) + (10 + 9) + (5 + 8) = 32
12
a b c d
a b c d
BERSAMBUNG
(Bagian 4)
Oleh: Rinaldi Munir

2021
1
Assignment Problem
• Misalkan terdapat n orang dan n buah pekerjaan (job). Setiap orang akan di-assign
dengan sebuah job. Ongkos (cost) untuk meng-assign setiap orang dengan sebuah
job dinyatakan dengan sebuah matriks.
• Bagaimana meng-assign job dengan orang sehingga total ongkos assignment
seminimal mungkin?
• Contoh: n = 4
8
Penyelesaian:
• Cost (lower bound) setiap simpul hidup di dalam pohon ruang status dapat dihitung
dengan berbagai cara, misalnya menggunakan matriks ongkos tereduksi.
• Cara lain yang lebih sederhana menghitung lower bound adalah dengan
menjumlahkan nilai minimum pada setiap baris matriks. Dasar pemikirannya adalah
bahwa sembarang solusi, termasuk solusi optimal, total ongkos penugasannya tidak
lebih kecil dari jumlah semua nilai terkecil pada setiap baris.
• Untuk sembarang solusi yang legitimate (tidak ada job yang sama di-assign ke 2
orang atau lebih) jika sebuah job di-assign dengan orang, maka ongkos peng-
assign-an tersebut dihitung sebagai salah satu komponen nilai terkecil di dalam
penjumlahan tersebut.
3
1. Cost untuk simpul akar:
𝑐Ƹ 0 = 2 + 3 + 1 + 4 = 10
8
2. Bangkitkan anak-anak dari simpul akar:
𝑐(0)
Ƹ
𝑐(1)
Ƹ 𝑐(2)
Ƹ 𝑐(3)
Ƹ 𝑐(4)
Ƹ
Simpul hidup: 1, 2, 3, dan 4

Simpul cost paling kecil: 2
8 8 8 Simpul-E sekarang: 2
(Sumber gambar: Levitin, 2003) 4
Simpul hidup: 1, 3, 4, 5, 6, dan 7
𝑐(5)
Ƹ 𝑐(6)
Ƹ 𝑐(7)
Ƹ Simpul cost paling kecil: 5
Simpul-E sekarang: 5
 Job 1 Job 2 Job 3 Job 4  Job 1 Job 2 Job 3 Job 4

 9 8  Orang a  9
 2 7
 2 7 8  Orang a
C= 6 4 3 7  Orang b C =  6 4 3 7  Orang b
   
 5 8 1 84  Orang c  5 8 1 4  Orang c
 7 6 9 4  Orang d  7 6 9 4  Orang d
𝑐(5)
Ƹ = 2 + 6 + 1 + 4 = 13 𝑐(7)
Ƹ = 2 + 7 + 1 + 7 = 17
5
B B B
B B
Simpul 8 adalah simpul solusi (goal node) dan

merupakan solusi optimal
 Job 1 Job 2 Job 3 Job 4 Semua simpul hidup yang cost-nya lebih besar
 9 8  Orang a
 2 7 Goal node B dari 13 dibunuh karena tidak mungkin
C= 6 4 3 7  Orang b (solusi optimal) menghasilkan cost lebih kecil dari 13.
 
 5 8 1 4  Orang c (simpul 1, 3, 4, 7. dan 9 dibunuh → B)
 7 6 9 4  Orang d
Solusi optimal: X = (a→2, b→1, c→3, d→4)
𝑐(8)
Ƹ = 2 + 6 + 1 + 4 = 13 6
Cost = 13
Integer Knapsack Problem
• Persoalan: Diberikan n buah objek dan sebuah knapsack dengan
kapasitas bobot K. Setiap objek memiliki properti bobot (weigth)
wi dan keuntungan(profit) pi. Bagaimana cara memilih objek-
objek yang dimasukkan ke dalam knapsack sedemikian sehingga
diperoleh total keuntungan yang maksimal dengan syarat tidak
boleh melebihi kapasitas knapsack.
• Formulasi matematis:
n
i =1

n
w x  K
i =1
i i

7
• Persoalan knapsack adalah persoalan maksimasi (mencari keuntungan maksimum)
• Oleh karena itu, cost setiap simpul pada pohon ruang status menyatakan batas
atas (upper bound) dari solusi optimum.
• (Bandingkan dengan pendekatan least cost search (untuk persoalan minimasi)

yang dalam hal ini cost setiap simpul menyatakan batas bawah (lower bound) dari
solusi optimum)
• Pada persoalan maksimasi, simpul berikutnya yang diekspansi adalah simpul hidup
yang memiliki cost paling besar.
• Agar pencarian solusi lebih mangkus, maka objek-objek diurutkan berdasarkan

pi/wi yang menurun (dari besar ke kecil) sebagai berikut:
p1/w1  p2/w2  …  pn/wn
8
• Pohon ruang statusnya berbentuk pohon biner. Cabang kiri menyatakan objek i
dipilih (xi = 1), cabang kanan menyatakan objek i tidak dipilih (xi = 0).
• Tiap simpul pada aras i di dalam pohon biner, i = 0, 1, 2, …n, menyatakan

himpunan bagian (subset) dari n objek yang dimasukkan ke dalam knapsack, yang
dipilih dari i objek pertama (yang sudah diurut berdasarkan pi/wi yang menurun).
• Tiap simpul diisi dengan total bobot knapsack yang sudah terpakai (W) dan total
keuntungan yang sudah dicapai (F).
• Cost atau batas atas (upper bound) simpul i dihitung sebagai penjumlahan total
keuntungan yang sudah dicapai (F) ditambah dengan perkalian sisa kapasitas
knapsack (K – W) dengan rasio keuntungan per bobot objek yang tersisa
berikutnya (pi + 1/wi + 1), atau dengan rumus:
𝑐Ƹ 𝑖 = 𝐹 + (𝐾 − 𝑊)𝑝𝑖+1 /𝑤𝑖+1
9
Contoh: Misalkan n = 4, K = 10
(w1, w1, w3, w4) = (4, 7, 5, 3),
(p1, p1, p3, p4) = (40, 42, 25, 12),
Langkah-Langkah penyelesaian:
1. Hitung pi/wi → (p1/w1, p2/w2, p3/w3, p4/w4 ) = (10, 6, 5, 4)
2. Urutkan objek-objek berdasarkan pi/wi yang menurun → kebetulan sudah terurut
3. Bangkitkan simpul akar (simpul 0), W = 0, F = 0,(belum ada objek dipilih) dan
𝑐Ƹ 0 = 𝐹 + (𝐾 − 𝑊)𝑝1 /𝑤1 = 0 + (10 − 0)(10) = 100
W=0
F =0
𝑐Ƹ 0 =100
(Sumber: Levitin, 2003)
10
4. Bangkitkan simpul anak kiri (simpul 2) dan simpul anak kanan (simpul 3) dari simpul
akar
• Simpul 1 (objek 1 diambil): W = 0 + 4 = 4; F = 0 + 40 = 40
𝑐Ƹ 1 = 𝐹 + (𝐾 − 𝑊)𝑝2 /𝑤2 = 40 + (10 − 4)(6) = 76
• Simpul 2 (objek 1 tidak diambil): W = 0 + 0 = 0; F = 0 + 0 = 0
𝑐Ƹ 2 = 𝐹 + (𝐾 − 𝑊)𝑝2 /𝑤2 = 0 + (10 − 0)(6) = 60
Pohon ruang status yang terbentuk: 0
W=0
F =0
objek 1 diambil 𝑐Ƹ 0 =100 objek 1 tidak diambil
1 2 Simpul hidup: 1 dan 2

W=4 W=0 Karena simpul 1 memiliki
F =40 F =0 cost paling besar, maka
simpul 1 selanjutnya yang
𝑐Ƹ 1 =76 𝑐Ƹ 2 =60
diekpansi
11
5. Bangkitkan anak-anak dari simpul 1, yaitu simpul 3 dan simpul 4
• Simpul 3 (w2 diambil): W = 4 + 7 = 11 > kapasitas knapsack (K = 10)
Simpul 3 langsung dimatikan (B).
• Simpul 4 (w2 tidak diambil): W = 4 + 0 = 4; F = 40 + 0 = 40
𝑐Ƹ 4 = 𝐹 + (𝐾 − 𝑊)𝑝3 /𝑤3 = 40 + (10 − 4)(5) = 70
Pohon ruang status yang terbentuk: 0
W=0
F =0
x1 = 1 100 x1 = 0
1 2
Simpul hidup: 2 dan 4 W=4 W=0
Karena simpul 4 memiliki F =40 F =0
cost paling besar, maka x2 = 1 76 x2 = 0 60
3 4
simpul 4 selanjutnya yang
W=11 W=4
diekpansi F = 40
B 70 12
0
W=0
Simpul 5 (objek 3 diambil): W = 4 + 5 = 9; F = 40 + 25 = 65
F =0
𝑐Ƹ 5 = 𝐹 + (𝐾 − 𝑊)𝑝4 /𝑤4 = 65 + (10 − 9)(4) = 69
x1 = 1 100 x1 = 0
Simpul 6 (objek 3 tidak diambil): W = 4 + 0 = 4; F = 40 + 0 = 40 1 2
𝑐Ƹ 6 = 𝐹 + (𝐾 − 𝑊)𝑝4 /𝑤4 = 40 + (10 − 4)(4) = 64 W=4 W=0
F =40 F =0
x2 = 1 76 x2 = 0 60
3 4
Simpul hidup: 2, 5, dan 6
W=11 W=4
Karena simpul 5 memiliki cost paling F = 40
besar, maka simpul 5 selanjutnya yang B
x3 = 1 70 x3 = 0
diekspansi 5 6
W=9 W=4
F = 65 F = 40
69 64
13
0
W=0
Simpul 7 (w4 diambil): W = 9 + 3 = 12 > kapasitas knapsack (K = 10) F =0
Simpul 7 langsung dimatikan. 100
x1 = 1 x1 = 0
Simpul 8 (w4 tidak diambil): W = 9 + 0 = 9; F = 65 + 0 = 65 1 2
𝑐Ƹ 8 = 𝐹 + (𝐾 − 𝑊)𝑝5 /𝑤5 = 65 + (10 − 9)(0) = 65 W=4 W=0
F =40 F =0
x2 = 1 76 x2 = 0 60 B
3 4
Simpul 8 adalah simpul solusi (goal node) W=11 W=4
dan merupakan solusi optimal F = 40
B 70
x3 = 1 x3 = 0
Semua simpul hidup yang cost-nya lebih 5 6
W=9 W=4
kecil dari 65 dibunuh F = 65 F = 40
B
(simpul 2 dan simpul 6 dibunuh) 69
x4 = 0 64
x4 = 1
7 8
Solusi optimal: X = (1, 0, 1, 0), F = 65 W=12 W=9
F = 65 65
B 14
Goal node (solusi optimal)
TAMAT
15
Algoritma Divide and Conquer
Oleh: Rinaldi Munir

Sekolah Teknik Elektro dan Informatika ITB 1
• Divide and Conquer dulunya adalah strategi militer yang
dikenal dengan nama divide ut imperes.
• Sekarang strategi tersebut menjadi strategi fundamental di

dalam ilmu komputer dengan nama Divide and Conquer.
2
3
Definisi
• Divide: membagi persoalan menjadi beberapa

upa-masalah yang memiliki kemiripan dengan
persoalan semula namun berukuran lebih kecil
(idealnya berukuran hampir sama),
• Conquer (solve): menyelesaikan masing-masing

upa-masalah (secara langsung atau secara
rekursif).
• Combine: mengabungkan solusi masing-masing

upa-masalah sehingga membentuk solusi
persoalan semula.
4
O
Q
U
C
R
E
sekaligus
• Obyek persoalan yang dibagi : masukan (input) atau
instances persoalan yang berukuran n seperti:
- tabel (larik),
- matriks,
- eksponen,
- dll, bergantung persoalannya.
• Tiap-tiap upa-masalah mempunyai karakteristik yang

sama (the same type) dengan karakteristik masalah
asal
• sehingga metode Divide and Conquer lebih natural

diungkapkan dengan skema rekursif.
6
Skema Umum Algoritma Divide and Conquer
procedure DIVIDE_and_CONQUER(input n : integer)

{ Menyelesaikan masalah dengan algoritma D-and-C.
Masukan: masukan yang berukuran n
Keluaran: solusi dari masalah semula
}
Deklarasi
r, k : integer
Algoritma
if n  n0 then {ukuran masalah sudah cukup kecil }
SOLVE upa-masalah yang berukuran n ini
else
Bagi menjadi r upa-masalah, masing-masing berukuran n/r
for masing-masing dari r upa-masalah do
DIVIDE_and_CONQUER(n/k)
endfor
COMBINE solusi dari r upa-masalah menjadi solusi masalah semula }
endif
7
Jika pembagian selalu menghasilkan dua upa-masalah yang
berukuran sama:
procedure DIVIDE_and_CONQUER(input n : integer)
{ Menyelesaikan masalah dengan algoritma D-and-C.
Masukan: masukan yang berukuran n
Keluaran: solusi dari masalah semula
}
Deklarasi
r, k : integer
Algoritma
if n  n0 then {ukuran masalah sudah cukup kecil }
SOLVE upa-masalah yang berukuran n ini
else
Bagi menjadi 2 upa-masalah, masing-masing berukuran n/2
DIVIDE_and_CONQUER(upa-masalah pertama yang berukuran n/2)
DIVIDE_and_CONQUER(upa-masalah kedua yang berukuran n/2)
COMBINE solusi dari 2 upa-masalah
endif
 g (n) , n  n0
T (n)  
2T ( n / 2)  f ( n ) , n  n0 8
Mencari Nilai Minimum dan
Maksimum (MinMaks)
Persoalan: Misalkan diberikan tabel A yang

berukuran n elemen dan sudah berisi nilai
integer.
Carilah nilai minimum dan nilai maksimum
sekaligus di dalam tabel tersebut.
9
procedure MinMaks1(input A : TabelInt, n : integer,
output min, maks : integer)
{ Mencari nilai minimum dan maksimum di dalam tabel A yang berukuran n
elemen, secara brute force.
Masukan: tabel A yang sudah terdefinisi elemen-elemennya
Keluaran: nilai maksimum dan nilai minimum tabel
}
Deklarasi
i : integer
Algoritma:
min A1 { inisialisasi nilai minimum}
maksA1 { inisialisasi nilai maksimum }
for i2 to n do
if Ai < min then

minAi
endif
if Ai > maks then

maksAi
endif
endfor
T(n) = (n – 1) + (n – 1) = 2n – 2 = O(n) 10
Ide penyelesaian dengan Divide and Conquer
Contoh 4.1. Misalkan tabel A berisi elemen-elemen sebagai berikut:
4 12 23 9 21 1 35 2 24
Ide dasar algoritma secara Divide and Conquer:
4 12 23 9 21 1 35 2 24
DIVIDE
4 12 23 9 21 1 35 2 24
SOLVE: tentukan min &

maks pada tiap bagian
4 12 23 9 21 1 35 2 24
min = 4 min = 1
maks = 23 maks = 35
COMBINE
4 12 23 9 21 1 35 2 24
min = 1
11
maks = 35
• Ukuran tabel hasil pembagian dapat dibuat
cukup kecil sehingga mencari minimum dan
maksimum dapat diselesaikan (SOLVE) secara
trivial.
• Dalam hal ini, ukuran “kecil” yang dipilih

adalah 1 elemen atau 2 elemen.
12
MinMaks(A, n, min, maks)
Algoritma:
1. Untuk kasus n = 1 atau n = 2,
SOLVE: Jika n = 1, maka min = maks = A[n]
Jika n = 2, maka bandingkan kedua elemen untuk
menentukan min dan maks.
2. Untuk kasus n > 2,

(a) DIVIDE: Bagi dua tabel A menjadi dua bagian yang sama,
A1 dan A2
(b) CONQUER:
MinMaks(A1, n/2, min1, maks1)
MInMaks(A2, n/2, min2, maks2)
(c) COMBINE:
if min1 < min2 then min  min1 else min  min2
if maks1 < maks2 then maks  maks2 else maks  maks1
13
Contoh 4.2. Tinjau kembali Contoh 4.1 di atas.
DIVIDE dan CONQUER:
4 12 23 9 21 1 35 2 24
4 12 23 9 21 1 35 2 24
4 12 23 9 21 1 35 2 24
SOLVE dan COMBINE:
4 12 23 9 21 1 35 2 24
min = 4 min = 9 min = 21 min = 1 min = 2
maks = 12 maks = 23 maks = 21 maks =35 maks = 24
4 12 23 9 21 1 35 2 24
min = 4 min = 9 min = 1
maks = 12 maks = 23 maks = 35
4 12 23 9 21 1 35 2 24
min = 4 min = 1
maks = 23 maks = 35
4 12 23 9 21 1 5 2 24 14
min = 1
maks = 35
procedure MinMaks2(input A : TabelInt, i, j : integer,
output min, maks : integer)
{ Mencari nilai maksimum dan minimum di dalam tabel A yang berukuran n
elemen secara Divide and Conquer.
Masukan: tabel A yang sudah terdefinisi elemen-elemennya
Keluaran: nilai maksimum dan nilai minimum tabel
}
Deklarasi
min1, min2, maks1, maks2 : integer
Algoritma:
if i=j then { 1 elemen }
minAi
maksAi
else
if (i = j-1) then { 2 elemen }
if Ai < Aj then
maksAj
minAi
else
maksAi
minAj
endif
else { lebih dari 2 elemen }
k(i+j) div 2 { bagidua tabel pada posisi k }
MinMaks2(A, i, k, min1, maks1)
MinMaks2(A, k+1, j, min2, maks2)
if min1 < min2 then
minmin1
else
minmin2
endif
if maks1<maks2 then
maksmaks2
else
maksmaks1
endif 15
Kompleksitas waktu asimptotik:
 0 ,n 1

T (n)   1 ,n  2
2T ( n / 2)  2 , n  2

Penyelesaian:
Asumsi: n = 2k, dengan k bilangan bulat positif, maka
T(n) = 2T(n/2) + 2
= 2(2T(n/4) + 2) + 2 = 4T(n/4) + 4 + 2
= 4T(2T(n/8) + 2) + 4 + 2 = 8T(n/8) + 8 + 4 + 2
= ...
k 1
k–1
=2 T(2) +  2 i
i 1
= 2k – 1  1 + 2k – 2
= n/2 + n – 2
= 3n/2 – 2
= O(n) 16
Bandingkan:
• MinMaks1 secara brute force : T(n) = 2n – 2
• MinMaks2 secara divide and conquer: T(n) = 3n/2 – 2
• Perhatikan: 3n/2 – 2 < 2n – 2 , n  2.
• Kesimpulan: algoritma MinMaks lebih mangkus

dengan algoritma Divide and Conquer.
• Algoritma divide and conquer dapat membantu kita

menemukan algoritma yang mangkus.
17
Algoritma Pengurutan Secara
Divide and Conquer
procedure Sort(input/output A : TabelInt, input n : integer)
{ Mengurutkan tabel A dengan metode Divide and Conquer

Masukan: Tabel A dengan n elemen
Keluaran: Tabel A yang terurut
}
Algoritma:
if Ukuran(A) > 1 then
Bagi A menjadi dua bagian, A1 dan A2, masing-masing berukuran n1
dan n2 (n = n1 + n2)
Sort(A1, n1) { urut bagian kiri yang berukuran n1 elemen }

Sort(A2, n2) { urut bagian kanan yang berukuran n2 elemen }
Combine(A1, A2, A) { gabung hasil pengurutan bagian kiri dan

bagian kanan }
end
18
Contoh:
A 4 12 3 9 1 21 5 2
Dua pendekatan (approach) pengurutan:
1. Mudah membagi, sulit menggabung (easy split/hard join)

Tabel A dibagidua berdasarkan posisi elemen:
Divide: A1 4 12 3 9 A2 1 21 5 2
Sort: A1 3 4 9 12 A2 1 2 5 21
Combine: A1 1 2 3 4 5 9 12 21
Algoritma pengurutan yang termasuk jenis ini:

a. urut-gabung (Merge Sort)
b. urut-sisip (Insertion Sort)
19
2. Sulit membagi, mudah menggabung (hard split/easy join)
Tabel A dibagidua berdasarkan nilai elemennya. Misalkan
elemen-elemen A1  elemen-elemen A2.
A 4 12 3 9 1 21 5 2
Divide: A1 4 2 3 1 A2 9 21 5 12
Sort: A1 1 2 3 4 A2 5 9 12 21
Combine: A 1 2 3 4 5 9 12 21
Algoritma pengurutan yang termasuk jenis ini:

a. urut-cepat (Quick Sort)
b. urut-seleksi (Selection Sort)
20
(a) Merge Sort
• Ide merge sort:
21
Merge Sort
Algoritma:
1. Untuk kasus n = 1, maka tabel A sudah terurut
dengan sendirinya (langkah SOLVE).
2. Untuk kasus n > 1, maka

(a) DIVIDE: bagi tabel A menjadi dua bagian,
bagian kiri dan bagian kanan, masing-masing
bagian berukuran n/2 elemen.
(b) CONQUER: Secara rekursif, terapkan
algoritma D-and-C pada masing-masing bagian.
(c) MERGE: gabung hasil pengurutan kedua
bagian sehingga diperoleh tabel A yang terurut.
22
Contoh Merge:
A1 A2 B
1 13 24 2 15 27 1 < 2  1 1
1 13 24 2 15 27 2 <13  2 1 2
1 13 24 2 15 27 13<1513 1 2 13
1 13 24 2 15 27 15<2415 1 2 13 15
1 13 24 2 15 27 24<2724 1 2 13 15 24
1 13 24 2 15 27 27  1 2 13 15 24 27
23
Proses merge:
24
Contoh 4.3. Misalkan tabel A berisi elemen-elemen berikut:
4 12 23 9 21 1 5 2
DIVIDE, CONQUER, dan SOLVE:
4 12 23 9 21 1 5 2
4 12 23 9 21 1 5 2
4 12 23 9 21 1 5 2
4 12 23 9 21 1 5 2
MERGE: 4 12 9 23 1 21 2 5
4 9 12 23 1 2 5 21
1 2 4 5 9 12 21 23
25
26
procedure MergeSort(input/output A : TabelInt, input i, j : integer)
{ Mengurutkan tabel A[i..j] dengan algoritma Merge Sort

}
Deklarasi:
k : integer
Algoritma:
if i < j then { Ukuran(A)> 1}
k(i+j) div 2
MergeSort(A, i, k)
MergeSort(A, k+1, j)
Merge(A, i, k, j)
endif
27
Prosedur Merge:
procedure Merge(input/output A : TabelInt, input kiri,tengah,kanan :

integer)
{ Menggabung tabel A[kiri..tengah] dan tabel A[tengah+1..kanan]
menjadi tabel A[kiri..kanan] yang terurut menaik.
Masukan: A[kiri..tengah] dan tabel A[tengah+1..kanan] yang sudah
terurut menaik.
Keluaran: A[kiri..kanan] yang terurut menaik.
}
Deklarasi
B : TabelInt
i, kidal1, kidal2 : integer
Algoritma:
kidal1kiri { A[kiri .. tengah] }
kidal2tengah + 1 { A[tengah+1 .. kanan] }
ikiri
while (kidal1  tengah) and (kidal2  kanan) do
if Akidal1  Akidal2 then
BiAkidal1
kidal1kidal1 + 1
else
BiAkidal2
kidal2kidal2 + 1
endif
ii + 1
endwhile
{ kidal1 > tengah or kidal2 > kanan }
{ salin sisa A bagian kiri ke B, jika ada }

while (kidal1  tengah) do
BiAkidal1
kidal1kidal1 + 1
ii + 1
endwhile
{ kidal1 > tengah }
{ salin sisa A bagian kanan ke B, jika ada }

while (kidal2  kanan) do
BiAkidal2
kidal2kidal2 + 1
ii + 1
endwhile
{ kidal2 > kanan }
{ salin kembali elemen-elemen tabel B ke A }

for ikiri to kanan do
AiBi
endfor
{ diperoleh tabel A yang terurut membesar } 28
 Kompleksitas waktu:
Asumsi: n = 2k
T(n) = jumlah perbandingan pada pengurutan dua buah

upatabel + jumlah perbandingan pada prosedur Merge
 a ,n 1
T (n)  
2T (n / 2)  cn , n  1
29
Penyelesaian:
T(n) = 2T(n/2) + cn
= 2(2T(n/4) + cn/2) + cn = 4T(n/4) + 2cn
= 4(2T(n/8) + cn/4) + 2cn = 8T(n/8) + 3cn
= ...
= 2k T(n/2k) +kcn
Berhenti jika ukuran tabel terkecil, n = 1:
n/2k = 1  k = 2log n
sehingga
T(n) = nT(1) + cn 2log n

= na + cn 2log n
= O(n 2log n)
30
(b) Insertion Sort
procedure InsertionSort(input/output A : TabelInt,

input i, j : integer)
{ Mengurutkan tabel A[i..j] dengan algoritma Insertion Sort.
}
Deklarasi:
k : integer
Algoritma:
ki
InsertionSort(A, i, k)
InsertionSort(A, k+1, j)
Merge(A, i, k, j)
endif
31
Perbaikan:
procedure InsertionSort(input/output A : TabelInt,

input i, j : integer)
{ Mengurutkan tabel A[i..j] dengan algoritma Insertion Sort.
}
Deklarasi:
k : integer
Algoritma:
ki
InsertionSort(A, k+1, j)
Merge(A, i, k, j)
endif
Selain menggunakan orosedur Merge yang sama seperti pada MergeSort,

kita dapat mengganti Merge dengan prosedur penyisipan sebuah elemen
pada tabel yang sudah terurut (lihat algoritma Insertion Sort versi iteratif).
32
4 12 23 9 21 1 5 2
DIVIDE, CONQUER, dan SOLVE::

4 12 3 9 1 21 5 2
4 12 3 9 1 21 5 2
4 12 3 9 1 21 5 2
4 12 3 9 1 21 5 2
4 12 3 9 1 21 5 2
4 12 3 9 1 21 5 2
4 12 3 9 1 21 5 2
4 12 3 9 1 21 5 2
4 12 3 9 1 21 5 2
33
MERGE: 4 12 3 9 1 21 2 5
4 12 3 9 1 2 5 21
4 12 3 9 1 2 5 21
4 12 3 1 2 5 9 21
4 12 1 2 3 5 9 21
4 1 2 3 5 9 12 21
1 2 3 4 5 9 12 21
34
Kompleksitas waktu algoritma Insertion Sort:
 a ,n 1
T (n)  
T (n  1)  cn , n  1
Penyelesaian:
T(n) = cn + T(n – 1)
= cn + { c  (n – 1) + T(n – 2) }
= cn + c(n – 1) + { c  (n – 2) + T(n – 3) }
= cn + c  (n – 1) + c  (n – 2) + {c(n – 3) + T(n – 4) }
= ...
= cn + c  (n – 1) + c(n – 2) + c(n – 3) + ... + c2 + T(1)
= c{ n + (n – 1) + (n – 2) + (n – 3) + ... + 2 } + a
= c{ (n – 1)(n + 2)/2 } + a
= cn2/2 + cn/2 + (a – c )
= O(n2)
35
(c) Quick Sort
• Ditemukan oleh Tony Hoare tahun 1959 dan
dipublikasikan tahun 1962.
• Termasuk pada pendekatan sulit membagi,

mudah menggabung (hard split/easy join)
• Tabel A dibagi (istilahnya: dipartisi) menjadi

A1 dan A2 sedemikian sehingga elemen-
elemen A1  elemen-elemen A2.
36
Partisi: A1 4 2 3 1 A2 9 21 5 12
Sort: A1 1 2 3 4 A2 5 9 12 21
Combine: A 1 2 3 4 5 9 12 21
37
• Terdapat beberapa varian Algoritma Quicksort. Versi orisinal
adalah dari Hoare seperti di bawah ini:
Teknik mem-partisi tabel:
(i) pilih x  { A[1], A[2], ..., A[n] } sebagai pivot,
(ii) pindai tabel dari kiri sampai ditemukan A[p]  x
(iii) pindai tabel dari kanan sampai ditemukan A[q]  x
(iv) pertukarkan A[p]  A[q]
(v) ulangi (ii), dari posisi p + 1, dan (iii), dari posisi q – 1 ,

sampai kedua pemindaian bertemu di tengah tabel (p  q)
38
8 1 4 6 9 3 5 7
Langkah-langkah partisi:
(i): 8 1 4 6 9 3 5 7
pivot
 
(ii) & (iii): 8 1 4 6 9 3 5 7
p q
(iv): 5 1 4 6 9 3 8 7
39
 
(ii) & (iii): 5 1 4 6 9 3 8 7
p q
(iv): 5 1 4 3 9 6 8 7

(ii) & (iii): 5 1 4 3 9 6 8 7
q p (q < p, berhenti)
Hasil partisi pertama:
kiri: 5 1 4 3 ( < 6)
kanan: 9 6 8 7 (  6)
40
5 1 4 3 9 6 8 7
p q p q
1 5 4 3 6 9 8 7
1 5 4 3 6 9 8 7
q p q p
(q > p , berhenti) (q > p , berhenti)
1 5 4 3 6 9 8 7
p q p q
41
1 3 4 5 6 7 8 9
1 3 4 5 6 7 8 9
q p q p
p>q, berhenti p>q, berhenti
1 3 4 5 6 7 8 9
q p q p
p>q p>q
1 3 4 5 6 7 8 9 (terurut)
42
Pseudo-code Quick Sort:
procedure QuickSort(input/output A : TabelInt, input i,j: integer)
{ Mengurutkan tabel A[i..j] dengan algoritma Quick Sort.

Masukan: Tabel A[i..j] yang sudah terdefinisi elemen-elemennya.
Keluaran: Tabel A[i..j] yang terurut menaik.
}
Deklarasi
k : integer
Algoritma:
if i < j then { Ukuran(A) > 1 }
Partisi(A, i, j, k) { Dipartisi pada indeks k }
QuickSort(A, i, k) { Urut A[i..k] dengan Quick Sort }
QuickSort(A, k+1, j) { Urut A[k+1..j] dengan Quick Sort }
endif
43
procedure Partisi(input/output A : TabelInt, input i, j : integer,
output q : integer)
{ Membagi tabel A[i..j] menjadi upatabel A[i..q] dan A[q+1..j]

Masukan: Tabel A[i..j]yang sudah terdefinisi harganya.
Keluaran upatabel A[i..q] dan upatabel A[q+1..j] sedemikian sehingga
elemen tabel A[i..q] lebih kecil dari elemen tabel A[q+1..j]
}
Deklarasi
pivot, temp : integer
Algoritma:
pivotA[(i + j) div 2] { pivot = elemen tengah}
p  i
q  j
repeat
while A[p] < pivot do
p  p + 1
endwhile
{ A[p] >= pivot}
while A[q] > pivot do

q  q – 1
endwhile
{ A[q] <= pivot}
if p < q then
{pertukarkan A[p] dengan A[q] }
swap(A[p], A[q])
{tentukan awal pemindaian berikutnya }

p  p + 1
q  q - 1
endif
until p > q
44
Versi kedua: Partisi sedemikian rupa sehingga
elemen-elemen larik kiri  pivot dan elemen-elemen
larik kanan  dari pivot. Pivot = elemen pertama.
pivot
Contoh:
5, 3, 1, 9, 8, 2, 4, 7
pivot
Partisi 2, 3, 1, 4, 5, 8, 9, 7
Semua  pivot Semua  pivot
45
Pseudo-code Quick Sort versi 2:
procedure QuickSort2(input/output A : TabelInt, input i,j: integer)
{ Mengurutkan tabel A[i..j] dengan algoritma Quick Sort.

}
Deklarasi
k : integer
Algoritma:
Partisi2(A, i, j, k) { Dipartisi pada indeks k }
QuickSort2(A, i, k-1) { Urut A[i..k-1] dengan Quick Sort }
QuickSort2(A, k+1, j) { Urut A[k+1..j] dengan Quick Sort }
endif
46
procedure Partisi2(input/output A : TabelInt, input i, j : integer,
output q : integer)
{ Membagi tabel A[i..j] menjadi upatabel A[i..q] dan A[q+1..j]

Masukan: Tabel A[i..j]yang sudah terdefinisi harganya.
Keluaran upatabel A[i..q] dan upatabel A[q+1..j] sedemikian
sehingga elemen tabel A[i..q] lebih kecil dari pivot dan elemen
tabel A[q+1..j] lebih besar dari pivot
}
Deklarasi
pivot : integer
p : integer
Algoritma:
pivotA[i] { missal pivot = elemen pertama}
p  i
q  j+1
repeat
repeat
p  p + 1
until A[p]  pivot
repeat
q  q – 1
until A[q]  pivot
swap(A[p], A[q]) {pertukarkan A[p] dengan A[q] }

until p  q
swap(A[p], A[q]) { undo last swap when p  q }

swap(A[i], A[q]) 47
Contoh: (Levitin, 2003)
 
5 3 1 9 8 2 4 7
p q
5 3 1 4 8 2 9 7
5 3 1 4 8 2 9 7
p q
5 3 1 4 2 8 9 7
5 3 1 4 2 8 9 7
q p  stop sebab p > q
2 3 1 4 5 8 9 7
5 5 48
   
2 3 1 4 8 9 7
p q p q
2 1 3 4 8 7 9
2 1 3 4 8 7 9
q p q p
1 2 3 4 7 8 9
1 3 4 7 9
q p
4
Terurut:
1 2 3 4 5 7 8 9
49
Cara pemilihan pivot (khusus pada Versi 1):
1. Pivot = elemen pertama/elemen terakhir/elemen
tengah tabel
2. Pivot dipilih secara acak dari salah satu elemen

tabel.
3. Pivot = elemen median tabel
50
Kompleksitas Algoritma Quicksort:
1. Kasus terbaik (best case)
• Kasus terbaik terjadi bila pivot adalah

elemen median sedemikian sehingga kedua
upatabel berukuran relatif sama setiap kali
pempartisian.
51
n
n/2 n/2
n/4 n/4 n/4 n/4
n/8 n/8 n/8 n/8 n/8 n/8 n/8 n/8

... ... ... ... ... ... ... ....
1 1 1 ...................1...1....1......................... 1 1 1
52
 a ,n 1
T (n)  
2T (n / 2)  cn , n  1
Penyelesaian (seperti pada Merge Sort):
T(n) = 2T(n/2) + cn = na + cn 2log n = O(n 2log n).
53
2. Kasus terburuk (worst case)
• Kasus ini terjadi bila pada setiap partisi pivot

selalu elemen maksimum (atau elemen
minimum) tabel.
• Kasus jika tabel sudah terurut menaik/menurun

dan kita ingin terurut menurun/menaik.
54
n
1 n–1
1 n–2
1 n–3
...
1 1
55
Kompleksitas waktu pengurutan:
 a ,n  1
T (n)  
T (n  1)  cn , n  1
Penyelesaian (seperti pada Insertion Sort):
T(n) = T(n – 1) + cn = O(n2).
56
3. Kasus rata-rata (average case)
• Kasus ini terjadi jika pivot dipilih secara acak

dari elemen tabel, dan peluang setiap elemen
dipilih menjadi pivot adalah sama.
• Tavg(n) = O(n 2log n).
57
(d) Selection Sort
procedure SelectionSort(input/output A : TabelInt, input i,j: integer)
{ Mengurutkan tabel A[i..j] dengan algoritma Selection Sort.

}
Algoritma:
Bagi(A, i, j)
SelectionSort(A, i+1, j)
endif
58
procedure Bagi(input/output A : TabInt, input i,j: integer)
{ Mencari elemen terkecil di dalam tabel A[i..j], dan menempatkan

elemen terkecil sebagai elemen pertama tabel.
Masukan: A[i..j]
Keluaran: A[i..j] dengan Ai adalah elemen terkecil.
}
Deklarasi
idxmin, k, temp : integer
Algoritma:
idxmini
for ki+1 to jdo
if Ak < Aidxmin then
idxmink
endif
endfor
{ pertukarkan A i dengan A idxmin }

tempAi
AiAidxmin
Aidxmintemp
59
4 12 3 9 1 21 5 2
Langkah-langkah pengurutan dengan Selection Sort:
4 12 3 9 1 21 5 2
1 12 3 9 4 21 5 2
1 2 3 9 4 21 5 12
1 2 3 9 4 21 5 12
1 2 3 4 9 21 5 12
1 2 3 4 5 21 9 12
1 2 3 4 5 9 12 21
1 2 3 4 5 9 12 21
1 2 3 4 5 9 12 21 60
Kompleksitas waktu algoritma:
 a ,n  1
T (n)  
T (n  1)  cn , n  1
Penyelesaian (seperti pada Insertion Sort):

2
T(n) = O(n ).
61
Teorema Master
Misalkan T(n) adalah fungsi menaik yang memenuhi
relasi rekurens:
T(n) = aT(n/b) + cnd
yang dalam hal ini n = bk , k = 1, 2, …, a  1, b  2,

dan c dan d adalah bilangan riil  0, maka
 O(n d ) jika a  b d

T(n) adalah O(n d log n) jika a  b d
 O(n logb a ) jika a  b d

62
Contoh: Pada algoritma Mergesort/Quick Sort,
 a ,n 1
T (n)  
2T (n / 2)  cn , n  1
Menurut Teorema Master, a = 2, b = 2, d = 1, dan

a = bd, maka relasi rekurens:
T(n) = 2T(n/2) + cn = O(n log n)
63
Persoalan Pemasangan Ubin
Persoalan: Diberikan sebuah papan yang berukuran
2k × 2k. Tersedia sebuah ubin dan 22k – 1 buah ubin
yang terdiri dari kelompok 3-ubin berbentuk huruf L.
Pasanglah semua ubin pada papan tersebut.
64
Algoritma D & C:
• Bagi papan menjadi 4 bagian
• Ubin tunggal dapat ditaruh di mana saja.
• Tempatkan kelompok 3-ubin berbentuk L
pada bagian tengah yang tidak ada ubin
tunggal
65
66
Latihan
• (Soal UTS 2011) Misalkan anda mempunyai array A[1..n] yang
telah berisi n elemen integer. Elemen mayoritas di dalam A
adalah elemen yang terdapat pada lebih dari n/2 posisi (jadi, jika
n = 6 atau n = 7, elemen mayoritas terdapat pada paling sedikit 4
posisi). Rancanglah algoritma divide and conquer (tidak dalam
bentuk pseudo-code, tapi dalam bentuk uraian deskriptif) untuk
menemukan elemen mayoritas di dalam A (atau menentukan
tidak terdapat elemen mayoritas). Jelaskan algoritma anda
dengan contoh sebuah array berukuran 8 elemen. Selanjutnya,
perkirakan kompleksitas algoritmanya dalam hubungan rekursif
(misalnya T(n) = bT(n/p) + h(n)), lalu selesaikan T(n) tersebut.
67
Solusi:
1. Jika n = 1, maka elemen tunggal tersebut adalah
mayoritasnya sendiri.
2. Jika n > 1, maka bagi array menjadi dua bagian (kiri dan
kanan) yang masing-masing berukuran sama (n/2).
3. Tahap combine. Ada empat kemungkinan kasus:
Kasus 1: tidak ada mayoritas pada setiap bagian, sehingga
array gabungan keduanya tidak memiliki mayoritas.
Return: “no majority”
Contoh: 4 3 4 2 7 5 2 1
4 3 4 2 7 5 2 1
Ingat definisi
no majority no majority
mayoritas!
4 3 4 2 7 5 2 1 68
“no majority”
Kasus 2: bagian kanan memiliki mayoritas, bagian kiri
tidak. Pada array gabungan, hitung jumlah elemen yang
sama dengan elemen mayoritas bagian kanan tersebut;
Jika elemen tersebut mayoritas, return elemen tersebut,
kalau tidak return “no majority”
Contoh: 4 3 4 2 7 4 4 4
Ingat definisi
mayoritas! 4 3 4 2 7 4 4 4
no majority majority = 4
Ingat definisi
4 3 4 2 7 4 4 4 mayoritas!
Jumlah elemen 4 = 5 buah  mayoritas
“majority = 4” 69
Contoh lain (tidak ada mayoritas):
4 3 5 2 7 4 4 4
4 3 5 2 7 4 4 4
no majority majority = 4
4 3 5 2 7 4 4 4
Jumlah elemen 4 = 4 buah  bukan mayoritas
“no majority”
70
Kasus 3: bagian kiri memiliki mayoritas, bagian kanan
tidak. Pada array gabungan, hitung jumlah elemen yang
sama dengan elemen mayoritas bagian kiri tersebut.
Jika elemen tersebut mayoritas, return elemen tersebut,
kalau tidak return “no majority”
Contoh: 3 3 4 3 7 3 3 4
3 3 4 3 7 3 3 4
majority = 3 no majority
3 3 4 3 7 3 3 4
“majority = 3” 71
Kasus 4: bagian kiri dan bagian kanan memiliki mayoritas,
Pada array gabungan, hitung jumlah elemen yang sama
dengan kedua elemen kandidat mayoritas tersebut.
Jika salah satu kandidat adalah elemen mayoritas, return
elemen tersebut, kalau tidak return “no majority”
Contoh: 3 3 4 3 4 4 4 4
3 3 4 3 4 4 4 4
majority = 3 majority = 4
3 3 4 3 4 4 4 4
Jumlah elemen 3 = 3 buah
72
“majority = 4”
Contoh keseluruhan:
4 3 4 4 4 5 4 3


4 3 4 4 4 5 4 3 

divide
4 3 4 4 4 5 4 3 


4 3 4 4 4 5 4 3 
4 3 4 4 4 5 4 3 
 solve
m=4 m=3 m=4 m=4 m=4 m=5 m=4 m=3 
73
4 3 4 4 4 5 4 3
m=4 m=3 m=4 m=4 m=4 m=5 m=4 m=3
4 3 4 4 4 5 4 3
nm m =4 nm nm 

4 3 4 4 4 5 4 3 

combine
m=4 nm 

4 3 4 4 4 5 4 3 

m=4
74
Kompleksitas waktu algoritma mayoritas:
T(n) adalah jumlah operasi perbandingan yang terjadi
(pada saat menghitung jumlah elemen yang sama dengan
kandidat mayoritas)
Pada setiap level terdapat dua pemanggilan rekursif,

masing-masing untuk n/2 elemen array.
Jumlah perbandingan yang terjadi paling banyak 2n (upper
bound) yaitu pada kasus 4, untuk array berukuran n.
Secara umum jumlah perbandingan = cn.
Untuk n = 1, jumlah perbandingan = 0, secara umum = a.
75
Jadi,
 a ,n 1
T (n)  
2T (n / 2)  cn , n  1
Menurut Teorema Master,
T(n) = 2T(n/2) + cn = O(n log n)
76
Mencari Pasangan Titik yang
Jaraknya Terdekat (Closest Pair)
Persoalan: Diberikan himpunan titik, P, yang terdiri

dari n buah titik, (xi, yi), pada bidang 2-D. Tentukan
sepasang titik di dalam P yang jaraknya terdekat satu
sama lain.
77
p5
p2
p4
p3 p6
p8
p1
p7
Jarak dua buah titik p1 = (x1, y1) dan p2 = (x2, y2):
d  ( x1  x2 )  ( y1  y2 )
2 2
78
Penyelesaian secara Brute Force
• Hitung jarak setiap pasang titik. Ada
sebanyak C(n, 2) = n(n – 1)/2 pasangan titik
• Pilih pasangan titik yang mempunyai jarak

terkecil.
• Kompleksitas algoritma adalah O(n2).
79
Penyelesaian secara Divide and Conquer
• Asumsi: n = 2k dan titik-titik sudah diurut
berdasarkan absis (x).
• Algoritma Closest Pair:

1. SOLVE: jika n = 2, maka jarak kedua
titik dihitung langsung dengan rumus
Euclidean.
80
2. DIVIDE: Bagi himpunan
titik ke dalam dua bagian, S1
dan S2, setiap bagian y
mempunyai jumlah titik yang p5
sama. L adalah garis maya p2
p4
yang membagi dua
himpunan titik ke dalam dua p3 p6
sub-himpunan, masing-
p8
masin n/2 titik. p1
p7
S1 S2 x
Garis L dapat dihampiri sebagai
L
y = xn/2 dengan asumsi titik-titik
diurut menaik berdasarkan absis.
81
3. CONQUER: Secara rekursif, terapkan algoritma D-
and-C pada masing-masing bagian.
4. COMBINE: Pasangan titik yang jaraknya terdekat

ada tiga kemungkinan letaknya:
(a) Pasangan titik terdekat terdapat di bagian S1.
(b) Pasangan titik terdekat terdapat di bagian S2.
(c) Pasangan titik terdekat dipisahkan oleh garis
batas L, yaitu satu titik di S1 dan satu titik di S2.
Jika kasusnya adalah (c), maka lakukan tahap ketiga

untuk mendapatkan jarak dua titik terdekat sebagai
solusi persoalan semula.
82
procedure FindClosestPair2(input P: SetOfPoint, n : integer,
output d : real)
{ Mencari jarak terdekat sepasang titik di dalam himpunan P.

}
Deklarasi:
d1, d2 : real
Algoritma:
if n = 2 then
d  jarak kedua titik dengan rumus Euclidean
else
S1  {p1, p2 ,..., pn/2 }
S2  {pn/2+1, pn/2+2 ,..., pn }
FindClosestPair2(S1, n/2, d1)
FindClosestPair2(S2, n/2, d2)
d  MIN(d1,d2)
{--***********************************************--}
Tentukan apakah terdapat titik pl di S1 dan pr di
S2 dengan jarak(pl, pr) < d. Jika ada, set
d dengan jarak terkecil tersebut.
{--***********************************************--}
endif
83
• Jika terdapat pasangan titik pl and pr yang jaraknya
lebih kecil dari d, maka kasusnya adalah:
(i) Absis x dari pl dan pr berbeda paling banyak

sebesar d.
(ii) Ordinat y dari pl dan pr berbeda paling banyak

sebesar d.
84
• Ini berarti pl and pr adalah sepasang titik yang berada
di daerah sekitar garis vertikal L:


• Berapa lebar strip abu-abu tersebut? 85

• Kita membatasi titik-titik di dalam strip selebar 2d Sstrip
• Oleh karena itu, implementasi tahap ketiga adalah

sbb:
(i) Temukan semua titik di S1t yang memiliki

absis x minimal xn/2 – d.
(ii ) Temukan semua titik di S2 yang memiliki

absis x maksimal x n/2 + d.
Sebut semua titik-titik yang ditemukan pada langkah

(i) dan (ii) tersebut sebagai himpunan Sstrip yang
d d
berisi s buah titik.
L
Urutkan titik-titik tersebut dalam urutan ordinat y
yang menaik. Misalkan q1, q2 , ..., qs menyatakan
hasil pengurutan.
86
87
for i1 to s do
for ji+1 to s do
if (|qi.x–qj.x |>d or |qi.y–qj.y|> d then
tidak diproses
else
d3  EUCLIDEAN(qi, qj)
if d3 < d then
d  d3
endif
endif
endfor
endfor
88
• Jika diamati, kita tidak perlu memeriksa semua titik di
dalam area strip abu-abu tersebut. Untuk sebuah titik P di
sebelah kiri garis L, kita hanya perlu memeriksa paling
banyak enam buah titik saja yang jaraknya sebesar d dari
ordinat P (ke atas dan ke bawah), serta titik-titik yang
berjarak d dari garis L.
 d

d d
P  
d
d d

d

89
• Pengurutan titik-titik dalam absis x dan ordinat y
dilakukan sebelum menerapkan algoritma Divide
and Conquer.
• Pemrosesan titik-titk di dalam Sstrip memerlukan
waktu t(n) = cn = O(n).
• Kompleksitas algoritma:
2T ( n / 2)  cn ,n  2
T (n)  
 a ,n  2
Solusi dari persamaan di atas adalah T(n) = O(n log n),

sesuai dengan Teorema Master
90
Perpangkatan a n
Misalkan a  R dan n adalah bilangan bulat

tidak negatif:
an = a × a × … × a (n kali), jika n > 0

=1 , jika n = 0
91
function Exp1(input a, n : integer)integer

{ Menghitung an, a > 0 dan n bilangan bulat tak-negatif
Masukan: a, n
Keluaran: nilai perpangkatan.
}
Deklarasi
k, hasil : integer
Algoritma:
hasil1
for k1 to n do
hasilhasil * a
endfor
return hasil
T(n) = n = O(n)
92
Penyelesaian dengan Divide and Conquer
Algoritma menghitung an:
1. Untuk kasus n = 0, maka an = 1.
2. Untuk kasus n > 0, bedakan menjadi dua

kasus lagi:
(i) jika n genap, maka an = an/2  an/2
(ii) jika n ganjil, maka an = an/2  an/2  a
93
Contoh 4.6. Menghitung 316 dengan metode Divide and Conquer:
316 = 38  38 = (38)2
= ((34)2)2
= (((32)2)2)2
= ((((31)2))2)2)2
= ((((30)2  3)2)2)2)2
= ((((1)2  3)2)2)2)2
= ((((3)2))2)2)2
= (((9)2)2)2
= (81) 2)2
= (6561)2
= 43046721
94
function Exp2(input a :real, n : integer)  real
{ mengembalikan nilai a^n, dihitung dengan metode Divide and
Conquer }
Algoritma:
if n = 0 then
return 1
else
if odd(n) then { fungsi ganjil }
return Exp2(a, n div 2)* Exp2(a, n div 2) * a
else
return Exp2(a, n div 2)* Exp2(a, n div 2)
endif
endif
Tidak mangkus, karena ada dua kali pemanggilan rekursif

untuk nialai parameter yang sama  Exp2(a, n div 2)
95
Perbaikan:
function Exp3(input a :real, n : integer)  real

{ mengembalikan nilai a^n, dihitung dengan metode Divide and
Conquer }
Algoritma:
if n = 0 then
return 1
else
xExp3(a, n div 2)
if odd(n) then { fungsi n ganjil }
return x * x * a
else
return x * x
endif
endif
96
Kompleksitas algoritma:
 0 ,n  0
T (n)  
1  T ( n / 2) , n  0
Penyelesaian:
T(n) = 1 + T( n/2 )
= 1 + (1 + T( n/4 ) = 2 + T( n/4 )
= 2 + (1 + T( n/8 ) = 3 + T( n/8 )
= ...
= k + T(n/2k )
97
Persamaan terakhir diselesaikan dengan membuat n/2k =1,
(n/2k) = 1  log (n/2k) = log 1

log n – log 2k = 0
log n – k log 2 = 0
log n = k log 2
k = log n / log 2 = 2log n
sehingga
T(n) = 2log n + T(1)

= 2log n + 1 + T(0)
= 2log n + 1 + 0
= 2log n + 1
= O (2log n)
98
Perkalian Matriks
• Misalkan A dan B dua buah matrik berukuran n
 n.
• Perkalian matriks: C = A × B
n
Elemen-elemen hasilnya: cij  ai1b1 j  ai 2 b2 j    ainbnj   aik bkj
k 1
99
function KaliMatriks1(input A,B: Matriks, input n : integer) Matriks

{ Memberikan hasil kali matriks A dan B yang berukuran n × n.
Masukan: matriks integer A dan B, ukuran matriks (n)
Keluaran: matriks C = A  B.
}
Deklarasi
i, j, k : integer
C : Matriks
Algoritma:
for i1 to n do
for j1 to n do
Ci,j0 { inisialisasi penjumlah }
for k  1 to n do
Ci,j  Ci,j + Ai,k * Bk,j
endfor
endfor
endfor
return C
Kompleksitas algoritma: T(n) = n3 + n3 = O(n3).

100
Penyelesaian dengan Algoritma Divide and Conquer
Matriks A dan B dibagi menjadi 4 buah matriks bujur sangkar.

Masing-masing matriks bujur sangkar berukuran n/2  n/2:
 A11 A12  B11 B12  C11 C12

 A21 A22   B21 B22 = C 21 C 22
     
A B C
Elemen-elemen matriks C adalah:
C11 = A11  B11 + A12  B21

C12 = A11  B12 + A12  B22
C21 = A21  B11 + A22  B21
C22 = A21  B12 + A22  B22
101
Contoh 4.7. Misalkan matriks A adalah sebagai berikut:
3 4 8 16 
 21 5 12 10 
A=  
5 1 2 3
45 9 0 1

Matriks A dibagi menjadi 4 upa-matriks 2 x 2:
 3 4  8 16  5 1 2 3 
A11 =   A12 = 12 10 A21 = 45 9 A22 = 0  1
21 5      
102
function KaliMatriks2(input A,B: Matriks, input n : integer)  Matriks
{ Memberikan hasil kali matriks A dan B yang berukuran n × n.
Keluaran: matriks C = A  B.
}
Deklarasi
i, j, k : integer
A11, A12, A21, A22,
B11, B12, B21, B22,
C11, C12, C21, C22 : Matriks
Algoritma:
if n = 1 then
return A  B { perkalian biasa }
else
Bagi A menjadi A11, A12, A21, dan A22 yang masing-masing
berukuran n/2  n/2
Bagi B menjadi B11, B12, B21, dan B22 yang masing-masing
berukuran n/2  n/2
C11  KaliMatriks2(A11, B11, n/2) + KaliMatriks2(A12, B21, n/2)
return C { C adalah gabungan C11, C12, C13, C14 }
endif
103
Pseudo-code algoritma penjumlahan (+), C = A + B:
function Tambah(input A, B : Matriks, input n : integer)  Matriks

{ Memberikan hasil penjumlahkan dua buah matriks, A dan B, yang
berukuran n × n.
Keluaran: matriks C = A + B
}
Deklarasi
i, j, k : integer
Algoritma:
for i1 to n do
for j1 to n do
C i,j  A i,j + B i,j
endfor
endfor
return C
104
Kompleksitas waktu perkalian matriks seluruhnya adalah:
 a ,n  1
T (n)  
8T ( n / 2 )  cn 2
,n  1
yang bila diselesaikan, hasilnya adalah:
T(n) = O(n3)
Hasil ini tidak memberi perbaikan kompleksitas dibandingkan

dengan algoritma brute force.
Dapatkah kita membuat algoritma perkalian matriks yang lebih

baik?
105
Algoritma Perkalian Matriks Strassen
Hitung matriks antara:
M1 = (A12 – A22)(B21 + B22)
M2 = (A11 + A22)(B11 + B22)
M3 = (A11 – A21)(B11 + B12)
M4 = (A11 + A12)B22
M5 = A11 (B12 – B22)
M6 = A22 (B21 – B11)
M7 = (A21 + A22)B11
maka,
C11 = M1 + M2 – M4 + M6
C12 = M4 + M5
C21 = M6 + M7
C22 = M2 – M3 + M5 – M7 106
• Volker Strassen (born April
29, 1936) is a German
mathematician, a professor
emeritus in the department of
mathematics and statistics at
the University of Konstanz.
• In 2008 he was awarded the Knuth Prize for "seminal and

influential contributions to the design and analysis of
efficient algorithms."[5]
107
Kompleksitas waktu algoritma perkalian matriks Strassen:
 a ,n  1
T (n)  
7T ( n / 2 )  cn 2
,n  1
yang bila diselesaikan, hasilnya adalah
log 7 2.81
T(n) = O(n ) = O(n )
108
Perkalian Dua Buah Bilangan
Bulat yang Besar
Persoalan: Misalkan bilangan bulat X dan Y
yang panjangnya n angka
X = x1x2x3 … xn
Y = y1y2y3… yn
Hitunglah hasil kali X dengan Y.

109
Contoh 4.8. Misalkan,
X = 1234 (n = 4)
Y = 5678 (n = 4)
Cara klasik mengalikan X dan Y:
X  Y = 1234
5678 
9872
8368
7404
6170 +
7006652 ( 7 angka)
110
Pseudo-code algoritma perkalian matriks:
function Kali1(input X, Y : LongInteger, n : integer)  LongInteger

{ Mengalikan X dan Y, masing-masing panjangnya n digit dengan algoritma
brute force.
Masukan: X dan Y yang panjangnya n angka
Keluaran: hasil perkalian
}
Deklarasi
temp, AngkaSatuan, AngkaPuluhan : integer
Algoritma:
for setiap angka yi dari yn, yn-1, …, y1 do
AngkaPuluhan  0
for setiap angka xj dari xn, xn-1, …, x1 do
temp  xj * yi
temp  temp + AngkaPuluhan
AngkaSatuan  temp mod 10
AngkaPuluhan  temp div 10
tuliskan AngkaSatuan
endfor
endfor
Z  Jumlahkan semua hasil perkalian dari atas ke bawah
return Z
Kompleksitas algoritma: O(n2). 111

Penyelesaian dengan Algoritma Divide and Conquer
n
X a b
Y c d
n/2 n/2
s = n div 2
a = X div 10s
b = X mod 10s
c = Y div 10s
d = Y mod 10s
X dan Y dapat dinyatakan dalam a, b, c, d, dan s sebagai
X = a  10s + b
Y = c  10s + d 112
Contoh,
X = 346769 = 346  10 + 769

3
Y = 279431 = 279  103 + 431
Perkalian X dengan Y dinyatakan sebagai
X  Y = (a  10s + b)  (c  10s + d)
= ac  102s + ad  10s + bc  10s + bd
= ac  102s + (ad + bc)  10s + bd
113
Pseudo-code perkalian X dan Y:

Divide and Conquer.
Masukan: X dan Y
Keluaran: hasil perkalian X dan Y
}
Deklarasi
a, b, c, d : LongInteger
s : integer
Algoritma:
if n = 1 then
return X * Y { perkalian biasa }
else
sn div 2 { bagidua pada posisi s }
aX div 10s
bX mod 10s
c Y div 10s
d Y mod 10s
return Kali2(a, c, s)*102s + Kali2(b, c, s)*10s +
Kali2(a, d, s)*10s + Kali2(b, d, s)
endif
 a ,n  1
T (n)  
4T (n / 2)  cn , n  1
114
• Penyelesaian:
T(n) = O(n2).
• Ternyata, perkalian dengan algoritma Divide

and Conquer seperti di atas belum
memperbaiki kompleksitas waktu algoritma
perkalian secara brute force.
• Adakah algoritma perkalian yang lebih baik?
115
Perbaikan (A.A Karatsuba, 1962):
Misalkan
r = (a + b)(c + d) = ac + (ad + bc) + bd
maka,
(ad + bc) = r – ac – bd = (a + b)(c + d) – ac – bd
Dengan demikian, perkalian X dan Y dimanipulasi menjadi
X  Y = ac  102s + (ad + bc)  10s + bd
 ac
  102s
 {( a  b)( c  d )  ac
  bd }  10s
 bd

p
     p q q
r
116
Anatolii Alexevich Karatsuba
Anatolii Alexeevitch Karatsuba (Russian: Анато́лий

Алексе́евич Карацу́ба; Grozny, January 31, 1937 — Moscow,
September 28, 2008) was a Russian mathematician, who
authored the first fast multiplication method: the Karatsuba
algorithm, a fast procedure for multiplying large numbers.
(Sumber: Wikipedia) 117
Divide and Conquer.
Masukan: X dan Y
Keluaran: hasil perkalian X dan Y
}
Deklarasi
a, b, c, d : LongInteger
s : integer
Algoritma:
if n = 1 then
return X * Y { perkalian biasa }
else
sn div 2 { bagidua pada posisi s }
aX div 10s
bX mod 10s
c Y div 10s
d Y mod 10s
pKali3(a, c, s)
qKali3(b, d, s)
rKali3(a + b, c + d, s)
return p*102s + (r – p – q)*10s + q
endif
118
Kompleksitas waktu algoritmanya:
T(n) = waktu perkalian integer yang berukuran n/2 +

waktu untuk perkalian dengan 10s dan 102s dan waktu
untuk penjumlahan
 a ,n  1
T (n)  
3T (n / 2)  cn , n  1
Bila relasi rekurens diselesaikan, diperoleh T(n) = O(nlog 3) =

O(n1.59), lebih baik daripada kompleksitas waktu dua algoritma
perkalian sebelumnya.
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
Aplikasi Divide and Conquer pada:
1. Grafika Komputer
2. Evaluasi expression tree
Oleh: Rinaldi Munir

Informatika STEI-ITB
Bezier Curve
• Bezier Curve adalah kurva yang sering digunakan
dalam grafika komputer (computer graphics).
• Dalam grafik vektor, Bezier curves digunakan untuk

memodelkan kurva mulus.
• Kurva Bézier dipublikasikan secara luas pada tahun

1962 oleh insinyur Pierre Bézier Perancis, yang
menggunakannya untuk merancang badan mobil.
Pemodelan Kurva Bezier
• Sebuah kurva Bézier didefinisikan oleh satu set titik kontrol P0
sampai Pn, n disebut order (n = 1 untuk linier, 2 kuadrat, dll).
• Titik kontrol pertama dan terakhir selalu titik akhir dari kurva,
namun, titik kontrol antara (jika ada) umumnya tidak terletak
pada kurva.
Kurva Linier
• Diberikan titik P0 dan P1, kurva Bézier linear adalah sebuah
garis lurus antara dua titik. Kurva diberikan oleh:
• t dalam fungsi kurva Bézier linier menggambarkan seberapa

jauh B (t) dari P0 ke P1. Misalnya ketika t = 0,25, B (t) adalah
seperempat dari jalan dari titik P0 ke P1. Seperti t bervariasi
dari 0 ke 1, B (t) menggambarkan garis lurus dari P0 ke P1.
Kurva Kuadratik
• Diberikan poin yang diberikan P0, P1, P2 , kurva Bézier kuadrat
adalah lintasan yang dilalui oleh fungsi B (t),
• yang dapat diartikan sebagai interpolasi linear dari titik yang

sesuai pada kurva Bézier linier dari P0 ke P1 dan dari P1 ke P2.
• Penyederhanaan:
• Untuk kurva Bézier kuadratik perlu dibangun titik antara (Q0
dan Q1 sebagaimana t bervariasi dari 0 sampai 1:
(i) Titik Q0 bervariasi dari P0 ke P1  kurva Bezier linier.

(ii) Titik Q1 bervariasi dari P1 ke P2  kurva Bézier linier.
(iii) Titik B (t) bervariasi dari Q0 ke Q1  kurva Bézier kuadrat.
Kurva Bezier Orde Lebih Tinggi
Orde 3:
Orde 4:
Aplikasi Divide and Conquer
• Ada banyak cara membentuk kurva Bezier.
• Cara sederhana adalah menggunakan algoritma titik

tengah yang berbasis divide and conquer.
• Pada contoh ini diperlihatkan cara mebentuk kurva

Bezier kuadratik dengan algoritma titik tengah
berbasis divide and conquer.
• Kurva Bezier curve dimulai dengan tiga titik yang bisa di-set
secara manual.
• Hitung titik tengah setiap garis yang terletak di antara tiga titik
awal. Titik-titik pertengahan baru dihitung ditampilkan dalam
warna hijau.
• Titik-titik yang mengubah warna menjadi biru akan berada di

kurva Bezier akhir.
private void PopulateBezierPoints(PointF ctrl1, PointF ctrl2,
PointF ctrl3, int currentIteration)
{
if (currentIteration < iterations) { //calculate next mid points
PointF midPoint1 = MidPoint(ctrl1, ctrl2);
PointF midPoint2 = MidPoint(ctrl2, ctrl3);
PointF midPoint3 = MidPoint(midPoint1, midPoint2); //the next
control point
currentIteration++;
PopulateBezierPoints(ctrl1, midPoint1, midPoint3, currentIteration);
//left branch
bezierPoints.Add(midPoint3); //add the next control point
PopulateBezierPoints(midPoint3, midPoint2, ctrl3, currentIteration);
//right branch }
}
private PointF MidPoint(PointF controlPoint1, PointF controlPoint2)
{
return new PointF(
(controlPoint1.X + controlPoint2.X) / 2,
(controlPoint1.Y + controlPoint2.Y) / 2 );
}
private void CreateBezier(PointF ctrl1, PointF ctrl2, PointF
ctrl3)
{
bezierPoints = new List<PointF>();
bezierPoints.Clear();
bezierPoints.Add(ctrl1); // add the first control point
PopulateBezierPoints(ctrl1, ctrl2, ctrl3, 0);
bezierPoints.Add(ctrl3); // add the last control point
}
• Kurva Bezier dengan empat titik control:
Sumber:
1. http://www.codeproject.com/Articles/22315
9/Midpoint-Algorithm-Divide-and-Conquer-
Method-for-D
2. http://en.wikipedia.org/wiki/Bezier_curve
Expression Tree
• Di dalam compiler bahasa pemrograman, ekspresi aritmetika
direpresentasikan dalam pohon biner yaitu expression tree
• Contoh: (5 + z) / -8) * (4 ^ 2)
Sumber gambar: Wikipedia.org

Mengevaluasi Expression Tree
• Simpul daun  operand
• Simpul dalam  operator (+, -, *, /)
• Struktur data pohon:
• Pada simpul daun  left = NIL dan right = NIL

• Algoritma divide and conquer:
If node adalah simpul daun

return nilainya
else
secara rekursif evaluasi upa-pohon kiri dan return nilainya
secara rekursif evaluasi upa-pohon kanan dan return nilainya
lakukan operasi yang bersesuaian dengan operator dan return
nilainya
procedure Evaluasi(input T : Pohon, output nilai : integer)
Algoritma:
if left(T) = NIL and right(T) = NIL { simpul daun}
nilai  item(T)
else { simpul dalam }
Evaluasi(left(T), nilai1);
Evaluasi(right(T), nilai2);
case item(T) of
“+” : nilai  nilai1 + nilai2
“-” : nilai  nilai1 - nilai2
“*” : nilai  nilai1 * nilai2
“/” : nilai  nilai / nilai2
end
end
function Evaluasi(T : Pohon)  integer
Algoritma:
if left(T) = NIL and right(T) = NIL { simpul daun}
return item(T)
else { simpul dalam }
case item(T) of
“+” : return Evaluasi(left(T)) + Evaluasi(right(T))
“-” : return Evaluasi(left(T)) - Evaluasi(right(T))
“*” : return Evaluasi(left(T)) * Evaluasi(right(T))
“/” : return Evaluasi(left(T)) / Evaluasi(right(T))
end
end
Program Studi Informatika – STEI ITB

Algoritma Branch & Bound (B&B)
• Digunakan untuk persoalan optimisasi → meminimalkan
atau memaksimalkan suatu fungsi objektif, yang tidak
melanggar batasan (constraints) persoalan
• B&B: BFS + least cost search
– BFS murni: Simpul berikutnya yang akan diekspansi
berdasarkan urutan pembangkitannya (FIFO)
• B&B:
– Setiap simpul diberi sebuah nilai cost:
ĉ(i) = nilai taksiran lintasan termurah ke simpul status
tujuan yang melalui simpul status i.
– Simpul berikutnya yang akan di-expand tidak lagi
berdasarkan urutan pembangkitannya, tetapi simpul yang
memiliki cost yang paling kecil (least cost search) – pada
kasus minimasi.
Algoritma Global Branch & Bound
1. Masukkan simpul akar ke dalam antrian Q. Jika simpul akar adalah
simpul solusi (goal node), maka solusi telah ditemukan. Stop.
2. Jika Q kosong, tidak ada solusi. Stop.
3. Jika Q tidak kosong, pilih dari antrian Q simpul i yang mempunyai
nilai ‘cost’ ĉ(i) paling kecil. Jika terdapat beberapa simpul i yang
memenuhi, pilih satu secara sembarang.
4. Jika simpul i adalah simpul solusi, berarti solusi sudah ditemukan,
stop. Jika simpul i bukan simpul solusi, maka bangkitkan semua
anak-anaknya. Jika i tidak mempunyai anak, kembali ke langkah
2.
5. Untuk setiap anak j dari simpul i, hitung ĉ(j), dan masukkan
semua anak-anak tersebut ke dalam Q.
6. Kembali ke langkah 2.
Permainan 15-Puzzle

• Aksi: up, down, left, right
Pohon Ruang Status untuk 15-Puzzle
Pohon ruang status B&B ketika jalur ke solusi sudah ‘diketahui’

Cost dari Simpul Hidup (2)
• Pada umumnya, untuk kebanyakan persoalan,
letak simpul solusi tidak diketahui.
• Cost setiap simpul umumnya berupa taksiran.
• Cost simpul P pada 15-puzzle:
Cost dari Simpul Hidup 15-Puzzle
Target
C(2)=1+4=5 C(3)=1+4=5 C(4)=1+2=3 C(5)=1+4=5
15-Puzzle dengan Branch & Bound

1 4,2,3,5
4 10,2,3,5,11,12
10 23,2,3,5,11,12,22
23 Solusi ketemu
Travelling Salesperson Problem
Persoalan: Diberikan n
buah kota serta diketahui
jarak antara setiap kota
satu sama lain. Temukan
perjalanan (tour)
terpendek yang melalui
setiap kota lainnya hanya
sekali dan kembali lagi ke
kota asal keberangkatan.
(n-1)! sirkuit hamilton
Pohon Ruang Status TSP 4 Simpul
A=1; B=2; C=3; D=4

Simpul awal=1
Solusi: 1-3-2-4-1 atau 1-4-2-3-1
Bobot=5+8+9+10=32
(lihat diktat: TSP-Brute Force hal 20)
TSP dengan B & B
Contoh lain TSP 5 simpul (matriks bobot/cost matrix):
Brute Force:
- 4!=24 sirkuit hamilton
- Solusi: 1-4-2-5-3-1
- Bobot: 10+6+2+7+3=28
Greedy:
- Solusi: 1-4-5-2-3-1 B&B-TSP dgn Reduced Cost Matrix
- Bobot: 10+3+4+16+3=36 X0=X5=1
Cost dari Simpul Hidup TSP
1. Matriks ongkos-tereduksi (reduced cost
matrix) dari graf
– Sebuah matriks dikatakan tereduksi jika setiap
kolom dan barisnya mengandung paling sedikit
satu buah nol dan semua elemen lainnya non-
negatif.
– Batas (bound): Jumlah total elemen pengurang
dari semua baris dan kolom merupakan batas
bawah dari total bobot minimum tur. (hal 159)
2. Bobot minimum tur lengkap
Reduced Cost Matrix: Contoh
R A
Reduksi baris
dan kolom
Setiap kolom dan barisnya

mengandung paling sedikit
satu buah nol dan semua
elemen lainnya non-negatif
Reduced Cost Matrix
Total semua pengurang = 10 + 2 + 2 + 3 + 4 + 1 + 3 = 25 Cost simpul akar

• Misalkan:
– A: matriks tereduksi untuk simpul R.
– S: anak dari simpul R sehingga sisi (R, S) pada pohon ruang status
berkoresponden dengan sisi (i, j) pada perjalanan.
• Jika S bukan simpul daun, maka matriks bobot tereduksi untuk
simpul S dapat dihitung sebagai berikut:
– (a) ubah semua nilai pada baris i dan kolom j menjadi . Ini untuk
mencegah agar tidak ada lintasan yang keluar dari simpul i atau masuk
pada simpul j;
– (b) ubah A(j, 1) menjadi . Ini untuk mencegah penggunaan sisi (j, 1);
– (c) reduksi kembali semua baris dan kolom pada matriks A kecuali
untuk elemen .
– Jika r adalah total semua pengurang, maka nilai batas untuk simpul S
adalah:
– Hasil reduksi ini menghasilkan matriks B.

• Misalkan:
A: matriks tereduksi untuk simpul R.
Simpul awal (R) = 1
R A
R1-10; R2-2; R3-2; R4-3; R5-4;

C1-1; C3-3
S: anak dari simpul R sehingga sisi (R, S) pada pohon ruang

status berkoresponden dengan sisi (i, j) pada perjalanan.
S  {2,3,4,5}
• A: matriks tereduksi R; S: anak dari simpul R
• Jika S bukan simpul daun, maka matriks bobot tereduksi untuk simpul S
dapat dihitung sebagai berikut (dari slide 32):
– (a) ubah semua nilai pada baris i dan kolom j menjadi . Ini untuk mencegah
agar tidak ada lintasan yang keluar dari simpul i atau masuk pada simpul j;
– (b) ubah A(j, 1) menjadi . Ini untuk mencegah penggunaan sisi (j, 1)
– (c) reduksi kembali semua baris dan kolom pada matriks A kecuali untuk
elemen .
Contoh: R=1; S=2 (bukan daun)
A Kolom j
Baris i
(a), (b) (c): tetap

Taksiran Cost dgn Reduced Cost Matrix
ĉ(S):
(a) bobot perjalanan dari akar ke S
(jika S daun)
(b) Bobot perjalanan minimum
yang melalui simpul S (jika S
bukan daun)
ĉ(akar)=r
ĉ(1)=25
R=1
A S=4
Sisi (1,4) yang sedang diperiksa, maka:
cˆ(4) = cˆ(1) + A(1,4) + r = 25 + 0 + 0 = 25
R A
X1=5
X1=2 X1=3 X1=4
ĉ(2)=35 ĉ(3)=53 ĉ(4)=25 ĉ(5)=31

Simpul-E=1 → Simpul hidup={4,5,2,3}
R A
X1=5
X1=2 X1=3 X1=4
Simpul-E=1 → Simpul hidup={4,5,2,3}

Solusi: 1,4,2,5,3,1
Bobot: 28
ĉ(10)=28
ĉ(11)=28
1 4,5,2,3
4 6,5,2,8,7,3
6 10,5,2,8,7,9,3
10 11,5,2,8,7,9,3
11 daun
Semua simpul hidup yang nilainya lebih besar

dari 28 dibunuh (B) karena tidak mungkin lagi
menghasilkan perjalanan dengan bobot < 28.
Karena tidak ada lagi simpul hidup di dalam

pohon ruang status, maka X = (1, 4, 2, 5, 3, 1)
menjadi solusi persoalan TSP di atas dengan
bobot 28.
SELAMAT BELAJAR
(Bagian 2)
Program Studi Informatika – STEI ITB

TSP (lanjutan)
• Pada pembahasan TSP sebelumnya, cost setiap simpul i dihitung
sebagai penjumlahan ongkos dari simpul akar ke simpul i, dan ongkos
dari simpul i ke simpul tujuan (goal).
c(S) = c(R) + {A(i,j) + r}

c(R) = cost simpul orangtua dari simpul S
g(i) = A(i, j) + r
• Terdapat pendekatan heuristik lain dalam menghitung nilai cost untuk

setiap simpul berdasarkan bobot tur lengkap.
Bobot Tur Lengkap (tur dimulai dari a)
12
Tour lengkap:
a,c,d,b,a
Solusi: (a,i2,i3,i4,a)
Hasil pengamatan:
Cost Simpul Akar
12
a b c d
Contoh untuk menghitung cost simpul 2:
Untuk i2=b, sisi (a, b) wajib diambil.
12 a b c d
32
a b c d

34.5
a b c d
32 32 a b c d
32

Untuk i3=b, sisi (a, c) dan sisi (c, b) wajib diambil.
12

Sisi (a, c), (c, b), dan (b, d) wajib diambil.
12
Cost  1/2 [(10 + 5) + (8 + 9) + (10 + 9) + (5 + 8) = 32
12
Latihan 1
• (TSP) Diberikan sebuah graf lengkap dengan 4
simpul yang dinyatakan dengan matriks berbobot
sebagai berikut:
 2 7 8 
6  3 7
• Simpul diberi nomor 1, 2, 3, dan 4. Jika tur dimulai C =  
dari simpul 3 , tentukan tur TSP dengan bobot 5 8  4
minimum (dari 3 kembali ke 3 melalui simpul yang  
lain tepat sekali). Selesaikan persoalan ini dengan
 7 6 9 
algoritma branch and bound. Bound atau cost
dihitung dengan matriks ongkos tereduksi
(reduced cost matices). Tuliskan jawaban anda
dengan menggambarkan pohon ruang status
beserta nilai bound untuk setiap simpul, solusi
dalam bentuk vektor X dan total bobot.
Penyelesaian:
Latihan 2:
• (Assignment Problem) Misalkan terdapat 4 orang
orang dan 4 buah pekerjaan (job). Setiap orang
akan di-assign dengan sebuah job. Ongkos (cost)
untuk meng-assign setiap orang dengan sebuah
job dinyatakan dengan sebuah matriks di  Job 1 Job 2 Job 3 Job 4
 9 8  Orang a
samping ini.  2 7
C= 6 7  Orang b
• Bagaimana meng-assign job dengan orang 
4 3

sehingga total ongkos assignment seminimal  5 8 1 4  Orang c
mungkin? Selesaikan persoalan ini dengan  7 6 9 4  Orang d
algoritma branch and bound. Bound dihitung
dengan matriks ongkos tereduksi (reduced cost
matices). Gambarkan juga proses pembentukan
pohon ruang statusnya sampai menemukan
solusi.
Latihan 3:
• Persoalan 1/0 Knapsack
• Kapasitas knapsack : 10
• Dengan B&B:
• Bagaimana pencabangan pohon?
Petunjuk: setiap item → diikutsertakan atau tidak?
• Bagaimana pengurutan item pada aras pohon?
Petunjuk: ingat Greedy, bagaimana pengurutan yang memberikan
keuntungan optimal?
• Perlu batas bawah, atau batas atas?
Petunjuk: tujuan meminimalkan atau memaksimalkan?
Nilai apa yang dioptimasi?
• Fungsi batas (bounding function) setiap simpul ?
Selamat Belajar
Program Dinamis
(Dynamic Programming)
Bagian 1

STEI-ITB
1
Program Dinamis
• Program Dinamis (dynamic programming):
- metode pemecahan masalah dengan cara menguraikan solusi
menjadi sekumpulan tahapan (stage)
- sedemikian sehingga solusi persoalan dapat dipandang sebagai
serangkaian keputusan yang saling berkaitan.
• Kata “program” tidak ada kaitannya dengan pemrograman

• Istilah “dinamis” muncul karena pencarian solusinya melakukan
perhitungan dengan menggunakan tabel (yang dapat
berkembang)
2
• Program dinamis digunakan untuk menyelesaikan persoalan-
persoalan optimasi (maksimasi atau minimisasi)
• Perbedaan Algoritma Greedy dengan Program Dinamis:

→ Greedy: hanya satu rangkaian keputusan yang dihasilkan
→ Program dinamis: lebih dari satu rangkaian keputusan yang

dipertimbangkan.
3
Tinjau graf di bawah ini. Kita ingin menemukan lintasan terpendek dari 1
ke 10.
7
2 5
1
2 4 3 4
6 8 3
6
4
1 3 2 6 3 10
3 9 4
4
3 1
4
3
4 7
5
Greedy: dari setiap simpul, ambil sisi dengan bobot terkecil ke simpul berikutnya
Solusi greedy: 1 – 2 – 6 – 9 – 10 dengan cost = 2 + 4 + 3 + 4 = 13 → tidak optimal!
4
Prinsip Optimalitas
• Pada program dinamis, rangkaian keputusan yang optimal dibuat
dengan menggunakan Prinsip Optimalitas.
• Prinsip Optimalitas: jika solusi total optimal, maka bagian solusi

sampai tahap ke-k juga optimal.
• Prinsip optimalitas berarti bahwa jika kita bekerja dari tahap k ke

tahap k + 1, kita dapat menggunakan hasil optimal dari tahap k tanpa
harus kembali ke tahap awal.
5
• Ongkos pada tahap k +1 = (ongkos yang dihasilkan pada tahap k ) +
(ongkos dari tahap k ke tahap k + 1, atau ck ,k +1 )
ck , k +1
……
1 2 k k +1 …… n
Ongkos sampai tahak k
Ongkos sampai tahap k+1
6
Karakteristik Persoalan dengan Program Dinamis
1. Persoalan dapat dibagi menjadi beberapa tahap (stage), yang pada

setiap tahap hanya diambil satu keputusan.
2. Masing-masing tahap terdiri dari sejumlah status (state) yang

berhubungan dengan tahap tersebut. Secara umum, status
merupakan bermacam kemungkinan masukan yang ada pada suatu
tahap.
7
Graf multitahap (multistage graph). Tiap simpul di dalam graf tersebut
menyatakan status, sedangkan V1, V2, … menyatakan tahap.
V1 V2 V3 V4 V5
9
6
7 10 12
1
4
8
11
8
3. Hasil dari keputusan yang diambil pada setiap tahap ditransformasikan
dari status yang bersangkutan ke status berikutnya pada tahap
berikutnya.
4. Ongkos (cost) pada suatu tahap meningkat secara teratur (steadily)

dengan bertambahnya jumlah tahapan.
5. Ongkos pada suatu tahap bergantung pada ongkos tahap-tahap yang

sudah berjalan dan onkos dari tahap tersebut ke tahap berikutnya.
6. Adanya hubungan rekursif yang mengidentifikasikan keputusan terbaik

untuk setiap status pada tahap k memberikan keputusan terbaik untuk
setiap status pada tahap k + 1.
7. Prinsip optimalitas berlaku pada persoalan tersebut.

9
Dua pendekatan PD
Dua pendekatan yang digunakan dalam program dinamis:
1. Program dinamis maju (forward atau up-down)
→ Perhitungan dilakukan dari tahap 1, 2, …, n – 1, n
2. Program dinamis mundur (backward atau bottom-up)

→ Perhitungan dilakukan dari tahap n, n – 1, …, 2, 1.
10
Misalkan x1, x2, …, xn menyatakan peubah (variable) keputusan yang
harus ditentukan masing-masing untuk tahap 1, 2, …, n. Maka,
1. Program dinamis maju. Program dinamis bergerak mulai dari
tahap 1, terus maju ke tahap 2, 3, dan seterusnya sampai tahap n.
Rangkaian peubah keputusan adalah x1, x2, …, xn.
2. Program dinamis mundur. Program dinamis bergerak mulai dari

tahap n, terus mundur ke tahap n – 1, n – 2, dan seterusnya
sampai tahap 1.
Rangkaian peubah keputusan adalah xn, xn-1, …, x1.
11
Langkah-langkah Pengembangan Algoritma
Program Dinamis
1. Karakteristikkan struktur solusi optimal.
- tahap, variable keputusan, status (state), dsb
2. Definisikan secara rekursif nilai solusi optimal.
- hubungan nilai optimal suatu tahap dengan tahap sebelumnya
3. Hitung nilai solusi optimal secara maju atau mundur.
- menggunakan tabel
4. Rekonstruksi solusi optimal (opsional).
- rekonstruksi solusi secara mundur
12
Persoalan 1: Lintasan Terpendek (Shortest Path)
• Tentukan lintasan terpendek dari simpul 1 ke simpul 10:
7
2 5
1
2 4 3 4
6 8 3
6
4
1 3 2 6 3 10
3 9 4
4
3 1
4
3
4 7
5
13
How to find the shortest path? 14
(a) Karakteristikkan struktur solusi optimal
• Misalkan x1, x2, x3, x4 adalah simpul-simpul yang dikunjungi pada tahap k
(k = 1, 2, 3, 4). Tahap 5 tidak ada karena x5=10
• Misalkan digunakan pendekatan program dinamis maju
• Maka rute yang dilalui adalah x1→x2→x3→x4 → x5=10
Pada persoalan ini,

• Tahap (k) adalah proses memilih simpul tujuan berikutnya (ada 4 tahap).
• Status (s) yang berhubungan dengan masing-masing tahap adalah simpul-

simpul di dalam graf multi-tahap.
15
Tahap 1 Tahap 2 Tahap 3 Tahap 4
7
2 5
1
2 4 3 4
6 8 3
6
4
1 3 2 6 3 10
3 9 4
4
3 1
4
3
4 7
5
x1 x2 x3 x4 x5=10
(b) Definisikan hubungan rekursif solusi optimal
Relasi rekurens berikut menyatakan lintasan terpendek pada setiap tahap:
f1(s) = cx1,s (basis)

fk(s) = min {fk – 1(xk) + cxk,s } (rekurens)
k = 2, 3, 4
Keterangan:
a. xk : peubah keputusan pada tahap k (k = 2, 3, 4).
b. s : status pada setiap tahap
c. cxk,s : bobot (cost) sisi dari ke xk ke s
d. fk(s) : nilai minimum dari fk(xk, s)
e. fk – 1(xk) : nilai minimum tahap sebelumnya dari xk ke s
(c )Hitung nilai solusi optimal
Tahap 1:
f1 (s) = cx1s
Solusi Optimum
s f1(s) x1*
2 2 1
3 4 1 f1(s) = cx1,s
4 3 1
Catatan: xk* adalah nilai xk yang meminimumkan fs.
18
Tahap sebelumnya (Tahap 1)
Tahap 2:
𝑓2 (𝑠) = 𝑚𝑖𝑛{𝑓1 (𝑥2 ) + }
𝑥2
x2 f2(s) = f1(x2) + cx2,s Solusi Optimum

s 2 3 4 f2(s) x2*
5 9 7 7 7 3 atau 4
6 6 6 4 4 4
7 8 8 8 8 2, 3, 4
fk(s) = min {fk – 1(xk) + cxk,s } 19
20
f (s) = min {f (x ) + c }
Tahap 4:
𝑓4 (𝑠) = 𝑚𝑖𝑛{𝑓3 (𝑥4 ) + }
𝑥4
x4 f4(s) = f3(x4)+ cx4,s Solusi Optimum

s 8 9 f4(s) x4*
10 11 11 11 8 atau 9
fk(s) = min {fk – 1(xk) + cxk,s } 21
Tahap 2:
(d) Rekonstruksi solusi optimal 𝑓2 (𝑠) = 𝑚𝑖𝑛{𝑓1 (𝑥2 ) + }
𝑥2
Solusi optimum dapat dibaca pada tabel di bawah ini: x2 f2(s) = f1(x2) + cx2,s Solusi Optimum
s 2 3 4 f2(s) x2*
x4 x3 x2 x1 Panjang Lintasan Terpendek 5 9 7 7 7 3 atau 4
6 6 6 4 4 4
8 5 3 1 11 7 8 8 8 8 2, 3, 4
4
10
9 6 4 1 11
Jadi ada tiga lintasan terpendek dari 1 ke 10, yaitu

1 → 3 → 5 → 8 → 10
1 → 4 → 5 → 8 → 10
1 → 4 → 6 → 9 → 10
yang mana panjang ketiga lintasan tersebut sama, yaitu 11. 22
Latihan
1. Selesaikan persoalan shortest path tersebut dengan program dinamis mundur.
2. Carilah lintasan terpendek dari 1 ke 6 pada graf (a) dan dari d ke k pada graf (b):
(a) (b)
Persoalan 2: Integer Knapsack
Diberikan sebuah knapsack dengan
kapasitas M. Terdapat n buah objek, setiap
objek memiliki bobot wi dan keuntungan pi.
dimasukkan ke dalam knapsack sehingga
total keuntungan yang diperoleh maksimal.
24
Contoh: n = 3
M=5
Barang ke-i wi pi
1 2 65
2 3 80
3 1 30
• Pada persoalan ini,
1. Tahap (k) adalah proses memasukkan objek ke dalam knapsack
(knapsack) (pada contoh di atas ada 3 tahap).
2. Status (y) menyatakan kapasitas muat knapsack yang tersisa setelah

memasukkan objek pada tahap sebelumnya.
• Dari tahap ke-1, kita masukkan objek ke-1 ke dalam knapsack untuk
setiap satuan kapasitas knapsack sampai batas kapasitas maksimumnya.
• Karena kapasitas knapsack adalah bilangan bulat, maka pendekatan ini

praktis.
• Misalkan ketika memasukkan objek pada tahap k, kapasitas muat
knapsack sekarang adalah y – wk.
• Untuk mengisi kapasitas sisanya, kita menerapkan prinsip

optimalitas dengan mengacu pada nilai optimum dari tahap
sebelumnya untuk kapasitas sisa y – wk
• Nilai optimum pada tahpa sebelumnya adalah fk-1(y – wk).
27
• Selanjutnya, kita bandingkan:
nilai keuntungan pengisian pada tahap k (yaitu pk) + nilai fk-1(y – wk)
dengan
keuntungan pengisian hanya k – 1 objek, fk-1(y).
• Jika pk + fk-1(y – wk) lebih kecil dari fk-1(y), maka objek yang ke-k tidak
dimasukkan ke dalam knapsack,
tetapi jika pk + fk-1(y – wk) lebih besar dari fk-1(y), maka objek yang ke-k
dimasukkan.
28
• Relasi rekurens untuk persoalan ini adalah
f0(y) = 0, y = 0, 1, 2, …, M (basis)
fk(y) = -, y < 0 (basis)
fk(y) = max{fk-1(y), pk + fk-1(y – wk)}, (rekurens)

k = 1, 2, …, n
• fk(y) adalah keuntungan optimum pada tahap k untuk kapasitas knapsack sebesar y.
• f0(y) = 0 adalah nilai persoalan knapsack kosong (tidak ada persoalan knapsack)
dengan kapasitas y)
• fk(y) = - adalah nilai persoalan knapsack untuk kapasitas negatif.

• Solusi optimum dari persoalan knapsack adalah fn(M).
29
Tahap 1:
f1(y) = max{f0(y), p1 + f0(y – w1)}
= max{f0(y), 65 + f0(y – 2)}
Solusi Optimum
y f0(y) 65 + f0(y – 2) f1(y) (x1*, x2*, x3*)
0 0 - 0 (0, 0, 0)
1 0 - 0 (0, 0, 0)
2 0 65 65 (1, 0, 0)
3 0 65 65 (1, 0, 0)
4 0 65 65 (1, 0, 0)
5 0 65 65 (1, 0, 0)
30
Tahap 2:
f2(y) = max{f1(y), p2 + f1(y – w2)}
= max{f1(y), 80 + f1(y – 3)}
Solusi Optimum
y f1(y) 80 + f1(y – 3) f2(y) (x1*, x2*, x3*)
0 0 80 + (-) = - 0 (0, 0, 0)
1 0 80 + (-) = - 0 (0, 0, 0)
2 65 80 + (-) = - 65 (1, 0, 0)
3 65 80 + 0 = 80 80 (0, 1, 0)
4 65 80 + 0 = 80 80 (0, 1, 0)
5 65 80 + 65 = 145 145 (1, 1, 0)
31
Tahap 3:
f3(y) = max{f2(y), p3 + f2(y – w3)}
= max{f2(y), 30 + f2(y – 1)}
Solusi Optimum
y f2(y) 30 + f2(y – 1) f3(y) (x1*, x2*, x3*)
0 0 30 + (-) = - 0 (0, 0, 0)
1 0 30 + (-) = - 0 (0, 0, 0)
2 65 30 + 0 = 30 65 (1, 0, 0)
3 80 30 + 65 = 95 95 (1, 0, 1)
4 80 30 + 80 = 110 110 (0, 1, 1)
5 145 30 + 80 = 110 145 (1, 1, 0)
Solusi optimum X = (1, 1, 0) dengan p = f = 145.
32
SELAMAT BELAJAR
Program Dinamis
Bagian 2.1: Capital Budgeting

STEI-ITB
1
• Metode pemecahan masalah dengan cara
menguraikan solusi menjadi sekumpulan
tahapan (stage) sehingga solusi dari persoalan
dapat dipandang dari serangkaian keputusan
yang saling berkaitan.
• Karakteristik persoalan: stage, state,
transformasi hasil state antar stage, cost >>,
Review rekursif keputusan terbaik k ke k+1, prinsip
optimalitas
Program • Prinsip optimalitas: jika solusi total optimal,
Dinamis (PD) maka bagian solusi sampai tahap ke-k juga
optimal.
• Metode: def struktur solusi, def rekursif nilai
solusi, kalkulasi, konstruksi solusi optimal
• Greedy: 1 rangkaian keputusan;
Program Dinamis: > 1 rangkaian keputusan
optimal 2
Persoalan 3: Penganggaran Modal (Capital
Budgeting)
• Sebuah perusahaan berencana akan mengembangkan usaha (proyek)
melalui ketiga buah pabrik (plant) yang dimilikinya.
• Setiap pabrik diminta mengirimkan proposal (boleh lebih dari satu) ke
perusahaan untuk proyek yang akan dikembangkan.
• Setiap proposal memuat total biaya yang dibutuhkan (c) dan total
keuntungan (revenue) yang akan diperoleh (R) dari pengembangan usaha
itu. Perusahaan menganggarkan Rp 5 milyar untuk alokasi dana bagi ketiga
pabriknya itu.
3
• Tabel berikut meringkaskan nilai c dan R untuk masing-masing
proposal proyek.
Pabrik 1 Pabrik 2 Pabrik 3

Proyek c1 R1 c2 R2 c3 R3
1 0 0 0 0 0 0
2 1 5 2 8 1 3
3 2 6 3 9 - -
4 - - 4 12 - -
• Proposal proyek bernilai-nol sengaja dicantumkan yang berarti tidak

ada alokasi dana yang diberikan untuk setiap pabrik.
• Tujuan Perusahaan adalah memperoleh keuntungan yang maksimum
dari pengalokasian dana sebesar Rp 5 milyar tersebut.
• Selesaikan persoalan ini dengan program dinamis. 4
Penyelesaian dengan Program Dinamis
• Tahap (k) adalah proses mengalokasikan dana untuk setiap

pabrik (ada 3 tahap, tiap pabrik mendefinisikan sebuah tahap).
• Status (xk) menyatakan jumlah modal yang dialokasikan pada
pada setiap tahap (namun terikat bersama semua tahap lainnya).
• Alternatif (p) menyatakan proposal proyek yang diusulkan setiap
pabrik. Pabrik 1, 2, dan 3 masing-masing memiliki 3, 4 dan 2
alternatif proposal.
5
Peubah status yang terdapat pada tahap 1, 2, dan 3:
x1 =  modal yang dialokasikan pada tahap 1

x2 =  modal yang dialokasikan pada tahap 1 dan 2
x3 =  modal yang dialokasikan pada tahap 1, 2, dan 3
x3
x2
x1
Tahap 1 Tahap 2 Tahap 3
Kemungkinan nilai-nilai untuk x1 dan x2 adalah 0, 1, 2,

3, 4, 5 (milyar), sedangkan nilai untuk x3 adalah 5
6
Misalkan,
Penyelesaian Rk(pk) = keuntungan dari
alternatif pk pada tahap k
dengan
Program fk(xk) = keuntungan optimal
Dinamis Maju. dari tahap 1, 2, …, dan k yang
diberikan oleh status xk
7
Relasi rekurens keuntungan optimal:
f ( x ) = max {R1(p1)}
1 1 feasible
(basis)
proposal _ p1
f ( x ) = max {Rk(pk) + fk-1(xk-1) }

k k feasible
(rekurens)
proposal _ pk
k = 2, 3
Catatan:
1. xk – 1 = xk – ck(pk)
c(pk) adalah biaya untuk alternatif pk pada tahap k.
2. Proposal pk dikatakan layak (feasible) jika biayanya,

c(pk), tidak melebihi nilai status xk pada tahap k.
8
Relasi rekurens keuntungan optimal menjadi
f ( x ) = max {R1(p1)}
1 1 c1 ( p1 )  x1
(basis)
f ( x ) = max {Rk(pk) + fk-1[xk – ck(pk)] } (rekurens)

k k ck ( pk )  x k
k = 2, 3
9
Tahap 1
f ( x ) = max {R1(p1)}
1 1 c1 ( p1 ) x1
p1 =1 , 2 , 3
R1(p1) Solusi Optimal

x1 p1 = 1 p1 = 2 p1 = 3 f1(x1) p1*
0 0 - - 0 1
1 0 5 - 5 2
2 0 5 6 6 3
3 0 5 6 6 3
4 0 5 6 6 3
5 0 5 6 6 3
10
Tahap 2
f ( x ) = max {R2(p2) + f1[(x2 – c2(p2)]},

2 2 c2 ( p2 )  x 2
p2 =1, 2 , 3 , 4
R2(p2) + f1[(x2 – c2(p2)] Solusi

x2 Optimal
p2 = 1 p2 = 2 p2 = 3 p2 = 4 f2(x2) p2*
0 0+0=0 - - - 0 1
1 0+5=5 - - - 5 1
2 0+6=6 8+0=8 - - 8 2
3 0 + 6 = 6 8 + 5 = 13 9 + 0 = 9 - 13 2
4 0 + 6 = 6 8 + 6 = 14 9 + 5 = 14 12 + 0 = 12 14 2 atau 3
5 0 + 6 = 6 8 + 6 = 14 9 + 6 = 15 12 + 5 = 17 17 4
11
Tahap 3
f ( x ) = max {R3(p3) + f2[(x3 – c3(p3)]},

3 3 c3 ( p 3 )  x 3
p3 =1 , 2
R3(p3) + f2[(x3 – c3(p3)] Solusi Optimal

x3 p3 = 1 p3 = 2 f3(x3) p3*
5 0 + 17 = 17 3 + 14 = 17 17 1 atau 2
12
Rekonstruksi Solusi
Rekonstruksi solusi:
x3 p3* x2 p2* x1 p1 * (p1*, p2*, p3*)
1 (5 – 0 = 5) 4 (5 – 4 = 1) 2 (2, 4, 1)
1
2 (4 – 2 = 2) 3 (3, 2, 2)
2 (5 – 1 = 4)
3 (4 – 3 = 1) 3 (2, 3, 2)
13
SELAMAT BELAJAR
Program Dinamis
Bagian 2.2: Travelling Salesperson Problem

STEI-ITB
1
• Diberikan sejumlah kota dan diketahui jarak
antar kota. Tentukan tur terpendek yang
harus dilalui oleh seorang pedagang bila
pedagang itu berangkat dari sebuah kota
Persoalan 4: dan menyinggahi setiap kota tepat satu kali
Travelling dan kembali lagi ke kota asal keberangkatan.
Salesperson
Problem
(TSP)
2
• Misalkan G = (V, E) adalah graf lengkap berarah
dengan sisi-sisi yang diberi harga cij > 0.
Travelling
• Misalkan V = n dan n > 1. Simpul diberi nomor
1,2,…,n. Salesperson
• Asumsikan perjalanan (tur) dimulai/berakhir pd Problem
simpul 1.
(TSP)
• Setiap tur pasti terdiri dari sisi (1, k) dgn kV – {1}
dan sebuah lintasan dari simpul k ke simpul 1.
• Lintasan dari simpul k ke simpul 1 tersebut
melalui setiap simpul di dalam V – {1, k} tepat
hanya sekali.
3
TSP
• Prinsip Optimalitas: jika tur tersebut optimal maka lintasan dari

simpul k ke simpul 1 juga menjadi lintasan k ke 1 terpendek yang
melalui simpul-simpul di dalam V – {1, k}.
• Misalkan f(i, S) adalah bobot lintasan terpendek yang berawal pada
simpul i, yang melalui semua simpul di dalam S dan berakhir pada
simpul 1.
• Nilai f(1, V – {1}) adalah bobot tur terpendek.
4
• Misalkan f(i, S) adalah bobot lintasan terpendek yang berawal dari simpul i,
yang melalui semua simpul di dalam S dan berakhir pada simpul 1.
• Nilai f(1, V – {1}) adalah bobot tur terpendek.
Hubungan rekursif:
f (1, V − {1}) = min{c + f (k , V − {1, k})}

2k n 1k
(1)
Dengan merampatkan persamaan (1), diperoleh
f (i ,  ) = c , 2  i  n
i ,1
(basis)
f (i, S ) = min{c + f ( j, S − { j})} (rekurens) (2)
jS ij
Gunakan persamaan (2) untuk memperoleh f(i, S) untuk S = 1,

f(i, S) untuk S = 2, dan seterusnya sampai untuk S = n – 1. 5
Tinjau persoalan TSP untuk n = 4:
0 10 15 20
5 0 9 10 
 
6 13 0 12 
8 8 9 0 
 
Tahap 1: f (i, ) = ci ,1
, 2in
Diperoleh:
f(2, ) = c21 = 5;
f(3, ) = c31 = 6;
f(4, ) = c41 = 8;
6
Tahap 2:
f (i, S ) = min{c + f ( j, S − { j})} untuk S = 1
jS ij
Diperoleh:
f(2, {3}) = min{c23 + f(3, )} = min{9 + 6} = min{15} = 15
f(2, {4}) = min{c24 + f(4, )} = min{10 + 8} = min{18} = 18
f(3, {2}) = min{c32 + f(2, )} = min{13 + 5} = min{18} = 18
f(3, {4}) = min{c34 + f(4, )} = min{12 + 8} = min{20} = 20
f(4, {2}) = min{c42 + f(2, )} = min{8 + 5} = min{13} = 13
f(4, {3}) = min{c43 + f(3, )} = min{9 + 6} = min{15} = 15
7
Tahap 3:
f (i, S ) = min{c + f ( j, S − { j})}
jS ij
untuk S = 2 dan i  1, 1  S dan i  S.
Diperoleh:
f(2, {3, 4}) = min{c23 + f(3, {4}), c24 + f(4, {3})}
= min{9 + 20, 10 + 15}
= min{29, 25} = 25
f(3, {2, 4}) = min{c32 + f(2, {4}), c34 + f(4, {2})}

= min{13 + 18, 12 + 13}
= min{31, 25} = 25
f(4, {2, 3}) = min{c42 + f(2, {3}), c43 + f(3, {2})}

= min{8 + 15, 9 + 18}
= min{23, 27} = 23
8
Dengan menggunakan persamaan (1) diperoleh:
f(1, {2, 3, 4}) = min{c12 + f(2, {3, 4}), c13 + f(3, {2, 4}),
c14 + f(4, {2, 3})}
= min{10 + 25, 15 + 25, 20 + 23}
= min{35, 40, 43} = 35
Jadi, bobot tur yang berawal dan berakhir di simpul 1

adalah 35.
9
Konstruksi Solusi
• Misalkan J(i, S) adalah nilai yang meminimumkan untuk mencapai simpul akhir.
Maka, J(1, {2, 3, 4}) = 2. Jadi, tur mulai dari simpul 1 selanjutnya ke simpul 2.
f(1, {2, 3, 4}) = min{c12 + f(2, {3, 4}), c13 + f(3, {2, 4}),
c14 + f(4, {2, 3})}
= min{10 + 25, 15 + 25, 20 + 23}
= min{35, 40, 43} = 35
• Simpul berikutnya dapat diperoleh dari f(2, {3, 4}), yang mana J(2, {3, 4}) = 4. Jadi,
simpul berikutnya adalah simpul 4.
f(2, {3, 4}) = min{c23 + f(3, {4}), c24 + f(4, {3})}
= min{9 + 20, 10 + 15}
= min{29, 25} = 25
• Simpul terakhir dapat diperoleh dari f(4, {3}), yang mana J(4, {3}) = 3.
f(4, {3}) = min{c43 + f(3, )} = min{9 + 6} = min{15} = 15
• Jadi, tur yang optimal adalah 1, 2, 4, 3, 1 dengan bobot (panjang) = 35.
10
SELAMAT BELAJAR
1 pesan baru https://v-class.gunadarma.ac.id/mod/quiz/review.php?attempt=5017235&cmid=789640
Dashboard / My courses / PTA 2021/2022 | 3IA03 | Peranc. & Analisis Algoritma */** | DIMAS NUGEROHO / Soal UTS Pilihan Ganda
/ Soal UTS Pilihan Ganda
Started on Friday, 17 December 2021, 10:04 AM

State Finished
Completed on Friday, 17 December 2021, 11:05 AM
Time taken 1 hour 1 min
Marks 35.00/35.00
Grade 10.00 out of 10.00 (100%)
Question 1
Correct
Mark 1.00 out of 1.00
Apa itu algoritma..?kecuali
Select one:
a. Pesan atau ucapan ekspresi yang terdiri dari order sekuens dari simbol, atau makna yang dapat di tafsirkan dari pesan atau
kumpulan pesan  Correct
b. Urutan logis pengambil keputusan untuk pemecahan masalah
c. Urutan langkah-langkah untuk memecahkan masalah yang disusun secara sistematis dan logis
d. Algoritma dibutuhkan untuk memerintahkan komputer mengambil langkah-langkah tertentu dalam menyelesaikan
masalah
The correct answer is: Pesan atau ucapan ekspresi yang terdiri dari order sekuens dari simbol, atau makna yang dapat di tafsirkan
dari pesan atau kumpulan pesan
Question 2
Correct
Kenapa dalam pembuatan sebuah sistem harus terdapat algoritma.. kecuali
Select one:
a. Notasi algoritma dapat diterjemahkan ke dalam berbagai bahasa pemrograman
b. Pembuatan atau penulisan algoritma tidak tergantung pada bahasa pemrograman manapun
c. Pembuatan atau penulisan algoritma tergantung pada bahasa pemrograman manapun  Correct
d. Apapun bahasa pemrogramannya, output yang akan dikeluarkan sama karena algoritmanya
The correct answer is: Pembuatan atau penulisan algoritma tergantung pada bahasa pemrograman manapun
1
Online
1 dari 14 17/12/2021 11.06

Question 3
Correct
Bentuk penyajian untuk algoritma dibagi menjadi 3 bentuk penyajian yaitu
Select one:
a. Algoritma dengan struktur bahasa Indonesia, Enkrip, dan Flowchart
b. Algoritma dengan struktur bahasa Indonesia, Pseudocode, dan Flowchart  Correct
c. Algoritma dengan struktur bahasa Inggris, Pseudocode, dan Flowchart
d. Data, Pseudocode, dan Flowchart
The correct answer is: Algoritma dengan struktur bahasa Indonesia, Pseudocode, dan Flowchart
Question 4
Correct
Penggambaran secara grafik dari langkah-langkah dan urutan-urutan prosedur dari suatu program yaitu
Select one:
a. Data
b. Algoritma
c. Flowchart  Correct
d. Sistem
The correct answer is: Flowchart
Question 5
Correct
Mengapa harus menggunakan Flowchart, maka terdapat pengungkapan yang jelas dalam model atau chart, maka para pembaca
dapat dengan mudah melihat permasalahan atau memfokuskan perhatian pada area-area tertentu sistem informasi. Pernyataan
berikut termasuk bentuk fungsi flowchart..?
Select one:
a. Communication
b. Simbol Flow
c. Analisis  Correct
d. Relationship
The correct answer is: Analisis
2 dari 14 17/12/2021 11.06

Question 6
Correct
Simbol - simbol yang dipakai dalam flowchart dibagi menjadi 3 kelompok yaitu kecuali
Select one:
a. Direction Symbols  Correct
b. Processing symbols
c. Input / output symbols
d. Flow Direction symbols
The correct answer is: Direction Symbols
Question 7
Correct
Jelaskan bentul symbols pada gambar dibawah ini
Select one:
a. Menyatakan pemulaan atau akhir suatu program
b. Menyatakan penyediaan tempat penyimpanan suatu pengolahan untuk memberikan harga awal  Correct
c. Menunjukan suatu kondisi tertentu yang akan menghasilkan dua kemungkinan jawaban
d. Menyatakan suatu tindakan (proses) yang dilakukan oleh komputer
The correct answer is: Menyatakan penyediaan tempat penyimpanan suatu pengolahan untuk memberikan harga awal
Question 8
Correct
Jelaskan bentul symbols pada gambar dibawah ini
Select one:
a. Menyatakan input berasal dari disk atau output yang disimpan ke disk
b. Menyatakan suatu tindakan (proses) yang dilakukan oleh komputer
c. Menyatakan penyediaan tempat penyimpanan suatu pengolahan untuk memberikan harga awal
d. Menyatakan input berasal dari kartu atau output yang ditulis ke kartu  Correct
The correct answer is: Menyatakan input berasal dari kartu atau output yang ditulis ke kartu
3 dari 14 17/12/2021 11.06

Question 9
Correct
Algoritma yang mempunyai sifat straight dan lurus. Algoritma yang sangat kompleks, karena untuk dapat menyelesaikan masalah
dengan teknik straight forward dibutuhkan masukan dan juga pertimbangan secara logis, sehingga dapat diperoleh sebuah
keputusan pemecahan masalah yang langsung mengacu atau menuju kepada hasil yang diinginkan. Pernyataan tersebut
menggambarkan algoritma ..?
Select one:
a. Greedy
b. DFS
c. Brute Force  Correct
d. BFS
The correct answer is: Brute Force
Question 10
Correct
Algoritma yang mempunyai pemilihan salah satu pemecahaan masalah terbaik, algoritma ini juga langsung melakukan
pemecahan masalah saat itu juga tanpa mempertimbangkan konsekuensi dari pemecahaan masalah yang dimaksud. Prinsip
utamanya lakukan selagi bisa atau lakukan apa yang kamu bisa sekarang. Penyataan tersebut menggambarkan algoritma..?
Select one:
a. Greedy  Correct
b. BFS
c. Brute Force
d. DFS
The correct answer is: Greedy
4 dari 14 17/12/2021 11.06

Question 11
Correct
Algoritma yang memiliki kelebihan

- Cepat dalam bertindak atau fast response
- Penyelesaian secara instant
- Tidak membutuhkan waktu lama untuk memikirkan opsi - opsi lain yang bisa dilakukan serta tidak perlu mempertimbangkan
baik buruk serta konsekuensi dari apa yang diputuskan.
Select one:
a. Brute Force
b. DFS
c. Greedy  Correct
d. BFS
The correct answer is: Greedy
Question 12
Correct
Algoritma yang termasuk algoritma traversal yaitu
Select one:
a. DFS
b. BFS
c. Brute Force
d. Jawaban B dan C Benar  Correct
The correct answer is: Jawaban B dan C Benar
Question 13
Correct
Sebutkan kelebihan dari algoritma BFS yaitu
Select one:
a. Mengambil kebawah dari pahon pencarian
b. Mengambil Melebar dari pohon pencarian  Correct
c. Jalur Solusi dengan jalur terpanjang
d. Memerlukan waktu dan ruang pencarian yang eksponensial
The correct answer is: Mengambil Melebar dari pohon pencarian
5 dari 14 17/12/2021 11.06

Question 14
Correct
di mana n adalah ukuran data. Notasi tersebut menunjukkan bahwa waktu yang diperlukan untuk transfer data akan bertambah
secara linear mengikuti besar ukuran data. Peryataan diatas bentuk dari transfer …
Select one:
a. Transfer Digital 
Gambar ini untuk soal 15 -16
b. Jawaban A, B dan C Salah
c. Transfer Data
d. Transfer Fisik
The correct answer is: Transfer Digital
Question 15
Correct
Sebutkan path untuk algoritma BFS dari gambar diatas
Select one:
a. Jawaban A, B dan C Salah
b. A,B,G,E,D,F,C
c. A,B,G,D,E,F,C  Correct
d. A,B,G,C,E,F,D
The correct answer is: A,B,G,D,E,F,C
6 dari 14 17/12/2021 11.06

Question 16
Correct
Sebutkan path untuk algoritma DFS dari gambar no 15
Select one:
a. A,B,E,G,F,C,D 
Gambar ini untuk soal 17 -18
b. A,B,G,C,E,F,D
c. A,B,G,C,E,F,D
d. A,B,G,D,E,F,C
The correct answer is: A,B,E,G,F,C,D
Question 17
Correct
Sebutkan path untuk algoritma DFS dari gambar diatas
Select one:
a. A,B,C,E,F,D,G  Correct
b. A,B,G,D,E,F,C
c. A,B,E,G,F,C,D
d. A,B,G,C,E,F,D
The correct answer is: A,B,C,E,F,D,G
7 dari 14 17/12/2021 11.06

Question 18
Correct
Sebutkan path untuk algoritma BFS dari gambar no 17
Select one:
a. A,B,G,E,D,F,C
b. Jawaban A, B dan C Salah
c. A,B,G,C,E,F,D
d. A,B,C,E,D,F,G  Correct
The correct answer is: A,B,C,E,D,F,G
Question 19
Correct
di mana 1 adalah suatu konstanta. Nilai konstan dalam notasi tersebut menunjukkan bahwa ukuran data tidak memengaruhi
waktu transfer data. Artinya, data akan selalu sampai dalam rentang waktu 3 - 5 jam, tidak peduli seberapa besar data yang
dikirimkan
Select one:
a. Transfer Fisik  Correct
b. Transfer Data
c. Transfer Digital
d. Jawaban A, B dan C Salah
The correct answer is: Transfer Fisik
Question 20
Correct
sebuah metrik yang digunakan untuk mengukur kompleksitas suatu algoritma. Kompleksitas dalam konteks ini berkaitan dengan
efisiensi kode. Semakin rendah kompleksitasnya, semakin efisien pula kode tersebut
Select one:
a. DFS
b. BFS
c. Jawaban A, B dan C Salah
d. BIG O  Correct
The correct answer is: BIG O
8 dari 14 17/12/2021 11.06

Question 21
Correct
Algoritma yang berbasis pada DFS untuk mencari solusi persoalan secara lebih mangkus
Select one:
a. BFS
b. DFS
c. BIG O
d. Runut Balik (Backtracking)  Correct
The correct answer is: Runut Balik (Backtracking)
Question 22
Correct
Properti umum metode Runut-Balik terdapat 3 yaitu kecuali
Select one:
a. Solusi Persoalan
b. Pembatas
c. Solusi Runut Balik  Correct
d. Pembangkit Nilai
The correct answer is: Solusi Runut Balik
Question 23
Correct
Pada algoritma runut balik terdapat ruang solusi jika knapsack 0/1 untuk N=3 maka bentuk ruang solusi yang ada adalah
Select one:
a. {(0, 0, 0), (0, 1, 0), (0, 0, 1), (1, 0, 0), (1, 1, 0), (1, 0, 1), (0, 1, 1), (1, 1, 1)}  Correct
b. {(0, 0, 0), (0, 1, 0), (0, 0, 1), (1, 0, 0), (1, 1, 0), (1, 1, 1) , (1, 0, 1), (0, 1, 1)}
c. {(0, 0, 0), (0, 1, 0), (0, 0, 1), (1, 0, 0) , (0, 1, 1), (1, 1, 0), (1, 0, 1), (1, 1, 1)}
d. {(0, 0, 0), (0, 0, 1), (0, 1, 0), (1, 0, 0), (1, 1, 0), (1, 0, 1), (0, 1, 1), (1, 1, 1)}
The correct answer is: {(0, 0, 0), (0, 1, 0), (0, 0, 1), (1, 0, 0), (1, 1, 0), (1, 0, 1), (0, 1, 1), (1, 1, 1)}
9 dari 14 17/12/2021 11.06

Question 24
Correct
Simpul hidup yang sedang diperluas dalam metode runut balik yaitu
Select one:
a. Simpul Dead
b. Simpul E 
Soal untuk NO 25 - 28
Pohon dinamis yang dibentuk selama pencarian untuk persoalan Knapsack 0/1 dengan n = 3,
M = 6, w = (2, 4, 8) dan p = (50, 35, 20)
c. Simpul C
d. Simpul Hidup
The correct answer is: Simpul E
Question 25
Correct
"Pohon dinamis yang dibentuk selama pencarian untuk persoalan Knapsack 0/1 dengan n = 3,
M = 6, w = (2, 4, 8) dan p = (50, 35, 20)"
Berapa jumlah kemungkinan solusi yang dapat diselesaikan sampai ke daun
Select one:
a. 1
b. 2
c. 4  Correct
d. 3
The correct answer is: 4
Question 26
Correct
Sebutkan salah satu solusi dari pencarian tersebut
Select one:
a. (0,0,1)
b. (0,1,1)
c. (1,1,1)
d. (1,1,0)  Correct
The correct answer is: (1,1,0)
10 dari 14 17/12/2021 11.06

Question 27
Correct
Berapa point tertinggi dari solusi pencairan tersebut
Select one:
a. 85  Correct
b. 90
c. 80
d. 50
Question 28
Correct
Berapa point terkecil dari solusi pencairan tersebut
Select one:
a. 85
b. 80
c. 0  Correct
d. 50
Question 29
Correct
Membagi masalah menjadi beberapa masalah yang memiliki kemiripan dengan masalah semula namun berukuran lebih kecil
(idealnya berukuran hampir sama) disebut
Select one:
a. Combine
b. Conquer
c. Divide & Conquer
d. Divide  Correct
The correct answer is: Divide
11 dari 14 17/12/2021 11.06

Question 30
Correct
memecahkan (menyelesaikan) masing-masing upa-masalah (secara rekursif) disebut
Select one:
a. Combine
b. Divide
c. Divide & Conquer
d. Conquer  Correct
The correct answer is: Conquer
Question 31
Correct
mengabungkan solusi masing-masing upa-masalah sehingga membentuk solusi masalah semula disebut
Select one:
a. Divide & Conquer
b. Combine 
Table A
4 20 18 10 2 6 8 12 14 16
Bentuk Diatas masih dalam kategori Divide dan Conquer yang belum dilakukan yaitu dalam melakukan merge sort
c. Divide
d. Conquer
The correct answer is: Combine
12 dari 14 17/12/2021 11.06

Question 32
Correct
"Bentuk Diatas masih dalam kategori Divide dan Conquer yang belum dilakukan yaitu dalam melakukan merge sort"
Tahap 1 posisi dalam melakukan merge sort, tentukan isian yang harus ada pada table berikut
Select one:
a. 4,20,18,2,6,10,8,12,14,16
b. 4,20,18,2,10,6,8,12,14,16  Correct
c. 4,20,18,2,10,6,8,12,16,14
d. 4,18,20,2,10,6,8,12,14,16
The correct answer is: 4,20,18,2,10,6,8,12,14,16
Question 33
Correct
Select one:
a. 4,20,18,2,6,10,8,12,14,16
b. 4,20,2,10,18,6,8,12,14,16  Correct
c. 4,18,20,2,10,6,8,12,14,16
d. 4,20,18,2,10,6,8,12,16,14
13 dari 14 17/12/2021 11.06

Question 34
Correct
Select one:
a. 2,4,10,18 ,6, 20,8,12,14,16
b. 2,4,18,10,20,6,8,12,14,16
c. 2,4,10,18,20,6,8,12,14,16  Correct
d. 2,4,10,18,20,8,6,12,14,16
Question 35
Correct
Tahap terakhir posisi dalam melakukan merge sort, tentukan isian yang harus ada pada table berikut
Select one:
a. 2,4,6,8,10,14,12,16,18,20
b. 2,4,6,8,10,12,14,16,18,20  Correct
c. 2,4,6,8,10,12,14,18,16,20
d. 2,4,6,8,10,12,16,14,18,20
◄ [Quiz]Peranc. & Analisis Algoritma
Jump to...
14 dari 14 17/12/2021 11.06

UU - Perancangan Analisis &amp; Algoritma

Diunggah oleh

Informasi Dokumen

Deskripsi Asli:

Hak Cipta

Format Tersedia

Bagikan dokumen Ini

Bagikan atau Tanam Dokumen

Opsi Berbagi

Apakah menurut Anda dokumen ini bermanfaat?

Apakah konten ini tidak pantas?

Hak Cipta:

Format Tersedia

UU - Perancangan Analisis &amp; Algoritma

Diunggah oleh

Hak Cipta:

Format Tersedia

Novrina

a. Kesalahan sintaks (penulisan program).

Algoritma dengan struktur pseudocode :

Maka, flowchart harus dapat

Kondisi adalah persyaratan yang dapat dinilai benar atau

‘if’ x > y ‘then’

For var=awal to akhir

Mengukur efisiensi sebuah Algoritma

100 2 + 100 102

1000 2 + 1000 1002

10000 2 + 10000 10002

Semakin meningkatnya jumlah y, semakin nilai 2

Y Jml Langkah (Y) Jml Langkah (Y2)

100 100 10000

1000 1000 1000000

10000 10000 100000000

• Operasi yang mendasar pada algoritma

• Keadaan rata-rata (average case)

• Keadaan terburuk (worst case)

• Algoritma dengan kompleksitas logaritmik

Terlihat bahwa pada setiap iterasinya

Jika diturunkan lebih lanjut

• Sehingga dapat dikatakan bahwa

• Algoritma dengan kompleksitas linear

Sehingga nilai kompleksitas dari linear search adalah (5 + n)

Algoritma dgn kompleksitas (n log n) memiliki

• Algoritma dengan kompleksitas polinomial

karena pada setiap iterasi kita harus menjalankan

 Algoritma brute force memecahkan masalah

an = a x a x … x a (n kali) , jika n > 0

Algoritma: kalikan 1 dengan a sebanyak n kali

 Misalkan C = A × B dan elemen-elemen matrik

 Algoritma: hitung setiap elemen hasil perkalian

 Definisi: Bilangan bulat a adalah faktor dari

Persoalan: Diberikan sebuah himpunan yang

Persoalan: Diberikan n buah bilangan bulat

• Apa metode yang paling lempang dalam

• Algoritma bubble sort mengimplementasikan teknik

Persoalan: Hitung nilai polinom

p(x) = anxn + an-1xn-1 + … + a1x + a0

pada titik x = x0.

Kompleksitas algoritma ini adalah O(n).

2. Algoritma brute force seringkali merupakan pilihan yang

Algoritma brute force sering digunakan sebagai

 Kompleksitas algoritma ini adalah O(n2).

• Sekarang strategi tersebut menjadi

n Conquer: memecahkan (menyelesaikan)

n Combine: mengabungkan solusi masing-masing

n Tiap-tiap upa-masalah mempunyai karakteristik

• Dalam hal ini, ukuran kecil yang dipilih

2. Untuk kasus n > 2,

• MinMaks2 secara divide and conquer:

• Perhatikan: 3n/2 – 2 < 2n – 2 , n  2.

• Kesimpulan: algoritma MinMaks lebih

2. Untuk kasus n > 1, maka

• Persoalan optimasi (optimization problems):

• Hanya ada dua macam persoalan optimasi:

( Masalah Penukaran Uang): Diberikan

• Uang senilai A = 32 dapat ditukar dengan

• Prinsip greedy: “take what you can get now!”.

• Algoritma greedy membentuk solusi langkah per

• Pada setiap langkah, terdapat banyak pilihan yang

pada setiap langkah:

UU - Perancangan Analisis & Algoritma

UU - Perancangan Analisis & Algoritma