DAFTAR ISI

DAFTAR ISI......................................................................................................................i
DAFTAR GAMBAR.......................................................................................................ii
BAB 1................................................................................................................................1
PENDAHULUAN............................................................................................................1
1.1 Tujuan..............................................................................................................................1
1.2 Latar Belakang................................................................................................................1
1.3 Alat dan Bahan................................................................................................................2
BAB 2................................................................................................................................3
TINJAUAN PUSTAKA..................................................................................................3
2.1 Algoritma Divide and Conquer......................................................................................3
2.2 Penerapan Algoritma......................................................................................................4
2.2.1 Pemecahan Masalah Convex Hull dengan Algoritma Divide and
Conquer...........................................................................................................4
2.2.2 Optimasi Konversi Bilangan Desimal Ke Biner............................5
BAB 3................................................................................................................................6
LANGKAH-LANGKAH PRAKTIKUM......................................................................6
3.1 Skema umum Divide and Conquer................................................................................6
3.2 Solusi dari masalah semula............................................................................................6
3.3 Nilai Maks dan Min menggunakan Metode Brute Force.............................................7
3.4 Nilai Maks dan Min........................................................................................................8
3.5 Mencari jarak terdekat sepasang titik didalam himpunan p......................................9
3.6 Pengurutan....................................................................................................................10
3.7 Prosedur MasgeSort.....................................................................................................10
3.8 Prosedur Marge............................................................................................................11
3.9 Insertion sort 1..............................................................................................................13
3.10 Insertion Sort 2..............................................................................................................14
BAB 4..............................................................................................................................15
ANALISA & PEMBAHASAN.....................................................................................15
4.1 Knapsack.......................................................................................................................15

i
 4.2 Tracer............................................................................................................................17
BAB 5..............................................................................................................................19
KESIMPULAN..............................................................................................................19
5.1 Kesimpulan.....................................................................................................................20
REFERENSI....................................................................................................................21

DAFTAR GAMBAR

Gambar 4.1 Input Knapsack ……………………………………………………. 12

Gambar 4.2 Output Knapsack ………………………………………………….. 13

ii
 BAB 1
PENDAHULUAN

1.1 Tujuan
1. Mahasiswa mampu memahami pengertian Algoritma Knapsack

2. Mahasiswa mampu menyelesaikan problema knapsack serta penerapannya

1.2 Latar Belakang

Catur adalah sebuah permainan pikiran yang menggunakan bidak dan
papan sebagai alat permainan. Permainan catur dapat dinikmati oleh siapa saja
karena cara bermain yang menarik dan dapat dipahami oleh siapa saja. Permainan
catur sudah banyak mengalami adaptasi ke dalam berbagai bidang seperti bidang
komputer. Pada aplikasi game komputer, catur menggunakan command & control
dalam penerapannya, yaitu menggunakan keyboard atau mouse untuk
menggerakannya. Agar permainan catur pada komputer dapat dinikmati atau
digunakan oleh siapa saja, jika mengganti penggunaan keyboard dan mouse
menjadi perintah suara, game catur tersebut lebih dapat memfasilitasi atau
menunjang banyak orang, bahkan oleh orang – orang berkebutuhan khusus (cacat
fisik), karena cacat fisik merupakan hal yang seringkali dianggap suatu bencana
bagi individu yang mengalaminya [9] dan membuat individu tersebut, kesulitan
dalam melakukan sesuatu karena tidak ada fasilitas yang memadai. Proses
perintah suara disebut juga dengan proses pengenalan suara. Proses pengenalan
suara adalah salah satu cabang dari kecerdasan buatan yang memungkinkan
komputer untuk dapat menerima masukan berupa kata yang diucapkan. Speech
Recognition merupakan salah satu proses pengenalan suara yang tidak
mempedulikan identitas orang yang mengucapkannya [3]. Speech Recognition
dapat diterapkan pada aplikasi – aplikasi yang menghasilkan hasil akhir berupa
perintah (Command & control) dan aplikasi yang memungkinkan mengganti
peranan keyboard dan mouse menjadi suara. Salah satu aplikasi yang menerapkan
hal tersebut adalah game. Pada proses pengenalan suara, terdapat proses
pengolahan sinyal suara yang bertujuan agar komputer dapat mengenali suara
masukan oleh user. Proses pencocokkan merupakan salah satu proses pengenalan
suara yang sangat penting, karena sinyal suara yang dimasukan oleh user akan
dicocokan dengan data pada 2 basis data. Hasil pencocokkan tersebut akan
menjadi hasil akhir berupa suatu aksi atau gerakan yang akan dilakukan oleh
komputer. Maka dari itu, proses pencocokkan sangat membutuhkan suatu metode
yang sangat akurat dalam mengenali suatu data. Metode yang dapat diterapkan

1
untuk melakukan pencocokkan, seperti Divide and Conquer dan Euclidean
Distance. Divide and Conquer merupakan algoritma yang berprinsip memecah –
mecah dahulu permasalahan yang besar menjadi bagian – bagian terkecil sehingga
lebih mudah diselesaikan. Masalah yang bisa diselesaikan seperti pada masalah
array 1 atau 2 dimensi yang mencari pasangan titik yang jaraknya terdekat atau
disebut juga Closest pair. Pada penelitian Khrisna Nugraha [8], beliau berhasil
menerapkan Divide and Conquer sebagai metode pencocokkan suara. Euclidean
distance merupakan metode perhitungan 2 buah titik dalam Euclidean space.
Euclidean space berkaitan dengan Teorema Phytagoras dan biasanya diterapkan
pada suatu template array yang berbasis 1, 2 atau 3 dimensi. Tapi juga sederhana
jika diterapkan pada dimensi yang lebih tinggi [2]. Pada penelitian Damayanti Eva
[1], beliau berhasil menerapkan Euclidean distance sebagai metode pencocokkan
suara. Berdasarkan kesamaan kedua metode yang dapat diterapkan pada suatu
array 1 atau 2 dimensi dan telah berhasil diterapkan sebagai algoritma
pencocokkan suara pada penelitian sebelumnya, maka kedua algoritma tersebut
akan diterapkan pada suatu aplikasi pengenalan suara, lalu akan dilakukan
perbandingan. Tujuan dilakukannya perbandingan adalah untuk mengukur
ketepatan atau keakuratan dalam perhitungan dan pencocokkan pada suatu sistem
pengenalan suara. Berdasarkan hal – hal yang sudah dibahas sebelumnya maka
akan dibangun aplikasi game catur yang membandingkan hasil implementasi
Divide and Conquer dan Euclidean distance sebagai pencocokkan pola suara.
Diharapkan dengan adanya penelitian ini, dapat mengetahui algoritma manakah
yang akan melakukan proses pencocokkan pola suara lebih baik pada nilai
keakuratannya dan menentukan metode yang lebih baik untuk diterapkan pada
Speech Recognition terhadap game catur (Turfan, D., Aladag, C.H. dan Yeniay,
O.2012)

1.3 Alat dan Bahan

 Laptop / PC
 Software Dev C++

2
 BAB 2
TINJAUAN PUSTAKA

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

3
1.5 Penerapan Algoritma
1.5.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
Conquer adalah metode pemecahan masalah yang bekerja dengan membagi
masalah menjadi beberapa upa-masalah yang lebih kecil, kemudian
menyelesaikan masing-masing upa-masalah tersebut secara independent, dan
akhirnya menggabungkan solusi masing-masing upa-masalah sehingga menjadi
solusi dari masalah semula.

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.

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

5
 BAB 3
LANGKAH-LANGKAH PRAKTIKUM

1.6 Skema umum 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/k

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

1.7 Solusi dari masalah semula

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

6
 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

1.8 Nilai Maks dan Min menggunakan Metode Brute Force

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

7
 if Ai > maks then

maksAi

endif

endfor

1.9 Nilai Maks dan Min

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

8
 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maks2

endif

1.10 Mencari jarak terdekat sepasang titik didalam himpunan p

procedure FindClosestPair2(input P: SetOfPoint, n : integer,
output delta : real)

{ Mencari jarak terdekat sepasang titik di dalam himpunan P. }

Deklarasi:
DeltaLeft, DeltaRight : real

Algoritma:
if n = 2 then
delta  jarak kedua titik dengan rumus Euclidean
else
P-Left {p1, p2 ,..., pn/2 }
P-Right  {pn/2+1, pn/2+2 ,..., pn }
FindClosestPair2(P-Left, n/2, DeltaLeft)
FindClosestPair2(P-Right, n/2, DeltaRight)
delta  minimum(DeltaLeft, DeltaRight)
{--***********************************************************--}
Tentukan apakah terdapat titik pl di P-Left dan pr di P-Right
Dengan jarak(pl, pr) < delta. Jika ada, set delta dengan jarak

9
 terkecil tersebut.
{--***********************************************************--}
endif

for ji+1 to s do
exit when (|qi.x – qj.x | > Delta or |qi.y – qj.y | > Delta
if jarak (qi, qj) < Delta then
Delta  jarak(qi, qj) { dihitung dengan rumus Euclidean }
endif
endfor
endfor

1.11 Pengurutan
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

1.12 Prosedur MasgeSort

procedure MergeSort(input/output A : TabelInt, input i, j : integer)

{ Mengurutkan tabel A[i..j] dengan algoritma Merge Sort

Masukan: Tabel A dengan n elemen

10
 Keluaran: Tabel A yang terurut

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

1.13 Prosedur Marge

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

11
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

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

1.14 Insertion sort 1

procedure InsertionSort(input/output A : TabelInt,

input i, j : integer)

{ Mengurutkan tabel A[i..j] dengan algoritma Insertion Sort.

Masukan: Tabel A dengan n elemen

Keluaran: Tabel A yang terurut

Deklarasi:

k : integer

Algoritma:

if i < j then { Ukuran(A)> 1}

ki

InsertionSort(A, i, k)

InsertionSort(A, k+1, j)

Merge(A, i, k, j)

endif

13
1.15 Insertion Sort 2
procedure InsertionSort(input/output A : TabelInt,

input i, j : integer)

{ Mengurutkan tabel A[i..j] dengan algoritma Insertion Sort.

Masukan: Tabel A dengan n elemen

Keluaran: Tabel A yang terurut

Deklarasi:

k : integer

Algoritma:

if i < j then { Ukuran(A)> 1}

ki

Insertion(A, k+1, j)

Merge(A, i, k, j)

endif

BAB 4
ANALISA & PEMBAHASAN
1.16 Knapsack
Input:

14
 Gambar 4.1 Syntax Knapsack

Output:

15
 Gambar 4.2 Output Knapsack

Analisa:

Setelah menyelesaikan percobaan tersebut, dapat di simpulkan bahwa

permasalahan Knapsack merupakan suatu masalah bagaimana cara menentukan
keuntungan maksimum dari sekumpulan barang. Dimana setiap keuntungan
tersebut memiliki berat dan keuntungan masing-masing, sehingga dari pemilihan
tersebut didapatkan keuntungan yang maksimum.

Lalu untuk menyelesaikan algoritma 0/1 knapsack dengan metode

program dinamis akan dibentuk sebuah matrix dan nilai matrix diisi sesuai alur
program. Sedangkan solusi optimum algoritma 0/1 Knapsack dengan metode
program dinamis dapat dilihat pada nilai terakhir, yaitu nilai terbawah disisi kanan
matrix, nilai tersebut merupakan jumlah profit keuntungan maksimum yang
didapatkan.

1.17 Tracer

Pembuktian K[0][0] Sampai K[0][4]

16
Perhitungan K[0][0] :
for (w = 0; w <= W; w++)
{
if (i==0 || w==0)
K[0][1] = 0;

Perhitungan K[0][1] :
for (w = 0; w <= W; w++)
{
if (i==0 || w==1)
K[0][1] = 0;

Perhitungan K[0][2] :
for (w = 0; w <= W; w++)
{
if (i==0 || w==3)
K[0][3] = 0;

Perhitungan K[0][3] :
for (w = 0; w <= W; w++)
{
if (i==0 || w==1)
K[0][3] = 0;

Perhitungan K[0][4] :
for (w = 0; w <= W; w++)
{
if (i==0 || w==1)
K[0][4] = 0;

Selanjutnya pembuktian
perhitungan K[1][0]:

Perhitungan K[1][0] :
for (w = 0; w <= W; w++)
{
if (i==1 || w==0)
K[1][0] = 0;

Perhitungan K[1][1] :

17
for (w = 0; w <= W; w++)
{
if (i==1 || w==1)
K[1][1] = 0;

Perhitungan K[1][2] :
for (w = 0; w <= W; w++)
{
if (i==1 || w==2)
K[1][2] = 0;

Perhitungan K[1][3] :
for (w = 0; w <= W; w++)
{
if (i==1 || w==3)
K[1][3] = 0;

Dan seterusnya sampai tahap pertama K[1][4]

Selanjutnya pembuktian
perhitungan K[2][0]
sampai K[2][4]:

Perhitungan K[2][0] :
for (w = 0; w <= W; w++)
{
if (i==2 || w==0)
K[2][0] = 0;
Perhitungan K[2][1] :
for (w = 0; w <= W; w++)
{
if (i==2 || w==1)
K[2][1] = 0;

Perhitungan K[2][2] :
for (w = 0; w <= W; w++)
{
if (i==2 || w==2)
K[2][2] = 0;

18
 Perhitungan K[2][3] :
for (w = 0; w <= W; w++)
{
if (i==2 || w==3)
K[2][3] = 0;

Perhitungan K[2][4] :
for (w = 0; w <= W; w++)
{
if (i==2 || w==4)
K[2][4] = 7;

BAB 5
KESIMPULAN

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

19
 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
Conquer adalah metode pemecahan masalah yang bekerja dengan membagi
masalah menjadi beberapa upa-masalah yang lebih kecil, kemudian
menyelesaikan masing-masing upa-masalah tersebut secara independen, dan
akhirnya menggabungkan solusi masing-masing upamasalah sehingga menjadi
solusi dari masalah semula.

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

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.

REFERENSI

20
Anagun, A.S. dan Sarac, T., Optimization performance of genetics algorithm for
0-1 knapsack problems using taguchi method. Lect. Notes Comput. Sc.,
Vol. 3982, pp. 678-687, 2006.

Gen, M. dan Cheng, R., Genetic Algorithms and Engineering Optimization,

Canada, John Wiley & Sons, Inc., 2000.

Olsen, A.L., Penalty functions and the knapsack problem. Evolutionary

Computation, IEEE World Congress on Computational Intelligence
Proceedings of the First IEEE Conference on IEEE, 1994.

Rinaldi Munir, Algoritma Divide and Conquer. Teknik Informatika Institut

Teknologi Bandung, 2004.

Rinaldi Munir, Strategi Algoritmik. Teknik Informatika Institut Teknologi

Bandung, 2007.

Syarif, A., Algoritma Genetika; Teori dan Aplikasi Edisi 2, Yogyakarta, Graha
Ilmu, 2014.

Turfan, D., Aladag, C.H. dan Yeniay, O., A new genetic algorithm to solve
knapsack problems, Journal of Social and Economic Statistics, Vol. 1, No.
2, 2012.

Zhao, J., Huang, T., Pang, F. dan Liu, Y., Genetic algorithm based on greedy
strategy in the 0-1 knapsack problem, Third International Conference on
Genetic and Evolutionary Computing IEEE, 2009.

Zukhri, Z., Algoritma Genetika : Metode Komputasi Evolusioner dan

Menyelesaikan Masalah Optimasi, Yogyakarta, Andi Offset, 2013.

21