MAKALAH KECERDESAN BUATAN

Dosen: Dony Novaliendry, M.kom.

“DEVIDE AND CONQUER”

Disusun Oleh Kelompok 4:

Dyospa Defki Illahi (17076098)

Faris Syafiq Sujana (17076102)
Nadya Prima (17076071)
Noval Yusri Yandi (17076072)

Teknik Elektronika
Pendidikan Teknik Informatika

Universitas Negeri Padang

2019
 KATA PENGANTAR

Puji syukur penulis ucapkan kepada Allah SWT yang telah melimpahkan rahmat dan
karuniah-Nya dengan membuka pintu hati dan pikiran penulis, sehingga penulis dapat
menyelesaikan makalah kelompok yang berjudul “Devide and Conquer”. Penulisan makalah ini
merupakan salah satu syarat untuk memenuhi tugas kelompok mata kuliah Kecerdasan Buatan.
Penulisan makalah ini tidak lepas dari bantuan dari berbagai pihak yang telah
memberikan bimbingan kepada penulis sehingga dapat menyelesaikan makalah. Dalam
kesempatan kali ini penulis mengucapkan terima kasih kepada dosen pembimbing mata kuliah
Kecrdasan Buatan karna telah membimbing penulis sehingga dapat menyelesaikan makalah ini.
Selaku hamba Allah, penulis adalah manusia yang  tidak luput dari kesalahan, sehingga
masih banyak kelemahan baik dari segi materi maupun dalam penyajian penulisan makalah ini.
Untuk itu kritik dan saran dari pembaca sehingga pada penulisan pada masa akan datang bisa
jadi lebih baik.

Padang, 29 Maret 2019

Penulis
DAFTAR ISI
KATA PENGANTAR.................................................................................................................................2
BAB I..........................................................................................................................................................4
PENDAHULUAN.......................................................................................................................................4
1. Latar Belakang.................................................................................................................................4
BAB II.........................................................................................................................................................6
PEMBAHASAN.........................................................................................................................................6
2.2. Devide and Conquer....................................................................................................................6
2.2. STRATEGI DIVIDE AND CONQUER......................................................................................7
2.3. Binary Search..............................................................................................................................8
BAB III......................................................................................................................................................12
KESIMPULAN.........................................................................................................................................12
3..1. Kesimpulan................................................................................................................................12
1..1. Saran..........................................................................................................................................12
DAFTAR PUSTAKA................................................................................................................................13
 BAB I

PENDAHULUAN

1. Latar Belakang
Proses pengenalan kata merupakan salah satu fungsi dari voice recognition. Voice
recognition dibagi menjadi dua jenis, yaitu speech recognition dan speaker recognition.
Berbeda dengan speaker recognition yang merupakan pengenalan identitas yang diklaim
oleh seseorang dari suaranya (ciri khusus dapat berupa intonasi suara, tingkat kedalaman
suara, dan sebagainya), speech recognition adalah proses yang dilakukan komputer untuk
mengenali kata yang diucapkan oleh seseorang tanpa mempedulikan identitas orang
terkait.

Ada beberapa metode yang bisa digunakan dalam pemrosesan sinyal suara dan
pencocokan pola suara. Metode untuk pemrosesan sinyal suara antara lain Mel Frequency
Cepstrum Coefisien (MFCC), Transformasi Wavelet, dan Linear Predictive Coding
(LPC). Untuk metode untuk pencocokan pola suara antara lain Jaringan Saraf Tiruan
(JST), Neuro-Fuzzy, Vector Quantization (VQ), Hidden Markov Model (HMM), Fast
Fourier Transfrom (FFT) dan Divide and Conquer (D&C).

Metode yang akan dibahas dalam penelitian ini adalah pencocokan pola suara
menggunakan algoritma Fast Fourier Transform dan Divide and Conquer. Algoritma Fast
Fourier Transform merupakan metode untuk mentransformasi sinyal suara menjadi sinyal
frekuensi. Artinya proses perekaman suara disimpan dalam bentuk digital berupa
gelombang spektrum suara berbasis frekuensi, dimana sinyal yang sebelumnya berada
dalam domain waktu akan dirubah dalam domain frekuensi. Divide and Conquer
merupakan algoritma yang berprinsip memecah-mecah permasalahan yang terlalu besar
menjadi beberapa bagian kecil sehingga mudah untuk diselesaikan. Alasan algoritma
Divide and Conquer ini digunakan adalah untuk mengetahui hasil pencocokan suara
dengan metode Divide and Conquer dan untuk mengoptimalkan waktu
pencocokan/pencarian sehingga kompleksitas berkurang. Dengan proses awal
mengkonversi data suara ke dalam bentuk bentuk diskrit (sampling), dari bentuk diskrit
inilah diambil fiturnya dengan feature extraction kemudian pencocokan data suara
menggunakan metode Divide and Conquer.
 Pengenalan kata ini dapat diimplementasikan ke dalam berbagai masalah
kehidupan manusia, contohnya adalah sebagai pengontrol suatu sistem seperti peralatan
elektronik pada konsep rumah pintar yang tentunya membuat efisiensi penggunaan waktu
juga menawarkan kemudahan kepada pengguna, apalagi bagi yang mempunyai
keterbatasan fisik. Berdasarkan uraian permasalahan tersebut maka diperlukan
pembangunan aplikasi pengenalan kata dari sebuah perintah suara yang diucapkan dan
dapat dikenali oleh suatu mesin serta diterapkan pada kebutuhan kehidupan manusia, dari
keinginan itulah maka pada penelitian skripsi ini mengambil judul Aplikasi Perintah
Suara Dengan Metode Fast Fourier Transform dan Divide and Conquer Pada Simulasi
Rumah Pintar.

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. Divide and Conquer adalah mengabungkan
solusi masing-masing masalah sehingga membentuk solusi masalah semula.

Terkadang dalam membuat program, ada banyak masalah yang kita temui. Divide
and Conquer yang akan dibahas di makalah ini nanti yang bisa membantu mahasiswa,
pembuat program (programmer), dan yang lain dalam menyelesaikan masalah dalam
suatu program. Maka dari itu kami membuat makalah ini dengan judul Algoritma Divide
and Conquer.
 BAB II

PEMBAHASAN

2.1 Devine and Conquer

Algoritma divide and conquer sudah lama diperkenalkan sebagai sumber dari
pengendalian proses paralel, karena masalah-masalah yang terjadi dapat diatasi secara
independen. Banyak arsitektur dan bahasa pemrograman paralel mendesain
implementasinya (aplikasi) dengan struktur dasar dari algoritmadivide and conquer.
Untuk menyelesaikan masalah-masalah yang besar, dan dibagi (dipecah) menjadi bagian
yang lebih kecil dan menggunakan sebuah solusi untuk menyelesaikan problem awal
adalah prinsip dasar dari pemrograman/strategidivide and conquer.

Divide and conquer adalah varian dari beberapa strategi pemrograman topdown,
tetapi keistimewaannya adalah membuat sub-sub problem dari problem yang besar, oleh
karena itu strategi ini ditunjukkan secara berulang-ulang (recursively), didalam
menerapkan algoritma yang sama dalam sub-sub problem seperti yang diterapkan pada
masalah aslinya (original problem). Sebagaimana prinsip dasar algoritma perulangan
dibutuhkan sebuah kondisi untuk mengakhiri perulangan tersebut. Biasanya untuk
mengecek apakah problem sudah cukup kecil untuk diselesaikan dengan metode secara
langsung. Mungkin dari segi ilustrasi kita, bahwa proses-proses pada komputer paralel
tentunya memiliki proses/problem/job yang cukup kompleks sehingga harus dipecah-
pecah menjadi sub-sub problem.Selain dibutuhkansebuah“kondisi”,juga diperlukan “fase
divide” untuk membagi/memecah problem menjadi sub-sub problem yang lebih kecil,
dan “fase combine“ untuk menggabungkan kembali solusi dari sub-sub problem kedalam
solusi dari problem awalnya. Berikut pseudocode dari strategi divide and conquer:

Pseudocode diatas adalah sebagai acuan dari strategi divide and conquer, tetapi
dalam implementasinya ada beberapa diferensiasi dari bentuk diatas yang akan
digunakan. Sebelum masuk ke pokok pemrograman dengan “Divide and
Conquerstrategy/algorithm”,ada 4 hal penting yang harus dipahami dalam strategi ini
:branching factor,balance,data dependence of divide function dan sequentiality.

 Branching Factor

Branching factor dalam algoritma divide and conquer adalah jumlah dari
subproblem yang akan dibagi dari sebuah problem awal. Ini adalah langkah nyata dari
algoritma divide and conquer, didalam proses pembagian yang sebenarnya, jumlah dari
branching factor harus 2 atau lebih, karena jika tidak problem tidak bisa dibagi. Banyak
jenis algoritma ini termasuk pula algoritma komputasi geometric yang memiliki
branching factor berjumlah 2.

 Balance

Sebuah algoritma divide and conquer dikatakan balance jika problem awal dibagi
menjadi sub-sub problem dengan ukuran yang sama. Yang artinya jumlah dari
keseluruhan ukuran subproblem sama dengan ukuran problem awal (initialproblem).
Algoritma Mergesort dan binary tree, dan sama halnya dengan algoritma reduksi & prefix
sum adalah beberapa contoh algoritma divide andconquer yang seimbang (balance).

 Data Dependence of Divide Function

Algoritma divide and conquer memiliki sebuah fungsi pembagian terhadap data
yang memiliki ketergantungan, artinya jika ukuran relatif dari sebuah algoritma yang
 tidak seimbang, salah satu contohnya adalah algoritma quicksort yang akan membagi
subproblem dengan fungsi data-dependent divide.

 Control Parallelism or Sequentiality

Algoritma divide and conquer dikatakan berurutan (sequential) jika subproblem

dieksekusi sesuai dengan perintah program. Paralelisasi dari algoritma divideand conquer
yang terurut pertama kali didefinisikan oleh Mou’s Divacon[Mou90] yang terjadi ketika
hasil dari salah satu sub-eksekusi diperlukan oleh subeksekusi yang lain. Dalam kasus ini
hasil dari subtree pertama diberikan (passing) kepada proses komputasi subtree kedua,
supaya hasil akhir tersebut bisa digunakan sebagai nilai awalnya, tetapi sekarang ini
contoh diatas tidak dapat dijadikan ilustrasi lagi karena teknologi komputer paralel yang
semakin canggih dan kompleks.

.2. STRATEGI DIVIDE AND CONQUER

Strategi Divide dan Conquer memecah masalah menjadi submasalah-submasalah
independen yang lebih kecil sehingga solusi submasalah-submasalah dapat diperoleh
secara mudah, solusi submasalah-submasalah digabung menjadi solusi seluruh masalah.

Skema umum algoritma divide dan conquer

Procedure DNC ( i,j : integer )

Var K : integer ;
If SMALL (i,j) then SOLVE (i,j)
Else begin
K : = DIVIDE (i,j)
COMBINE (DNC(i,k),DNC(k+1,j))
End if

Keterangan :
1. SMALL adalah fungsi yang mengirim BOOLEAN, menentukan apakah ukuran telah
cukup kecil sehingga solusi dapat diperoleh. . Ukuran dinyatakan sebagai telah berukuran
kecil bergantung masalah.
2. DIVIDE adalah fungsi membagi menjadi 2 bagian pada posisi K. Biasanya bagian
berukuran sama.
3. COMBINE adalah fungsi menggabungkan solusi X dan Y submasalah. Solusi
diperoleh dengan memanggil prosedur rekursif DNC.

Jika ukuran kedua submasalah sama, waktu komputasi DNC dideskripsikan hubungan
rekuren berikut :
T(n) = g (n), n kecil
2 T (n/2) + f (n), selainnya
 dimana :
• T(n) adalah waktu untuk DNC dengan n masukan,
• g(n) adalah waktu komputasi jawaban secara langsung untuk masukan kecil dan
• f(n) adalah waktu COMBINE.

Untuk algoritma divide dan conquer yang menghasilkan submasalah-submasalah

dengan tipe masalah yang sama dengan masalah awal, sangat alami untuk
mendeskripsikan algoritma secara rekursi. Kemudian untuk meningkatkan efisiensi
dilakukan penerjemahan menjadi bentuk iterasi.
Pemakaian teknik Divide dan Conquer banyak digunakan dalam menyelesaikan berbagai
macam persoalan, antara lain:
1. Searching
2. Sorting

.3. Binary Search

Binary Search (Pencarian Biner) dapat dilakukan jika data sudah dalam keadaan
urut. Dengan kata lain, apabila data belum dalam keadaan urut, pencarian biner tidak
dapat dilakukan. Dalam kehidupan sehari-hari, sebenarnya kita juga sering
menggunakan pencarian biner. Misalnya saat ingin mencari suatu kata dalam kamus.
Prinsip dari pencarian biner dapat dijelaskan sebagai berikut:
1. Mula-mula diambil posisi awal = 1 dan posisi akhir = N
2. Cari posisi data tengah dengan rumus (posisi awal + posisi akhir) / 2
3. Data yang dicari dibandingkan dengan data tengah.
4. Jika lebih kecil, proses dilakukan kembali tetapi posisi akhir dianggap sama dengan
posisi tengah – 1.
5. Jika lebih besar, proses dilakukan kembali tetapi posisi awal dianggap sama dengan
posisi tengah + 1.
6. Demikian seterusnya sampai data tengah sama dengan yang dicari.

Untuk lebih jelasnya, perhatikan contoh berikut. Misalkan kita ingin mencari 17 pada
sekumpulan data berikut :

1. Mula–mula dicari data tengah, dengan rumus (1+ 9) / 2 = 5.

2. Berarti data tengah adalah data ke-5, yaitu 15.
3. Data yang dicari, yaitu 17, dibandingkan dengan data tengah ini.
4. Karena 17 > 15, berarti proses dilanjutkan tetapi kali ini posisi awal dianggap sama
dengan posisi tengah + 1 atau 6
1. Data tengah yang baru didapat dengan rumus (6 + 9) / 2 = 7. Berarti data tengah yang
baru adalah data ke-7, yaitu 23.
2. Data yang dicari, yaitu 17 dibandingkan dengan data tengah ini.
3. Karena 17 < 23, berarti proses dilanjutkan tetapi sekarang posisi akhir dianggap sama
dengan posisi tengah – 1 atau 6

1. Data tengah yang baru didapat dengan rumus (6 + 6) / 2 = 6. Berarti data tengah yang
baru adalah data ke-6, yaitu 17.
2. Data yang dicari dibandingkan dengan data tengah ini dan ternyata sama. Jadi data
ditemukan pada indeks ke-6.
3. Bagaimana jika data yang dicari tidak ada, misalnya 16?
4. Pencarian biner ini akan berakhir jika data ditemukan atau posisi awal lebih besar dari
posisi akhir.
5. Jika posisi awal sudah lebih besar daripada posisi akhir berarti data tidak ditemukan.
Untuk lebih jelasnya perhatikan proses pencarian 16 pada data di atas. Prosesnya
hampir sama dengan pencarian 17. Tetapi setelah posisi awal = posisi akhir = 6, proses
masih dilanjutkan lagi dengan posisi awal = 6 dan posisi akhir = 5

Disini dapat dilihat bahwa posisi awal lebih besar daripada posisi akhir, yang artinya data
tidak ditemukan.
Secara umum, algoritma pencarian biner dapat dituliskan sebagai berikut :
1. l ← 1.
2. r ← N.
3. ketemu ← false.
4. selama ( l < = r ) dan (not ketemu) kerjakan baris 5 sampai dengan 8.
5. m ← ( l + r ) / 2
6. Jika ( Data [m] = x ) maka ketemu ← true.
7. Jika ( x < Data [m] ) maka r ← m – 1.
8. Jika ( x > Data [m] ) maka l ← m + 1.
9. If (ketemu) maka m adalah indeks dari data yang dicari, jika tidak data tidak
ditemukan.
Berikut ini adalah contoh fungsi untuk mencari data menggunakan pencarian biner.

Function BinarySearch (x: word) : integer;

var
l, r, m : word;
ketemu : boolean;
begin
l : = 1;
r : = N;
ketemu : = false;
while (1 <= r ) and ( not ketemu ) do
begin
m : = (1 + r ) div 2;
if (Data [m] = x ) then
Ketemu := true
else if (x < Data [m] ) then
r:=m–1
else
l : = m + 1;
end;

if ( ketemu ) then
BinarySearch : = m
else
BinarySearch : = -1;
end;

Fungsi di atas akan mengembalikan indeks dari data yang dicari. Apabila data tidak
ditemukan, maka yang yang dikembalikan adalah –1.
Jumlah pembandingan minimum pada pencarian biner adalah 1 kali, yaitu bila data yang
dicari tepat berada di tengah-tengah. Jumlah pembandingan maksimum yang dilakukan
dengan pencarian biner dapat dicari dengan rumus logaritma, yaitu :
C = ²log (N)
2.4 Penerapan Algoritma

2.2.1. Pemecahan Masalah Convex Hull dengan Algoritma Divide and Conquer

Secara sederhana, pemasalahan convex hull ini adalah diberikan sebuah himpunan
titik-titik dalam sebuah bidang, lalu temukan convex hull dari titik-tititk ini
dengan keluaran dapat berupa list-of-verteks. Atau lebih formalnya:
Input: Himpunan S = (p1, p2, ..., pn) dimana p1,p2,...,pn merupakan titik-titik
pada bidang koordinat kartesius.

Output: Convex Hull CH(S) dari n titik-titik diatas.

-
Misalkan Pmax dan Pmin adalah dua buah titik pada himpunan S yang
masing-masing merupakan titik maksimum dan titik minimum berdasarkan
koordinat absis-X.
- Lalu Pmax dan Pmin merupakan verteks dari convex hull
- Lalu, jika Pmax dan Pmin dihubungkan, akan terdapat garis yang akan
membagi convex hull menjadi dua bagian, yaitu upper hull dan lower hull.
- Garis L disebut dengan tangen dari convex poligon P jika semua verteks dari P
berada pada sisis yang sama dari L.
 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.
Berikut ini adalah pseudo-code yang penulis buat sendiri untuk algoritmanya:

procedure D_and_C_CH (input P [1..n] : array of Point, Output L : List of Point)

{ Menyelesaikan masalah convex hull dengan algoritma D-and-C.

Masukan: masukan array of point yang berukuran n
Keluaran: solusi dari masalah }
Deklarasi
r : integer
la : list of point Algoritma

L = {}
if n ≤ 30 then {ukuran masalah sudah cukup kecil }
 SOLVE upa-masalah dengan metode brute-force
else
Bagi menjadi r upa-masalah, masing-masing berukuran n/k
Ha = P[1..n/2] HB = P[n/2+1..n] C_and_D_CH(Ha) C_and_D_CH(HB)

{gabungkan solusi dari r upa-masalah menjadi solusi masalah semula }

H = prosedur gabung Ha dan Hb dengan mencari lower tangen dan upper tangen
La = listPoint(H)
L = L ∪la endif

Pada algoritma di atas, dapat dilihat bahwa terdapat prosedur untuk mencari lower
tangen dan upper tangen. Algoritmanya merupakan suatu algoritma berjalan yang biasa.
Pada kasus ini, a diinisialisasi sebagai titik paling kanan dari HA dan b merupakan titik
paling kiri dari HB. Jika pasangan ab belum merupakan lower tangen untuk HA dan HB
, maka “nailkkan” a menjadi suksesor dari a dan “turunkan” b menjadi predesesor dari
b, sesuai dengan kaidah arah jarum jam.

Berikut adalah gambaran umum dalam pencarian lower tangen dari HA dan HB :

LowerTangen(HA, HB):

1) Misalkan a merupakan titik terkanan dari HA 2)Misalkan b merupakan titik terkanan dari HB
3)While (ab bukan merupakan lower tangen dari HA

dan HB)do
- While(ab bukan merupakan lower tangen dari HA) do a -> a.predesesor

- While(ab bukan merupakan lower tangen dari HA) do b-> b.suksesor

4)Return ab

Untuk lebih jelasnya, jika dibuatkan pseudo-codenya akan menjadi:

function LowerTangent (input HA, HB : list of point): list of point

{mencari lower tangen dari Ha dan Hb, untuk mencari lower tangen, analogi}

Algoritma

a = rightmost point dari Ha b = leftmost point dari Hb

while ab bukan lower tangen dar ha dan Hb do while ab bukan lower tangen dari Ha do

a.pred()

while ab bukan lower tangen dari Ha do b.succ()

return ab
 Kompleksitas waktu dari algoritma yang digunakan di atas dapat dinyatakan
dalam relasi rekurens. Diberikan masukkan dengan ukuran n, pertimbangkan waktu
yang dibutuhkan untuk menjalankan semua bagian dari prosedur. Hal ini akan
mencakup waktu untuk mempartisi himpunan titik, menghitung kedua tangen, dan
mengembalikan hasil akhir. Jelas sekali bahwa langkah pertama dan ketiga dapat
dijalankan dalam kompleksitas waktu O(n). Lalu dengan mengabaikan semua faktor
yang konstan, algoritma di atas dapat dijelaskan dengan relasi
 Apabila diperhatikan, relasi rekurens tersebut sangat mirip sekali dengan relasi
rekurens algoritma pengurutan MergeSort, yang jika diselesaikan akan menghasilkan
kompleksitas waktu sebesar O(n log n).

2.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 masing-masing
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.

2.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.2.4. Mencari Pasangan Titik yang Jaraknya Terdekat ( Closest Pair )

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.
 BAB III

KESIMPULAN

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

1.1. Saran
Dengan makalah yang dibuat ini diharapkan para pembaca dapat memecahkan suatu
masalah yang besar dengan metode Divide and Conquer baik masalah program
maupun masalah kehidupan.
Kami sebagai penyusun makalah ini meminta maaf sebesar-besarnya apabila
terdapat kesalahan di dalam makalah ini serta terimakasih sebanyak-banyaknya bagi
seluruh komponen yang telah mendukung terbentuknya makalah ini.
 DAFTAR PUSTAKA
Nudiyah ,Laura Belani.2014. Algoritma Divide and Conquer . ilmuti.org/wp-
content/uploads/.../laura_belani-Algoritma_Divide_and_Conquer.pdf.

informatika.stei.itb.ac.id/~rinaldi.munir/Stmik/2006.../MakalahSTMIK2007-125.pdf

1.