Kartika Dwi Hapsari 1 Desain dan Analisa Algoritma Divide and

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

1 Kartika Dwi Hapsari | 105060809111003

Kartika Dwi Hapsari 2 Desain dan Analisa Algoritma Divide and solusi masalah sebenarnya

Kartika Dwi Hapsari | 105060809111003

Langkah kerja Divide and Conquer : 1. Sebuah permasalahan dibagi menjadi beberapa bagian 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 2

lebih

sederhana dari permasalahan yang sama, idealnya dengan ukuran yang

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 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 subeksekusi diperlukan oleh subeksekusi yang lain. Dalam kasus ini hasil
3

memiliki

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

then {ukuran masalah sudah cukup kecil }

SOLVE upa-masalah yang berukuran n ini else

Kartika Dwi Hapsari | 105060809111003

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 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 n/2) pertama yang berukuran

DIVIDE_and_CONQUER(upa-masalah kedua yang berukuran n/2) COMBINE solusi dari 2 upa-masalah endif

Kompleksitas Waktu : T (n) =

5

g ( n)

,n n0

2T (n / 2) + f (n)

Kartika Dwi Hapsari | 105060809111003

, n > n0

Kartika Dwi Hapsari | 105060809111003

Contoh masalah : 1. Mencari nilai minimum dan maksimum 4 12 23 9 21 1 35 2 24

Ide dasar algoritma secara Divide and Conquer:

12

23

21

35

24

DIVIDE 4 12 23 9 21 1 35 2 24

SOLVE: tentukan min & maks pada tiap bagian 4 12 23 min = 4 maks = 23 9 21 1 35 min = 1 maks = 35 2 24

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

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,
6

(a) DIVIDE: Bagi dua tabel A menjadi dua bagian yang sama, A1 dan A2

Kartika Dwi Hapsari | 105060809111003

(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 minAi maksAi else if (i = j-1) then if Ai < Aj then maksAj minAi else maksAi minAj { 2 elemen } { 1 elemen }

endif else { lebih dari 2 elemen }

Kartika Dwi Hapsari | 105060809111003

k(i+j) div 2

{ bagidua tabel pada posisi k }

Kartika Dwi Hapsari | 105060809111003

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

0 ,n= 1 T ( n) = 1 ,n= 2 2T (n / 2) + 2 , n > 2 Asumsi: n = 2 , 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
k1
k 1

T(2) +

2
i=1

=2

k1

1+2 2

= n/2 + n 2 = 3n/2 2
8

= O(n)

Kartika Dwi Hapsari | 105060809111003

2.

Mencari Pasangan Titik yang Jaraknya Terdekat (Closest Pair)

y p5 p2 p3 p1 p4 p6 p8 p7 x

Jarak dua buah titik p1 = (x1, y1) dan p2 = (x2, y2): d = ( x1 x2 )2 + ( y1 y2 )2

k

Asumsi: n = 2 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, Pleft dan Pright, setiap bagian mempunyai jumlah titik yang sama.
y p5 p2 p3 p1 p4 p6 p8 p7 PLeft PRight x

Kartika Dwi Hapsari | 105060809111003

Kartika Dwi Hapsari | 105060809111003

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 PLeft. (b) Pasangan titik terdekat terdapat di bagian PRight. (c) 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 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 {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 terkecil tersebut. {-*********************************************************** --} endif

titik terdekat sebagai solusi persoalan

10

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

x L

Oleh karena itu, implementasi tahap COMBINE sbb: (i) (ii) Temukan semua titik di PLeft yang memiliki absis x minimal xn/2
delta.

Temukan semua titik di PRight yang memiliki absis x maksimal x n/2+

delta.

Sebutkan semua titik-titik yang ditemukan pada langkah (i) dan (ii) tersebut sebagai himpunanPstrip yang berisi s buah titik. Urutkan titik-titik tersebut dalam urutan absis y yang menaik. Misalkan q1, q2 , ..., qs menyatakan hasil pengurutan.

11

- strip

Langkah COMBINE:
for i1 to s do for ji+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

Kompleksitas Waktu

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

,n>2 ,n= 2

Solusi dari persamaan di atas adalah T(n) = O(n log n).

12