STRATEGI ALGORITMA

OLEH :
1.

PROGRAM STUDI
FAKULTAS ILMU
UNIVERSITAS

KATA PENGANTAR

Alhandulillah puji syukur kehadirat Allah SWT karena dengan Rahmat

dan Hidayah-Nya makalah ini dapat diselesaikan dengan judul Strategi
Algoritma
Dalam penyusunan makalah ini, tentunya jauh dari kesempurnaan. Hal ini
dikarenakan keterbatasan pengalaman, kemampuan dan pengetahuan yang ada
pada diri penulis, namun demikian besar harapan, mudah-mudahan makalah ini
dapat bermanfaat bagi penulis khususnya maupun bagi pembaca umumnya.
Akhirnya kata semoga Makalah ini berguna bagi kita semua dan sekali
lagi penulis mengucapkan terima kasih kepada seluruh pihak yang telah
membantu dan memberikan dorongan terhadap penyelesaian makalah ini.

Penulis

DAFTAR ISI

Kata Pengantar .............................................................................................i

Daftar Isi .......................................................................................................ii
BAB I PENDAHULUAN
A. Latar Belakang ...............................................................................1
B. Rumusan Masalah ..........................................................................2
C. Tujuan ............................................................................................2
BAB II PEMBAHASAN
A. Strategi solusi langsung .................................................................5
B. Strategi berbasis pencarian pada ruang status ................................14
C. Strategi solusi atas-bawah. .............................................................22
D. Strategi solusi bawah-atas ..............................................................27

BAB III PENUTUP

A. Kesimpulan .................................................................................... 37
DAFTAR PUSTAKA

BAB I
PENDAHULUAN
1.1.

Latar Belakang
Di dalam kehidupannya, manusia selalu menemui masalah atau
persoalan. Hal ini mungkin didasarkan dari sifat dasar manusia itu sendiri
yang selalu ingin tahusegala sesuatu. Deskripsi dari masalah menurut
[NEA96] adalah pertanyaan atau tugas yang kita cari jawabannya. Dalam
menghadapi permasalahan, untuk menyelesaikannya manusiamemerlukan
langkah-langkah

yang

benar

sehingga

permasalah

tersebut

dapatterselesaikan. Urutan langkah-langkah untuk memecahkan suatu

masalahtersebutlah yang dinamakan dengan algoritma. Definisi lain dari
algoritma

adalahderetan

langkah-langkah

komputasi

yang

mentranformasikan data masukanmenjadi keluaran [COR92].

Dalam menentukan langkah-langkah tersebut diperlukan suatu
strategi agarlangkah-langkah yang dipakai tersebut dapat menyelesaikan
permasalahan secaramangkus (efisien). Strategi menurut kamus besar
bahasa indonesia adalah rencanayang cermat mengenai kegiatan untuk
mencapai sasaran khusus. Rencana itusendiri dapat berisi suatu metode
atau teknik yang digunakan untuk mencapaisasaran khusus tersebut.
Dengan

pengertian

algoritma

dan

strategi

tersebut,

kita

dapat

mendefinisikanstrategi algoritmik sebagai kumpulan metode atau teknik

untuk memecahkanmasalah guna mencapai tujuan yang ditentukan, yang
dalam hal ini deskripsimetode atau teknik tersebut dinyatakan dalam suatu
urutan langkah-langkahpenyelesaian.

1.2.

Rumusan Masalah
Adapun rumusan masalah dalam makalah ini ialah sebagai berikut :

1. Apa definisi dari Strategi Algoritma?

2. Apa saja macam-macam Strategi Algoritma?
3. Apa saja fungsi Strategi Algoritma?

1.3.

Tujuan
Adapun tujuan dari penyusunan makalah ini yaitu Untuk menambah ilmu
dan pengetahuan mengenai masalah yang diangkat dalam makalah ini.

BAB II
PEMBAHASAN

Secara umum, strategi pemecahan masalah dapat dikelompokan menjadi:

A.

Strategi solusi langsung

metode yang termasuk ke dalam strategi ini adalah:
a. Algoritma Brute Force
Brute force : pendekatan yang lempang (straightforward)
untuk memecahkan suatu masalah. Biasanya didasarkan
pada:

pernyataan masalah (problem statement)

Definisi konsep yang dilibatkan.

Algoritma brute force memecahkan masalah

dengan sangat sederhana, langsung, jelas (obvious way).
Algoritma brute force merupakan algoritma pencocokan
string yang ditulis tanpa memikirkan peningkatan
performa. Algoritma ini sangat jarang dipakai dalam
praktik, namun berguna dalam studi pembanding dan
studi-studi lainnya.
2. Karakteristik Algoritma Brute Force

Algoritma brute force sebenarnya bukanlah algoritma

yang cerdas dan mangkus(efisien), karena ia
membutuhkan jumlah langkah yang besar/banyak dalam
penyelesaiannya dan tentu saja membutuhkan waktu yang
berbanding lurus dengan jumlah langkah penyelesaiannya.
Kadang-kadang algoritma brute force disebut juga
algoritma naif (nave algorithm).

Algoritma brute force seringkali merupakan pilihan yang

kurang disukai karena ketidakmangkusannya itu, tapi kalau
mencari pola2 dasar, keteraturan, atau trik-trik khusus,

biasanya dapat membantu untuk menemukan algoritma

yang lebih cerdas dan lebih mangkus lagi.

Untuk persoalan2 yang kecil, kesederhanaan brute force

lebih diperhitungkan daripada ketidakmangkusannya.
Algoritma brute force sering digunakan sebagai basis bila
membandingkan beberapa alternatif algoritma yang
mangkus.

Meskipun brute force bukan merupakan teknik

pemecahan masalah yang mangkus, namun teknik brute
force dapat diterapkan pada sebagian besar persoalan.
Bayangkan..,sangat sulit menemukan masalah yang tidak
dapat dipecahkan dengan teknik brute force, tapi ada
masalah yang hanya dapat dipecahkan secara brute force.

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 (nave
algorithm).

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.

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.

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).
3. Cara kerja

Secara sistematis, langkah-langkah yang dilakukan algoritma brute force

pada saat mencocokkan string adalah:
1. Algoritma brute force mulai mencocokkan pattern pada
awal teks.
2. Dari kiri ke kanan, algoritma ini akan mencocokkan
karakter per karakter pattern dengan karakter di teks yang
bersesuaian, sampai salah satu kondisi berikut dipenuhi:
1.

Karakter di pattern dan di teks yang dibandingkan

tidak cocok (mismatch).

2.

Semua karakter di pattern cocok. Kemudian

algoritma akan memberitahukan penemuan di posisi ini.

3. Algoritma kemudian terus menggeser pattern sebesar satu

ke kanan, dan mengulangi langkah ke-2 sampai pattern
berada di ujung teks.
Jadi secara keselurhuan cara kerjanya yaitu:

Enumerasi (list) setiap solusi yang mungkin dengan cara

yang sistematis.

Evaluasi setiap kemungkinan solusi satu per satu dan

simpan solusi terbaik yang ditemukan sampai sejauh ini
(the best solusi found so far).

Bila pencarian solusi berakhir, umumkan solusi terbaik (the

winner).
Contoh-contoh algoritma Brute Force:
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
5

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.

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.
b. Algoritma Greedy
Algoritma greedy merupakan jenis algoritma yang menggunakan
pendekatan penyelesaian masalah dengan mencari nilai
maksimum sementara pada setiap langkahnya. Nilai maksimum
sementara ini dikenal dengan istilah local maximum. Pada
kebanyakan kasus, algoritma greedy tidak akan menghasilkan
solusi paling optimal, begitupun algoritma greedy biasanya
memberikan solusi yang mendekati nilai optimum dalam waktu
yang cukup cepat.
Sebagai contoh dari penyelesaian masalah dengan algoritma greedy, mari kita
lihat sebuah masalah klasik yang sering dijumpai dalam kehidupan sehari-hari:
mencari jarak terpendek dari peta. Misalkan kita ingin bergerak dari titik A ke titik
B, dan kita telah menemukan beberapa jalur dari peta:

Jalur dari Titik A ke B

Dari peta yang ditampilkan di atas, dapat dilihat bahwa terdapat beberapa jalur
dari titik A ke titik B. Sistem peta pada gambar secara otomatis telah memilih
jalur terpendek (berwarna biru). Kita akan mencoba mencari jalur terpendek juga,
dengan menggunakan algoritma greedy.
Langkah pertama yang harus kita lakukan tentunya adalah memilih struktur data
yang tepat untuk digunakan dalam merepresentasikan peta. Jika dilihat kembali,
sebuah peta seperti pada gambar di atas pada dasarnya hanya menunjukkan titiktitik yang saling berhubungan, dengan jarak tertentu pada masing-masing titik
tersebut. Misalnya, peta di atas dapat direpresentasikan dengan titik-titik
penghubung seperti berikut:

Graph Sederhana dari Titik A ke B

Dari gambar di atas, kita dapat melihat bagaimana sebuah peta jalur perjalanan
dapat direpresentasikan dengan menggunakan graph, spesifiknya Directed Graph
(graph berarah). Maka dari itu, untuk menyelesaikan permasalahan jarak
terpendek ini kita akan menggunakan struktur data graph untuk merepresentasikan
peta. Berikut adalah graph yang akan digunakan:

Graph Berarah dari Titik A ke B

Untuk mencari jarak terpendek dari A ke B, sebuah algoritma greedy akan
menjalankan langkah-langkah seperti berikut:
1. Kunjungi satu titik pada graph, dan ambil seluruh titik yang
dapat dikunjungi dari titik sekarang.
2. Cari local maximum ke titik selanjutnya.
3. Tandai graph sekarang sebagai graph yang telah
dikunjungi, dan pindah ke local maximum yang telah
ditentukan.
8

4. Kembali ke langkah 1 sampai titik tujuan didapatkan.

Jika mengapliikasikan langkah-langkah di atas pada graph A ke B sebelumnya
maka kita akan mendapatkan pergerakan seperti berikut:
1. Mulai dari titik awal (A). Ambil seluruh titik yang dapat dikunjungi.

Langkah Pertama Greedy

2. Local maximum adalah ke C, karena jarak ke C adalah yang paling dekat.
3. Tandai A sebagai titik yang telah dikunjungi, dan pindah ke C.
4. Ambil seluruh titik yang dapat dikunjungi dari C.

Langkah Kedua Greedy

5. Local maximum adaah ke D, dengan jarak 6.
6. Tandai C sebagai titik yang telah dikunjungi, dan pindah ke D.

Langkah Ketiga Greedy

7. (Langkah selanjutnya diserahkan kepada pembaca sebagai latihan).

Dengan menggunakan algoritma greedy pada graph di atas, hasil akhir yang akan
didapatkan sebagai jarak terpendek adalah A-C-D-E-F-B. Hasi jarak terpendek
yang didapatkan ini tidak tepat dengan jarak terpendek yang sebenarnya (A-G-EF-B). Algoritma greedy memang tidak selamanya memberikan solusi yang
optimal, dikarenakan pencarian local maximum pada setiap langkahnya, tanpa
memperhatikan solusi secara keseluruhan. Gambar berikut memperlihatkan
bagaimana algoritma greedy dapat memberikan solusi yang kurang optimal:

Solusi Kurang Optimal dari Greedy

Tetapi ingat bahwa untuk kasus umum, kerap kali algoritma greedy memberikan
hasil yang cukup baik dengan kompleksitas waktu yang cepat. Hal ini
mengakibatkan algoritma greedy sering digunakan untuk menyelesaikan
permasalahan kompleks yang memerlukan kecepatan jawaban, bukan solusi
optimal, misalnya pada game.

10

Implementasi Algoritma Greedy

Untuk memperdalam pengertian algoritma greedy, kita akan
mengimplementasikan algoritma yang telah dijelaskan pada bagian sebelumnya
ke dalam kode program. Seperti biasa, contoh kode program akan diberikan dalam
bahasa pemrograman python. Sebagai langkah awal, tentunya kita terlebih dahulu
harus merepresentasikan graph. Pada implementasi yang kita lakukan, graph
direpresentasikan dengan menggunakan dictionary di dalam dictionary, seperti
berikut:
DAG = {'A':
'G':
'C':
'D':
'H':
'E':
'F':

{'C':
{'E':
{'D':
{'E':
{'F':
{'F':
{'B':

4, 'G': 9},
6},
6, 'H': 12},
7},
15},
8},
5}}

# Hasil Representasi:
{'A': {'C': 4, 'G': 9},
'C': {'D': 6, 'H': 12},
'D': {'E': 7},
'E': {'F': 8},
'F': {'B': 5},
'G': {'E': 6},
'H': {'F': 15}}

Selanjutnya kita akan membuat fungsi yang mencari jarak terpendek dari graph
yang dibangun, dengan menggunakan algoritma greedy. Definisi dari fungsi
tersebut sangat sederhana, hanya sebuah fungsi yang mengambil graph, titik awal,
dan titik akhir sebagai argumennya:
def shortest_path(graph, source, dest):

Jarak terpendek yang didapatkan akan dibangun langkah demi langkah, seperti
pada algoritma greedy yang mengambil nilai local maximum pada setiap
langkahnya. Untuk hal ini, tentunya kita akan perlu menyimpan jarak terpendek
ke dalam sebuah variabel, dengan source sebagai isi awal variabel tersebut. Jarak
terpendek kita simpan ke dalam sebuah list, untuk menyederhanakan proses
penambahan nilai.
result = []
result.append(source)

Penelusuran graph sendiri akan kita lakukan melalui result, karena variabel ini
merepresentasikan seluruh node yang telah kita kunjungi dari keseluruhan graph.
Variabel result pada dasarnya merupakan hasil implementasi dari langkah 3
algoritma (Tandai graph sekarang sebagai graph yang telah dikunjungi). Titik
awal dari rute tentunya secara otomatis ditandai sebagai node yang telah
dikunjungi.
11

Selanjutnya, kita akan menelusuri graph sampai titik tujuan ditemukan, dengan
menggunakan iterasi:
while dest not in result:
current_node = result[-1]

dengan mengambil node yang sekarang sedang dicari local maximum-nya dari isi
terakhir result. Pencarian local maximum sendiri lebih memerlukan pengetahuan
python daripada algoritma:
# Cari local maximum
local_max = min(graph[current_node].values())
# Ambil node dari local maximum,
# dan tambahkan ke result
# agar iterasi selanjutnya dimulai
# dari node sekarang.
for node, weight in graph[current_node].items():
if weight == local_max:
result.append(node)

Setelah seluruh graph ditelurusi sampai mendapatkan hasil, kita dapat

mengembalikan result ke pemanggil fungsi:
return result

Keseluruhan fungsi yang dibangun adalah sebagai berikut:

def shortest_path(graph, source, dest):
result = []
result.append(source)
while dest not in result:
current_node = result[-1]
local_max = min(graph[current_node].values())
for node, weight in graph[current_node].items():
if weight == local_max:
result.append(node)
return result

Perlu diingat bahwa fungsi ini masih banyak memiliki kekurangan, misalnya tidak
adanya penanganan kasus jika titik tujuan tidak ditemukan, atau jika terdapat node
yang memiliki nilai negatif (bergerak balik). Penanganan hal-hal tersebut tidak
dibuat karena fungsi hanya bertujuan untuk mengilustrasikan cara kerja algoritma
greedy, bukan untuk digunakan pada aplikasi nyata.
B.

Strategi berbasis pencarian pada ruang

status, metode yang termasuk ke dalam strategi ini adalah:
a. Algoritma Backtracking

12

1. Algoritma Backtracking (Runut-Balik)

Algoritma backtracking pertama kali diperkenalkan oleh D.H Lehmer pada tahun
1950. Algoritma ini sangat mangkus untuk digunakan dalam beberapa
penyelesaian masalah dan untuk memberikan kecerdasan buatan dalam game.
Beberapa game populer semisal Sudoku, Labirin, Catur dapat diimplementasikan
dengan menggunakan algoritma backtracking.
Algoritma backtracking merupakan algoritma yang digunakan
untuk mencari solusi persoalan secara lebih mangkus daripada
menggunakan algoritma brute force. Algoritma ini akan mencari
solusi berdasarkan ruang solusi yang ada secara sistematis,
namun tidak semua ruang solusi akan diperiksa, hanya pencarian
yang mengarah kepada solusi yang akan diproses.
Algoritma backtracking berbasis pada DFS (Depth First Search)
sehingga aturan pencariannya akan mengikut kepada aturan
pencarian DFS yaitu dengan mencari solusi dari akar ke daun
(dalam pohon ruang solusi) dengan pencarian mendalam.
Simpul-simpul yang sudah dilahirkan (diperiksa) dinamakan
simpul hidup (live node). Simpul hidup yang sedang diperluas
dinamakan simpul-E atau Expand Node.
Algoritma backtracking mempunyai prinsip dasar yang sama
seperti brute-force yaitu mencoba segala kemungkinan solusi.
Perbedaan utamanya adalah pada ide dasarnya, semua solusi
dibuat dalam bentuk pohon solusi dan algoritma akan menelusuri
pohon tersebut secara DFS sampai ditemukan solusi yang sesuai.
Dengan metode runut-balik, kita tidak perlu memeriksa semua
kemungkinan solusi yang ada. Hanya pencarian yang mengarah
ke solusi saja yang selalu dipertimbangkan sehingga waktu
pencarian dapat dihemat.

13

Properti Umum Metode Backtracking (Runut-Balik)

Untuk

menerapkan

metode

backtracking,

properti

berikut

didefinisikan:
1. Solusi persoalan.
Solusi dinyatakan sebagai vektor n-tuple:
X=(X1, X2, ..., Xn), Xi Si (Xi anggota himpunan berhingga
Si) .
Mungkin saja S1 = 0S2 = ... = Sn.
Contoh: Si = {0,1}
Si = 0, atau Si = 1
2. Fungsi pembangkit nilai Xk
Dinyatakan sebagai:
T(k)
T(k) membangkitkan nilai untuk xk, yang merupakan komponen vektor solusi
3. Fungsi Pembatas (Fungsi Kriteria)
Dinyatakan sebagai:
B(X1, X2, ..., Xk)
Fungsi pembatas menentukan apakah (X1, X2, ..., Xk) mengarah ke solusi. Jika
ya, maka pembangkitan nilai untuk Xk+1 dilanjutkan, tetapi jika tidak, maka
(X1, X2, ..., Xk) dibuang dan tidak dipertimbangkan lagi dalam pencarian
solusi.

3.

Pengorganisasian Solusi

Semua kemungkinan solusi dari persoalan disebut ruang solusi

(solution space). Jika xi Si, maka S1 x S2 x x Sn disebut ruang

14

solusi. Jumlah anggota di dalam ruang solusi adalah | S1| . | S2| .

. | Sn |. Tinjau persoalan Knapsack untuk n = 3. Solusi
persoalan dinyatakan sebagai vektor (x1, x2, x3) dengan xi
{0,1}. Ruang solusinya adalah:
{0,1} x {0,1} x {0,1} = {(0,0,0),

(0,0,1), (0,1,0), (0,1,1),

(1,0,0), (1,0,1), (1,1,0), (1,1,1)}.

Pada persoalan Knapsack 0/1 dengan n = 3 terdapat 2n = 23 = 8.
Knapsack adalah wadah (tempat) dengan kapasitas tertentu
yang dapat membuat beberapa benda/objek. Kemungkinan
solusinya, yaitu:
(0,0,0), (0,0,1), (0,1,0), (0,1,1), (1,0,0), (1,0,1), (1,1,0), dan
(1,1,1).
Penyelesaian secara exhaustive search adalah dengan menguji
setiap kemungkinan solusi.

Ruang solusi diorganisasikan ke

dalam struktur pohon. Tiap simpul pohon menyatakan status

(state) persoalan, sedangkan sisi (cabang) dilabeli dengan nilainilai xi. Lintasan dari akar ke daun menyatakan solusi yang
mungkin. Seluruh lintasan dari akar ke daun membentuk ruang
solusi. Pengorganisasian pohon ruang solusi diacu sebagai pohon
ruang status (state space tree). Tinjau kembali persoalan
Knapsack 1/0 untuk n = 3. Ruang solusinya:

15

1
x1 =1

x1 =0

2
x2 =1

9
x2 =0

3
x3 =1
4

x2 =1
6

x3 =0
5

x3 =1
7

x2 =0
13

10

x3 =0

x3 =1
11

x3 =0
12

x3 =1
14

x3 =0
15

Gambar Ruang solusi untuk persoalan Knapsack 0/1 dengan n =

3

4. Prinsip Pencarian Solusi dengan Metode Backtracking (Runut-Balik)

Langkah-langkah pencarian solusi dengan metode backtracking
adalah sebagai berikut:
1. Solusi dicari dengan membentuk lintasan dari akar ke daun. Aturan yang
dipakai adalah mengikuti metode DFS. Simpul-simpul yang sudah dilahirkan
dinamakan simpul hidup (live node). Simpul hidup yang sedang diperluas
dinamakan simpul-E (Expand-node).
2. Jika lintasan yang diperluas yang sedang dibentuk tidak mengarah ke solusi,
maka simpul-E tersebut dibunuh sehingga menjadi simpul mati (dead
node). Simpul yang sudah mati ini tidak akan diperluas lagi.
3. Jika pembentukan lintasan berakhir dengan simpul mati, maka proses
pencarian diteruskan dengan membangkitkan simpul anak lainnya. Bila tidak
ada lagi simpul anak yang dibangkitkan, maka pencarian solusi dilanjutkan
dengan melakukan runut-balik (backtracking) ke simpul hidup terdekat.
Selanjutnya simpul ini menjadi simpul-E yang terbaru.

16

5.

Persoalan N-Queen

N-Queen merupakan salah satu bentuk permainan puzzle yang pertama kali
dibentuk pada tahun 1848 oleh seorang pemain catur Max Bezzel. Dua orang
matematikawan yaitu Gauss and George Cantor telah bekerja keras untuk
menyelesaikan masalah N-Queen ini. Solusi pertama kali dibentuk oleh Franz
Nauck pada tahun 1850.
N-Queen merupakan generalisasi dari masalah 4-Queen dan 8-Queen. N-Queen
ditempatkan pada sebuah papan catur berukuran NxN tanpa dua serangan
sekaligus, dan tanpa dua atau lebih queen dalam satu baris, kolom, dan diagonal
yang sama. Layaknya queen pada sebuah papan catur, langkah queen dapat
bergerak dalam sejumlah petak horizontal, vertical, dan diagonal.
x
x
x
Q
x
x
x
x

x
x

x
x
x

x
x
x
x
x

x
x
x

Gambar Langkah Queen

Petak yang bisa dilalui oleh queen (Q) diberi tanda x.
Pada pembahasan ini akan dilakukan pemecahan masalah 4-Queen, yang berarti
ditempatkan pada papan berukuran 4x4 dengan menggunakan backtracking.
Queen pada papan disimbolkan dengan huruf Q dan cara pengisiannya
dilakukan berdasarkan urutan baris, mulai dari baris 1, baris 2 dan seterusnya.
Langkah-langkah pemecahan masalah 4-Queen akan dijelaskan sebagai berikut:
a. Terdapat papan berukuran 4x4.
1

A
B

17

C
D
b. Tempatkan queen pada A1.
A
B
C
D

1
Q

c. Satu queen sudah ditempatkan pada A1, selanjutnya penempatan queen pada
baris berikutnya. Langkah yang memungkinkan adalah:
A
B
C
D

1
Q

Langkah A
A
B
C
D

1
Q

4
Q

Langkah B
d. Penempatan queen pada baris ke-3 untuk langkah A tidak mungkin dilakukan,
maka dari itu backtracking untuk langkah A berakhir di A1, B3. Langkah
yang memungkinkan adalah B. Tempatkan queen pada baris ke-3 untuk
langkah B.
A
B
C
D

1
Q

4
Q

e. Setelah penempatan queen ke-3, untuk penempatan queen selanjutnya tidak

dapat dilakukan. Kemungkinan untuk A1, B4, C2 berakhir, maka dari itu
kembali ke langkah pertama dan tempatkan queen pada A2.

18

1
A
B
C
D

2
Q

2
Q

f. Tempatkan queen pada baris ke-2.

1
A
B
C
D

g. Tempatkan queen pada baris ke-3.

1
A
B
C
D

2
Q

4
Q

h. Tempatkan queen pada baris ke-4.

1
A
B
C
D

2
Q

4
Q

Q
Q

i. Jadi, solusi untuk pemecahan masalah 4-Queen adalah A2, B4, C1, D3.
Proses backtracking secara lengkap:

19

Pohon solusi dari backtracking diatas sebagai berikut:

b. Algoritma Brach and Bound

20

Metode Branch and Bound adalah sebuah teknik algoritma yang

secara khusus mempelajari bagaimana caranya memperkecil
Search Tree menjadi sekecil mungkin.
Sesuai dengan namanya, metode ini terdiri dari 2 langkah
yaitu :

Branch yang artinya membangun semua cabang tree yang

mungkin menuju solusi.

Bound yang artinya menghitung node mana yang

merupakan active node (E-node) dan node mana yang
merupakan dead node (D-node) dengan menggunakan
syarat batas constraint (kendala).

TEKNIK BRANCH AND BOUND

Ada beberapa teknik dalam Branch and Bound yaitu:
1. FIFO Branch and Bound
Adalah teknik Branch and Bound yang menggunakan
bantuan queue untuk perhitungan Branch and Bound secara
First In First Out.
2. LIFO Branch and Bound
Adalah teknik Branch and Bound yang menggunakan
bantuan stack untuk perhitungan Branch and Bound secara Last
In First Out.
3. Least Cost Branch and Bound
Teknik ini akan menghitung cost setiap node. Node yang
memiliki cost paling kecil dikatakan memiliki kemungkinan paling

21

besar menuju solusi.

APA MASALAH YANG DAPAT DIPECAHKAN DENGAN BRANCH AND
BOUND?????
Branch and Bound dapat digunakan untuk memecahkan berbagai
masalah yang menggunakan Search Tree
Traveling Salesman Problem
N-Queen Problem
15 Puzzle Problem
0/1 Knapsack Problem
Shortest Path
FIFO BRANCH AND BOUND
Menggunakan queue
E-node dimasukkan ke dalam queue, kemudian dibangun
branch (cabang) berikutnya.
D-node tidak digunakan untuk membangun branch berikutnya.
Didapatkan Partial Space Tree yang dicari.
LIFO BRANCH AND BOUND
Menggunakan stack
E-node dimasukkan ke dalam stack, kemudian dibangun branch
(cabang) berikutnya.
D-node tidak digunakan untuk membangun branch berikutnya.
Didapatkan Partial Space Tree yang dicari.
LEAST COST BRANCH AND BOUND
Pada teknik FIFO dan LIFO, node dibuka sesuai urutannya
Pada LC Branch and Bound, node yang memiliki cost terendah
dibuka terlebih dulu (menjadi E-node berikutnya)
Pada sebuah node x berlaku b c(x) u
b adalah batas bawah
c(x) adalah cost node x
u adalah batas atas
Jika terjadi b > u maka simpul x dapat dimatikan (dinyatakan
sebagai D-node).
Contoh LC Branch and Bound yaitu Traveling Salesman Problem

22

dapat dipecahkan dengan Least Cost Branch and Bound

Langkah-langkah penyelesaian
- Gambarkan problem dengan weigthed digraph G={V,E}
- C(i,j) = nilai (cost) pada edge <i,j>, dimana C(i,j)= , jika tidak ada edge
antara i dan j.
- Dengan definisi nilai (cost) di atas, bangun Cost Matrix dari TSP.
- Lakukan reduksi terhadap Cost Matrix, didapat Reduced Cost Matrix.
- Gunakan fungsi pembatas (bound), untuk membangun Search Tree dari
Reduced Cost Matrix.
- Dan seterusnya hingga didapat set solusi yang diinginkan.
C.

Strategi solusi atas-bawah, metode

yang termasuk ke dalam strategi ini adalah Algoritma
Divide and Conquer.
Algoritma Divide and Conquer merupakan algoritma yang sangat populer di
dunia Ilmu Komputer. Divide and Conquer merupakan algoritma yang berprinsip
memecah-mecah permasalahan yang terlalu besar menjadi beberapa bagian kecil
sehingga lebih mudah untuk diselesaikan. Langkah-langkah umum algoritma
Divide and Conquer :

Divide : Membagi masalah menjadi beberapa upa-masalah yang memiliki

kemiripan dengan masalah semula namun berukuran lebih kecil ( idealnya
berukuran hampir sama ).

Conquer : Memecahkan ( menyelesaikan ) masing-masing upa-masalah

( secara rekursif ).

Combine : Menggabungkan solusi masing-masing upa-masalah sehingga

membentuk solusi masalah semula.

Objek masalah yang di bagi adalah masukan (input) atau instances yang
berukuran n: tabel (larik), matriks, dan sebagainya, bergantung pada masalahnya.
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. Sesuai dengan karakteristik
pembagian dan pemecahan masalah tersebut, maka algoritma ini dapat berjalan
baik pada persoalan yang bertipe rekursif (perulangan dengan memanggil dirinya
sendiri). Dengan demikian, algoritma ini dapat diimplementasikan dengan cara
23

iteratif ( perulangan biasa ), karena pada prinsipnya iteratif hampir sama dengan
rekursif. Salah satu penggunaan algoritma ini yang paling populer adalah dalam
hal pengolahan data yang bertipe array ( elemen larik ). Mengapa ? Karena
pengolahan array pada umumnya selalu menggunakan prinsip rekursif atau
iteratif. Penggunaan secara spesifik adalah untuk mencari nilai minimal dan
maksimal serta untuk mengurutkan elemen array. Dalam hal pengurutan ini ada
empat macam algoritma pengurutan yang berdasar pada algoritma Divide and
Conquer, yaitu merge sort, insert sort, quick sort, dan selection sort. Merge sort
dan Quick sort mempunyai kompleksitas algoritma O(n log n). Hal ini lebih baik
jika dibandingkan dengan pengurutan biasa dengan menggunakan algoritma brute
force.
Skema Umum Algoritma Divide and Conquer :
2. Penerapan Algoritma
2.1. Pemecahan Masalah Convex Hull dengan Algoritma Divide and Conquer
Pada penyelasaian masalah pencarian Convex Hull dengan menggunakan
algoritma Divide and Conquer, hal ini dapat dipandang
sebagai generalisasi dari algoritma pengurutan merge sort. Berikut ini merupakan
garis besar gambaran dari algoritmanya:

Pertama-tama lakukan pengurutan terhadap titik-titik dari himpunan S

yang diberika berdasarkan koordinat absis-X, dengan kompleksitas waktu
O(n log n).

Jika |S| 3, maka lakukan pencarian convex hull secara brute-force

dengan kompleksitas waktu O(1). (Basis).

Jika tidak, partisi himpunan titik-titik pada S menjadi 2 buah himpunan A

dan B, dimana A terdiri dari setengah jumlah dari |S| dan titik dengan
koordinat absix-X yang terendah dan B terdiri dari setengah dari jumlah |S|
dan titik dengan koordinat absis-X terbesar.

Secara rekursif lakukan penghitungan terhadap HA = conv(A) dan HB =

conv(B).

Lakukan penggabungan (merge) terhadap kedua hull tersebut menjadi

convex hull, H, dengan menghitung da mencari upper dan lower tangents
untuk HA dan HB dengan mengabaikan semua titik yang berada diantara
dua buah tangen ini.

Permasalahan convex hull adalah sebuah permasalahan yang memiliki aplikasi

terapan yang cukup banyak, seperti pada permasalahan grafika komputer, otomasi
desain, pengenalan pola (pattern recognition), dan penelitian operasi. Divide and
24

Conquer adalah metode pemecahan masalah yang bekerja

masalah menjadi beberapa upa-masalah yang lebih
menyelesaikan masing-masing upa-masalah tersebut secara
akhirnya menggabungkan solusi masing-masing upa-masalah
solusi dari masalah semula.

dengan membagi
kecil, kemudian
independent, dan
sehingga menjadi

Algoritma Divide and Conquer merupakan salah satu solusi dalam penyelesaian
masalah convex hull. Algoritma ini ternyata memiliki kompleksitas waktu yang
cukup kecil dan efektif dalam menyelesaikan permasalahan ini (jika dibandingkan
algoritma lain). Selain itu juga, algoritma ini dapat digeneralisasi untuk
permasalahan convex hull yang berdimensi lebih dari 3.
2.2. Persoalan Minimum dan Maksimum (MinMaks)
Persoalan : Misalnya diketahui table A yang berukuran n eleman sudah berisi nilai
integer. Kita ingin menentukan nilai minimum dan nilai maksimum sekaligus di
dalam table tersebut. Misalkan tabel A berisi elemen-elemen sebagai berikut :
Ide dasar algoritma secara Divide and Conquer :

Ukuran table 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.
Algoritma MinMaks :
1. Untuk kasus n = 1 atau n = 2,
SOLVE : Jika n = 1, maka min = maks = An. Jika n = 2, maka bandingkan kedua
elemen untuk menentukan min dan maks.
2. Untuk kasus n > 2,

DIVIDE : Bagi dua table A secara rekursif menjadi dua bagian yang
berukuran sama, yaitu bagian kiri dan bagian kanan.

CONQUER : Terapkan algoritma Divide and Conquer untuk masingmasing bagian, dalam hal ini min dan maks dari table bagian kiri
dinyatakan dalam peubah min1 dan maks1, dan min dan maks dari table
bagian kanan dinyatakan dalam peubah min2 dan maks2.

COMBINE : Bandingkan min1 dan min2 untuk menentukan min table A,

serta bandingkan maks1 dan maks2 untuk menentukan maks table A.

25

2.3. Optimasi Konversi Bilangan Desimal Ke Biner

Salah satu cara optimasi yang bias kita lakukan adalah membagi bilangan decimal
yang hendak diubah dengan angka 8 ( bukan 2 ). Di sinilah prinsip algoritma
Divide and Conquer kita gunakan untuk melakukan optimasi. Kita pecah-pecah
angka decimal yang akan kita gunakan dengan cara membaginya dengan angka 8
secara berulang. Angka-angka sisa pembagian yang kita peroleh kemudian kita
ubah ke dalam bilangan biner sebelum kita gabungkan menjadi hasil jawaban.
Karena angka pembagi yang kita pakai adalah 8 (23), maka kita dapat
mengurangijumlah pembagian yang kita lakukan menjadi 1/3 dari jumlah
semula. Hal ini tentu saja akan sangat berpengaruh pada kinerja dan waktu yang
diperlukan oleh computer mengingat proses pembagian merupakan salah satu
proses yang cukup rumit.
Tentu saja optimasi ini harus kita bayar dengan menangani konversi bilangan octal
ke biner. Akan tetapi jika kita gunakan teknik perbandingan ( tanpa harus
melakukan konversi secara manual ), maka proses ini akan menjadi sangat cepat
dan mudah. Penerapan algoritma ini adalah dengan menggunakan sintaks case of.
Begitu juga dengan permasalahan pemakaian memori ( kompleksitas ruang ) yang
lebih besar yang muncul akibat penggunaan algoritma rekursif. Karena pada
proses rekursif-nya kita tidak banyak menggunakan variable yang memerlukan
tempat yang begitu besar, maka hal ini bias kita abaikan. Dengan penggunaan
optimasi ini, maka seharusnya proses konversi akan lebih cepat karena
pemangkasan jumlah pembagian yang dilakukan.
Skema procedur utama Konversi dengan optimasi
Skema procedur rekursif dengan menerapkan Algoritma Divide and Conquer
Kompleksitas waktu algoritma :
T(n) = O(n/3)
dengan n menyatakan eksponen terkecil dari 2 yang mempunyai nilai 2n lebuh
besar dari angka decimal
Algoritma konversi system bilangan dengan menggunakan algoritma dengan
optimasi yang menerapkan algoritma Divide and Conquer lebih mangkus daripada
algoritma konversi dengan metode pembagian sisa biasa jika dilihat dari segi
kompleksitas waktunya. Hanya saja optimasi ini diimbangi dengan kenaikan pada
kompleksitas ruangnya, meskipun pengaruhnya tidak sebesar optimasi yang kita
lakukan.
2.4. Mencari Pasangan Titik yang Jaraknya Terdekat ( Closest Pair )

26

Persoalan : Diberikan himpunan titik, P, yang terdiri dari n buah titik, (xi,yi), pada
bilangan 2-D. Tentukan jarak terdekat antara dua buah titik di dalam himpunan P.
Jarak dua buah titik p1 = (x1, y1) dan p2 = (x2, y2) :
Penyelesaian dengan Algoritma Divide and Conquer :
a. Asumsi : n = 2k dan titik-titik diurut berdasarkan absis (x).
b. Algoritma Closest Pair :
SOLVE : jika n = 2, maka jarak kedua titik dihitung langsung dengan rumus
Euclidean.
DIVIDE : Bagi titik-titik itu ke dalam dua bagian, PLeft dan PRight, setiap
bagian mempunyai jumlah titik yang sama
CONQUER :Secara rekursif, terapkan algoritma D-and-C pada masingmasing
bagian.
Pasangan titik yang jaraknya terdekat ada tiga kemungkinan letaknya :

Pasangan titik terdekat terdapat di bagian PLeft.

Pasangan titik terdekat terdapat di bagian PRight.

Pasangan titik terdekat dipisahkan oleh garis batas L, yaitu satu titik di
PLeft dan satu titik di PRight.

Jika kasusnya adalah (c), maka lakukan tahap COMBINE untuk mendapatkan
jarak dua titik terdekat sebagai solusi persoalan semula.

D.

Strategi solusi bawah-atas, metode

yang termasuk ke dalam strategi ini adalah
Dynamic Programming.
Dynamic

Programming

(selanjutnya

disebut

DP

saja)

merupakan salah satu teknik perancangan algoritma yang

dikembangkan untuk menyelesaikan permasalahan yang sangat
kompleks dengan memecah permasalahan tersebut menjadi
banyak sub-permasalahan. Perbedaan utama DP dengan Divide
and Conquer (selanjutnya disebut D&C) adalah pada DP kita

27

menggunakan kembali hasil kalkulasi sub-masalah yang telah

dilakukan sebelumnya. Apa artinya?
Untuk mempermudah penjelasan, mari kita selesaikan masalah sederhana yang
telah kita bahas berkali-kali: perhitungan bilangan fibonacci. Algoritma untuk
menyelesaikan perhitungan fibonacci secara naif adalah seperti berikut:
def fibonacci(n):
if n <= 2:
hasil = 1
else:
hasil = fibonacci(n - 1) + fibonacci(n - 2)
return hasil

Algoritma fibonacci sederhana seperti di atas dapat dikatakan sebagai algoritma

D&C, karena kita membagikan perhitungan fibonacci ke dua fungsi fibonacci,
sampai didapatkan nilai hasil terkecilnya. Pemanggilan fungsi fibonacci di atas
dapat digambarkan seperti berikut:

Pemanggilan Fungsi Fibonacci

Perhatikan bagaimana f(n2)
dan

f(n3)

dikalkulasikan sebanyak dua kali, dan semakin kita masuk ke dalam pohon
pemanggilan, kita akan melihat semakin banyak fungsi-fungsi yang dipanggil
berkali-kali. Pendekatan DP menghindari kalkulasi fungsi yang berulang kali
seperti ini dengan melakukan memoization, yaitu menyimpan hasil kalkulasi
fungsi tersebut dan menggunakan nilai yang disimpan ketika perhitungan yang

28

sama dibutuhkan kembali. Dengan menyimpan hasil kalkulasi seperti ini, tentunya
jumlah total langkah perhitungan yang harus dilakukan menjadi berkurang.
Misalnya, kita dapat menyimpan hasil kalkulasi dari fungsi fibonacci tersebut
pada sebuah dictionary, seperti berikut:
memo = dict()
def fibonacci_dp(n):
if n in memo.keys():
return memo[n]
elif n <= 2:
hasil = 1
else:
hasil = fibonacci_dp(n - 1) + fibonacci_dp(n - 2)
memo[n] = hasil
return hasil

Dengan menyimpan hasil kalkulasi dari fungsi yang telah ada, maka proses
pemanggilan fungsi akan menjadi seperti berikut:

Pemanggilan Fungsi Fibonacci Dynamic Programming

Seperti yang dapat dilihat, pohon pemanggilan fungsi terpotong setengahnya!
Tentunya perhitungan fibonacci akan menjadi sangat efisien dengan menggunakan
fungsi yang baru ini.
Pendekatan lain dalam menghitung fibonacci lagi, yang masih adalah DP, yaitu
dengan menghitung nilai fibonacci dari bawah pohon (pada kode sebelumnya kita
melakukan perhitungan dari atas pohon):
def fibonacci_dp_bu(n):

29

memo = dict()
for i in range(1, n + 1):
if i <= 2:
hasil = 1
else:
hasil = memo[i - 1] + memo[i - 2]
memo[i] = hasil
return memo[n]

Untuk melihat efek langsung dari ketiga fungsi tersebut, coba jalankan ketiga
fungsi tersebut untuk n yang sama, dan lihat perbedaan waktu eksekusinya!
Sebagai latihan tambahan, hitung juga kompleksitas dari ketiga fungsi
perhitungan fibonacci tersebut.
Mari kita rangkum hal yang telah kita pelajari mengenai DP sejauh ini:
1. DP menyelesaikan masalah dengan memecah masalah
menjadi sub-permasalahan.
2. Setiap solusi dari sub-permasalahan yang telah didapatkan
disimpan untuk digunakan kembali jika terdapat subpermasalahan yang sama. Teknik ini dikenal dengan nama
memoization.
3. DP tidak harus menggunakan rekursif. Pemecahan subpermasalahan juga dapat dilakukan dengan iterasi maupun
kalkulasi sederhana.

Contoh Aplikasi Dynamic Programming: Text Justification

Kegunaan utama dari DP adalah untuk menyelesaikan masalah optimasi.
Permasalahan optimasi artinya permasalahan yang mencari nilai terbaik, baik
maksimal maupun minimal, dari sebuah solusi. Salah satu contoh paling praktis
dalam penerapan DP model ini adalah algoritma untuk membuat teks rata tengah.
Bagaimana cara kerja algoritma ini? Mari kita lihat masalah yang ingin
diselesaikan terlebih dahulu.
Pada aplikasi pengolah kata seperti Microsoft Word, biasanya terdapat fitur untuk
menentukan kemerataan teks yang ada pada paragraf, seperti yang nampak pada
gambar di bawah:

30

Fitur Pemerataan Teks pada Microsoft Word

Bagaimana kita menentukan kemerataan teks? Secara umum, kemerataan sebuah
teks ditentukan oleh beberapa hal berikut:
1. Ukuran dari halaman, yang tentunya akan mempengaruhi
berapa lebar maksimal dari sebuah teks.
2. Ukuran setiap kata yang ada dalam teks, untuk
menghitung berapa banyak kata yang dapat dimasukkan
ke dalam satu baris teks.
3. Ukuran spasi dalam teks, seperti ukuran kata, untuk
menghitung jumlah kata yang dapat dimasukkan ke dalam
teks.
4. Ukuran karakter-karakter khusus seperti !, ?, ,,.,
dan lainnya. Meskipun biasanya berukuran kecil, karakter
khusus tetap berperan dalam mengisi ruang tulisan.
Dengan melakukan kalkulasi sederhana dari teks, tentunya kita bisa saja
melakukan pemerataan teks dengan mudah. Misalnya, untuk menghitung total
teks yang dapat masuk ke dalam sebuah baris tulisan, kita dapat menggunakan
persamaan berikut:

ukuran halamantotal ukuran kata+total ukuran

spasi+total ukuran simbol
Sehingga untuk membuat sebuah teks menjadi rata penuh (justified) kita dapat
memasukkan setiap kata, spasi, dan simbol satu demi satu sampai kita memenuhi
sebuah baris. Jika kata selanjutnya tidak lagi memiliki ukuran yang cukup, maka
kita dapat menambahkan spasi di tengah-tengah kata sebelumnya sampai baris
penuh, dan lalu berpindah baris.
31

Secara sederhana, algoritma naif untuk melakukan rata penuh teks adalah seperti
berikut:
1. Ambil satu elemen dalam teks, baik berupa kata, simbol, maupun spasi.
Masukkan elemen ini ke dalam baris.
2. Hitung ukuran baris sekarang.
3. Ambil satu elemen lagi dalam teks, dan hitung ukurannya.
4. Tambahkan ukuran baris sekarang dengan ukuran elemen berikutnya.
Hasil pengukuran ini selanjutnya akan disebut Ukuran Baris Selanjutnya
atau UBS.
5. Cek nilai UBS:
1. Jika UBS masih lebih kecil dari lebar halaman, kembali ke langkah
1
2. Jika UBS sudah lebih dari lebar halaman:
1.

Tambahkan spasi di antara setiap kata dalam

baris sampai ukuran baris sama dengan lebar
halaman.

Secara kasar, algoritma di atas dapat diimplementasikan seperti kode berikut

(yang jelas tidak dapat dijalankan):
def naive_justify(text, page_size):
next = text.get_next()
total_size = 0
next_total_size = total_size + next.size()
lines = [[next]]
current_line = 0
while(!text.empty()):
while(next_total_size < page_size):
total_size = next_total_size
next = text.get_next()
lines[current_line].push(next)
next_total_size = total_size + next.size()
while total_size != page_size:
add_space(lines[current_line])
current_line = current_line + 1

32

Hasil algoritma di atas kurang optimal, karena ketika terdapat kata-kata yang
panjang dalam sebuah kalimat, kita terpaksa harus memotong baris terlalu cepat,
dan akhirnya menambahkan banyak spasi. Contoh eksekusi dari algoritma di atas
dapat dilihat pada gambar berikut:

Hasil Algoritma Pemerataan Teks Sederhana

Perhatikan bagaimana teks Dynamic Programming, dikembangkan untuk, dan
memecah permasalahan memiliki spasi yang sangat lebar. Menggunakan DP,
kita dapat menghasilkan pemerataan teks yang lebih optimal.
Berdasarkan algoritma sebelumnya yang kita kembangkan, dapat dilihat
bagaimana optimasi dari rata penuh sebuah teks terdapat pada kapan kita
melakukan pergantian baris. Jika kita mengganti baris terlalu cepat (jumlah kata
masih sedikit), maka secara otomatis kita harus menambahkan banyak spasi, yang
menyebabkan teks tidak enak dilihat. Untuk mendapatkan jumlah kata yang
optimal dalam sebuah baris, kita akan melakukan perhitungan tingkat
keburukan sebuah kata dalam teks, jika kata tersebut dijadikan pengganti baris.
Kita kemudian dapat mencari tingkat keburukan setiap kata yang ada dalam teks,
dan mengambil kata yang memiliki tingkat keburukan terendah sebagai tanda
berganti baris.

33

Pengukuran tingkat keburukan teks sendiri tentunya ditentukan oleh jumlah ruang
kosong yang ada dari teks sampai ke ujung halaman. Misalnya, pada gambar di
bawah kita dapat melihat contoh ruang kosong dari teks sampai ke ujung halaman:

Tingkat Keburukan Teks

Pada gambar di atas, blok berwarna merah berarti tingkat keburukannya tinggi,
dan blok berwarna hijau berarti tingkat kebukurannya rendah. Untuk mendapatkan
nilai keburukan yang paling kecil dalam sebuah teks, tentunya kita harus
menghitung seluruh kombinasi nilai keburukan dari elemen-elemen yang ada
dalam teks. Perhitungan kombinasi nilai keburukan ini tentunya merupakan
masalah yang tepat untuk algoritma DP, karena setiap perhitungan nilai keburukan
pada dasarnya adalah sebuah sub-masalah!
Jadi sekarang kita telah menemukan sub-masalahnya: mencari nilai keburukan
dari sebuah elemen. Bagaimanakah kita dapat menggunakan teknik DP untuk
menyelesaikan masalah ini? Ketika menghitung kombinasi dari nilai keburukan
dari setiap elemen, secara tidak langsung kita akan membangun sebuah Directed
Acyclic Graph, seperti yang tampak pada gambar berikut:

DAG dalam Teks

dengan setiap k
merepresentasikan tingkat keburukan dari elemen tersebut. Menggunakan
informasi tersebut, kita dapat mencari nilai minimal dari total seluruh nilai
keburukan yang ada pada sebuah teks untuk mendapatkan titik penggantian baris
yang paling tepat. Untuk merangkum, berikut adalah langkah-langkah untuk
algoritma yang sedang kita kembangkan:
34

1. Ambil setiap elemen dari dalam teks.

2. Untuk setiap elemen yang ada, lakukan: 1. Hitung nilai
keburukan dari elemen terhadap elemen-elemen lain
dalam teks. 2. Hitung total nilai keburukan yang ada pada
elemen yang sedang dicari.
3. Tentukan nilai keburukan minimum dari nilai keburukan
seluruh elemen yang telah dihitung pada langkah 2.
4. Ambil elemen yang memiliki nilai keburukan minimum.
5. Ganti baris pada elemen dengan nilai keburukan minimum.
Perhitungan nilai keburukan sendiri dapat dilakukan dengan menggunakan rumus
sederhana berikut:

keburukan(i,j)={ukuran baris>lebar halaman(lebar

halamanukuran baris)3
dengan i
dan

sebagai awal dan akhir dari kata yang ingin dihitung tingkat keburukannya. Jika
dijadikan kode program, algoritma tersebut dapat dituliskan seperti berikut:
def length(word_lengths, i, j):
return sum(word_lengths[i- 1:j]) + j - i + 1
def break_line(text, L):
# wl = lengths of words
wl = [len(word) for word in text.split()]
# n = number of words in the text
n = len(wl)
# total badness of a text l1 ... li
m = dict()
m[0] = 0

35

s = dict()
for i in range(1, n + 1):
sums = dict()
k = i
while (length(wl, k, i) <= L and k > 0):
# badness calculation
sums[(L - length(wl, k, i))**3 + m[k - 1]] = k
k -= 1
m[i] = min(sums)
s[i] = sums[min(sums)]
return s

Perlu dicatat bahwa kode di atas belum mengikut sertakan spasi dalam
perhitungan, dan juga belum membangun kembali baris-baris yang telah dipecah
menjadi sebuah teks (paragraf).

36

BAB III
PENUTUP

Kesimpulan
Algoritma Simplified-Memory A* bias mengoptimalkan pencarian. Hal ini
dikarenakan algoritma tersebut dapat menyelesaikan solusi dengan menggunakan
solusi yang telah ada sebelumnya. Sedangkan algoritma greedy tidak dapat
memperhitungkan kebenaran biayanya. Seeara optimality, algoritma greedy tidak
selalu dapat menemukan solusi yang terbaik karena diperlukan pengeeekan
langkah langkah algoritma yang berulang-ulang, sehingga tidak menghemat
waktu untuk mendapatkan solusi yang terbaik dan beberapa solusi yang telah
terbentuk. Walaupun greedy eukup terkenal dan favorit untuk kasus penearian
optimasi, tetapi dalam kasus di atas, greedy dengan Greedy-Best First search-nya
masih kurang efektif dibandingkan dengan algoritma Simplified-Memory
Algoritma hanyalah algoritma, yaitu hanyalah sebuah proses yang
mungkin dapat menyelesaikan sebuab masalah. Seperti pengertian heuristik yang
telah dijelaskan sebelumnya. Mungkin jika itu masalah perhitungan soal dapat
diselesaikan. Tetapi jika itu masalah dunia nyata yang tidak akan lepas dan
perubahan seeara dinamis, solusi pun akan cepat bergantian.
Oleh karena itu, pengembangan dan modifikasi algoritma dalam beberapa
kasus sangatlah penting dan patut untuk dieoba.

37

DAFTAR PUSTAKA
https://www.academia.edu/7369726/Backtracking_Algorithm
https://torikiri.wordpress.com/2013/09/10/algoritma-brute-force-dalam-pencarianstring/
http://bertzzie.com/knowledge/analisis-algoritma/Greedy.html
http://azistakata.blogspot.co.id/2014/03/algoritma-branch-and-bound.html
http://bertzzie.com/knowledge/analisis-algoritma/DynamicProgramming.html
https://andikafisma.wordpress.com/algoritma-divide-and-conquer/

38