Kartika Dwi Hapsari

Desain dan Analisa Algoritma Divide and Conquer

1

Kartika Dwi Hapsari | 105060809111003

1

Divide and Conquer
A. Pengertian
Merupakan teknik umum desai algoritma yang paling terkenal. 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), di dalam menerapkan
algoritma yang sama dalam sub-sub problem seperti yang diterapkan pada
masalah aslinya (original problem).
Divide : Membagi masalah menjadi beberapa submasalah yang memiliki
kemiripan dengan masalah semula namun berukuran lebih kecil (idealnya tiap
submasalah berukuran hampir sama).
Conquer : Memecahkan (menyelesaikan) masing-masing submasalah (secara
rekursif).
Combine: mengabungkan solusi masing-masing submasalah sehingga
membentuk solusi masalah semula.
















masalah berukuran n
submasalah 1 ;
berukuran n/2
submasalah 2 ;
berukuran n/2
solusi submasalah 1 solusi submasalah 2
solusi masalah
sebenarnya
Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
2

Kartika Dwi Hapsari | 105060809111003

2

Langkah kerja Divide and Conquer :
1. Sebuah permasalahan dibagi menjadi beberapa bagian yang lebih
sederhana dari permasalahan yang sama, idealnya dengan ukuran yang
sama.
2. Bagian yang lebih sederhana diselesaikan (biasanya secara rekursif)
3. Jika diperlukan solusi yang didapat dari bagian yang lebih sederhana
digabungkan untuk mendapatkan penyelesaian untuk masalah yang
sebenarnya.

Objek masalah yang dibagi adalah masukan (input) atau instances yang
berukuran n : tabel (larik), matriks, dan sebagainya, bergantung pada
masalahnya. Tiap-tiap submasalah 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.

Selain dibutuhkan sebuah 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
ke dalam solusi dari problem awalnya. Psodecode :
function d and c (p)
if basecase (p)
then
return solve (p)
else
(p1, : : :, pn) = divide (p)
return combine (d and c (p1), : : :, d and c (pn))
endif



Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
3

Kartika Dwi Hapsari | 105060809111003

3

Hal-hal yang penting pada Divide and Conquer :
1. 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.
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 (initial problem). Algoritma Mergesort dan binary tree, dan
sama halnya dengan algoritma reduksi & prefix sum adalah beberapa
contoh algoritma divide and conquer yang seimbang (balance).
3. Data Dependence of Divide Function
Algoritma divide and conquer memiliki sebuah fungsi pembagian
terhadap data yang memiliki ketergantungan, artinya jika ukuran relatif
dari sebuah subproblem tergantung pada proses input datanya. Ini adalah
salah satu ciri dari algoritma yang tidak seimbang, salah satu contohnya
adalah algoritma quicksort yang akan membagi subproblem dengan
fungsi data-dependent divide.
4. Control Parallelism or Sequentiality
Algoritma divide and conquer dikatakan berurutan (sequential) jika
subproblem dieksekusi sesuai dengan perintah program. Paralelisasi dari
algoritma divide and conquer yang terurut pertama kali didefinisikan oleh
Mous 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,
Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
4

Kartika Dwi Hapsari | 105060809111003

4

tetapi sekarang ini contoh diatas tidak dapat dijadikan ilustrasi lagi karena
teknologi komputer paralel yang semakin canggih dan kompleks.
Rekursi Divide and Conquer
Machiavelli menggunakan sintaks :
Split (result1 = func (arg1), result2 = func (arg2) [, resultn = func (argn)])
Untuk membentuk fungsi call dalam algoritma divide and conquer. Varn
adalah hasil akhir yang kembali ke fungsi func dalam argument argn.
Machiavelli membuat versi fungsi yang salah satunya mengaplikasikan
reduksi menjadi sebuah pengulangan sederhana . Contoh :
void fetch_vec_int_serial (vec_int src, vec_int indices,
vec_int dst)
{
int i, nelt = dst.nelt_here;
for (i = 0; i < nelt; i++)
{
dst[i] = src[indices[i]]
}
}
B. Contoh Algoritma
Skema umum :
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 s n
0
then {ukuran masalah sudah cukup kecil }
SOLVE upa-masalah yang berukuran n ini
else
Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
5

Kartika Dwi Hapsari | 105060809111003

5

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
Jika pembagian selalu menghasilkan dua submasalah yang berukuran sama :
procedure DIVIDE_and_CONQUER(input n : integer)
{ Menyelesaikan masalah dengan algoritma D-and-C.
Masukan: masukan yang berukuran n
Keluaran: solusi dari masalah semula
}
Deklarasi
r, k : integer
Algoritma
if n s n
0
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
Kompleksitas Waktu :

> +
s
=
, ) ( ) 2 / ( 2
n , ) (
) (
0
0
n n n f n T
n n g
n T

Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
6

Kartika Dwi Hapsari | 105060809111003

6

Contoh masalah :
1. Mencari nilai minimum dan maksimum

4 12 23 9 21 1 35 2 24

Ide dasar algoritma secara Divide and Conquer:


4 12 23 9 21 1 35 2 24

DIVIDE

4 12 23 9 21 1 35 2 24

SOLVE: tentukan min &
maks pada tiap bagian

4 12 23 9 21 1 35 2 24
min = 4 min = 1
maks = 23 maks = 35


COMBINE

4 12 23 9 21 1 35 2 24
min = 1
maks = 35
Algoritma:
1. Untuk kasus n = 1 atau n = 2,
SOLVE: Jika n = 1, maka min = maks = A[n]
Jika n = 2, maka bandingkan kedua elemen untuk
menentukan min dan maks.
2. Untuk kasus n > 2,
(a) DIVIDE: Bagi dua tabel A menjadi dua bagian yang sama, A1
dan A2


Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
7

Kartika Dwi Hapsari | 105060809111003

7

(b) CONQUER: MinMaks(A1, n/2, min1, maks1)
MInMaks(A2, n/2, min2, maks2)
(c) COMBINE: if min1 <min2 then min <- min1 else min <- min2
if maks1 <maks2 then maks <- maks2 else maks <-
maks1
procedure MinMaks2(input A : 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 }
minA
i

maksA
i

else
if (i = j-1) then { 2 elemen }
if A
i
< A
j
then
maksA
j

minA
i

else
maksA
i

minA
j

endif
else { lebih dari 2 elemen }
k(i+j) div 2 { bagidua tabel pada posisi k }
Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
8

Kartika Dwi Hapsari | 105060809111003

8

MinMaks2(A, i, k, min1, maks1)
MinMaks2(A, k+1, j, min2, maks2)
if min1 < min2 then
minmin1
else
minmin2
endif
if maks1<maks2 then
maksmaks2
else
maksmaks2
endif
Kompleksitas Waktu



Asumsi: n = 2
k
, dengan k bilangan bulat positif, maka
T(n) = 2T(n/2) + 2
= 2(2T(n/4) + 2) + 2 = 4T(n/4) + 4 + 2
= 4T(2T(n/8) + 2) + 4 + 2 = 8T(n/8) + 8 + 4 + 2
= ...
= 2
k 1
T(2) +

=
1
1
2
k
i
i


= 2
k 1
1 + 2
k
2
= n/2 + n 2
= 3n/2 2
= O(n)

> +
=
=
=
2 , 2 ) 2 / ( 2
2 , 1
1 , 0
) (
n n T
n
n
n T
Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
9

Kartika Dwi Hapsari | 105060809111003

9

2. Mencari Pasangan Titik yang Jaraknya Terdekat (Closest Pair)







Jarak dua buah titik p
1
= (x
1
, y
1
) dan p
2
= (x
2
, y
2
):

Asumsi: n = 2
k
dan titik-titik diurut berdasarkan absis (x).
Algoritma Closest Pair:
1. SOLVE: jika n = 2, maka jarak kedua titik dihitung langsung dengan
rumus Euclidean.
2. DIVIDE: Bagi himpunan titik ke dalam dua bagian, P
left
dan P
right
,
setiap bagian mempunyai jumlah titik yang sama.







p
1
p
2
p
3
p
4
p
5
p
6
p
7
p
8
x
y
2
2 1
2
2 1
) ( ) ( y y x x d + =
p
1
p
2
p
3
p
4
p
5
p
6
p
7
p
8
x
y
L
P
Left
P
Right
Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
10

Kartika Dwi Hapsari | 105060809111003

10

3. CONQUER: Secara rekursif, terapkan algoritma D-and-C pada
masing-masing bagian.
4. Pasangan titik yang jaraknya terdekat ada tiga kemungkinan letaknya:
(a) Pasangan titik terdekat terdapat di bagian P
Left
.
(b) Pasangan titik terdekat terdapat di bagian P
Right
.
(c) Pasangan titik terdekat dipisahkan oleh garis batas L, yaitu satu
titik di P
Left
dan satu titik di P
Right
.

Jika kasusnya adalah (c), maka lakukan tahap COMBINE untuk
mendapatkan jarak dua titik terdekat sebagai solusi persoalan
semula.
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 {p
1
, p
2
,..., p
n/2
}
P-Right {p
n/2+1
, p
n/2+2
,..., p
n
}
FindClosestPair2(P-Left, n/2, DeltaLeft)
FindClosestPair2(P-Right, n/2, DeltaRight)
delta minimum(DeltaLeft, DeltaRight)
{--
***********************************************************
--}
Tentukan apakah terdapat titik p
l
di P-Left dan p
r
di
P-Right
Dengan jarak(p
l
, p
r
) < delta. Jika ada, set delta
dengan jarak
terkecil tersebut.
{--
***********************************************************
--}
endif




Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
11

Kartika Dwi Hapsari | 105060809111003

11

Jika terdapat pasangan titik p
l
and p
r
yang jaraknya lebih kecil dari delta,
maka kasusnya adalah:
(i) Absis x dari p
l
dan p
r
berbeda paling banyak sebesar delta.
(ii) Ordinat y dari p
l
dan p
r
berbeda paling banyak sebesar delta.
Ini berarti p
l
and p
r
adalah sepasang titik yang berada di daerah sekitar
garis vertikal L:









Oleh karena itu, implementasi tahap COMBINE sbb:
(i) Temukan semua titik di P
Left
yang memiliki absis x minimal x
n/2


delta
.
(ii) Temukan semua titik di P
Right
yang memiliki absis x maksimal x
n/2+
delta
.
Sebutkan semua titik-titik yang ditemukan pada langkah (i) dan (ii)
tersebut sebagai himpunanP
strip
yang berisi s buah titik.
Urutkan titik-titik tersebut dalam urutan absis y yang menaik. Misalkan
q1, q2 , ..., qs menyatakan hasil pengurutan.



-
-
-
-
x
y
L
-
Kartika Dwi Hapsari
Desain dan Analisa Algoritma Divide and Conquer
12

Kartika Dwi Hapsari | 105060809111003

12









Langkah COMBINE:
for i1 to s do
for ji+1 to s do
exit when (|q
i
.x q
j
.x | > Delta or |q
i
.y q
j
.y | >
Delta
if jarak (q
i
, q
j
) < Delta then
Delta jarak(q
i
, q
j
) { dihitung dengan rumus
Euclidean }
endif
endfor
endfor

Kompleksitas Waktu


Solusi dari persamaan di atas adalah T(n) = O(n log n).
L
A A
strip - A

=
> +
=
2 ,
2 , ) 2 / ( 2
) (
n a
n cn n T
n T