Modul 6 : Analisis Algoritma dan Struktur Data Divide and Conquer Modul 6 : Analisis Algoritma dan Struktur Data copyright@suarga

Divide and Conquer Memecah belah kemudian menaklukkan, politik kompeni Bentuk umum: Andaikan x adalah persoalan yang akan di-selesaikan Bila x cukup kecil maka selesaikan dengan ADHOC(x), dimana ADHOC(x) adalah fungsi untuk menyelesaikan persoalan sederhana x. Pecah x menjadi x(i) : i = 1 s/d n Mulai dari i=1 s/d n x  x(i); cari penyelesaian dari x(i), misalnya adalah y(i) Gabungkan solusi y(i) menjadi solusi persoalan. copyright@suarga

Fungsi DaC(x) { x adalah masalah yang akan diselesaikan } if (x cukup kecil/mudah) then return ADHOC(x); Pecah x menjadi x(i): i=1 s/d n for i=1 to n y(i)= DaC(x(i)); endfor. y =  y(i); { y adalah kombinasi seluruh y(i) } return y. copyright@suarga

procedure D-and-C (n : input size) is begin if n < = n0 then Solve problem without further sub-division; else Split into r sub-instances each of size n/k; for each of the r sub-instances do D-and-C (n/k); Combine the r resulting sub-solutions to produce the solution to the original problem; end if; end D-and-C; T(n) = a T(n/k) + O(n) copyright@suarga

Analisis algoritma Andaikan suatu algoritma A memiliki kompleksitas O(n2), kemudian misalkan c adalah konstanta sehingga tA(n)  cn2 Misalkan metoda DAC kemudian membagi proses menjadi 3 langkah dengan dimensi masing-masing |n/2| maka kompleksitas bisa ditulis dalam bentuk rekurensi sbb: tC(n) = tA(n) bila n  n0 = 3 tC( n/2 ) + t(n) utk n yang lain Dimana untuk n  n0 masalah bisa diselesaikan dengan mudah (ADHOC) Solusi rekurensi adalah O(nlg 3) atau O(n1.59) yang sedikit lebih baik dari O(n2)   copyright@suarga

Contoh 1: Binary search Hanya effektif bila kumpulan data telah di-sort (ingat kompleksitas sort umumnya O(n2) ) Kumpulan data dibagi dua, kiri dan kanan Ambil titik tengah m, bila x = A[m] maka ketemu, bila x < A[m] cari dikiri, bila x >A[m] cari dikanan Ulangi proses hingga ketemu,atau tidak sama sekali Kompleksitas: T(n) = O(1) bila n = 1 = T(n/2) + O(n) bila n > 1 Solusinya adalah O(lg n) copyright@suarga

Fungsi binsearch (D[1..n], x) { mencari x dalam D dengan binsearch } if (n=0) or (x < D[1]) then return 0; return binrec(D, x); Fungsi binrec(D[i..j], x) { mencari x dalam D[i..j] dengan binsearch } if (i = j) then return i; m  (i + j + 1) div 2; if ( x < D[m] ) then return binrec(D[i .. m-1], x); else return binrec(D[m .. j], x); copyright@suarga

Contoh 2 : Merge Sort Merge Sort adalah salah satu teknik pengurutan data (sort) yang biasa diterapkan apabila jumlah data n cukup besar, dengan metoda divide-and-conquer. Prinsipnya adalah sebagai berikut: bila n tidak terlalu besar, gunakan teknik sort biasa, misalnya insertion-sort bila n cukup besar maka bagi-dua data secara rekursif, kemudian lakukan sort pada masing-masing bagian hasil sort bagian kemudian digabungkan (merge) copyright@suarga

copyright@suarga

Prosedur MergeSort (D[1..n]) { sort array D menjadi ascending order } if (n < n0) then insert_sort(D) else U  D[1..n div 2]; V  D[1 + n div 2 .. n]; MergeSort(U); MergeSort(V); Merge(U, V); Kompleksitas: T(n) = O(n2) bila n < n0 = 2 T(n/2) + O(n) bila n  n0 Solusi : O(n lg n) bila n  n0 copyright@suarga

Contoh 3: Perkalian Integer Besar Apabila dua integer besar akan diperkalikan maka ada kemungkinan akan terjadi error karena adanya batasan digit yang diperbolehkan oleh hardware Sofware matematis seperti Mathematica dan Maple menggunakan algoritma perkalian integer besar untuk mengatasi persoalan ini Andaikan u dan v adalah dua integer besar masing masing hampir sama: u = 10s w + x dan v = 10s y + z dimana: 0  x  10s, 0  z  10s, dan s =  n/2 . copyright@suarga

Hasil perkalian-nya adalah : uv = 102s wy + 10s (wz + xy) + xz u w x v y z n Hasil perkalian-nya adalah : uv = 102s wy + 10s (wz + xy) + xz copyright@suarga

Fungsi Kalikan(u, v : large_int)  large_int n  size_of(u,v); if (n is small) then hasil = u*v; return hasil; s  n div 2; w  u div 10^s; x  u mod 10^s; y  v div 10^s; z  v mod 10^s; return Kalikan(w,y)x10^2s + (Kalikan(w,z) + Kalikan(x,y))x10^s + Kalikan(x,z); kompleksitas algoritma diatas adalah: tb(n)  3 tb(n/2 + tb(n/2 + (n) Atau tb(n)  4 tb(n/2) + (n) copyright@suarga

Fungsi Kalikan(u, v : large_int)  large_int n  size_of(u,v); Bila andaikan r = (w+x)(y+z) = wy + (wz + xy) + xz, atau : (wz + xy) = r – wy – xz, maka algoritma diubah menjadi: Fungsi Kalikan(u, v : large_int)  large_int n  size_of(u,v); if n is small then hasil = u*v; return hasil; s  n div 2; w  u div 10^s; x  u mod 10^s; y  v div 10^s; z  v mod 10^s; r  Kalikan(w + x, y + z); p  Kalikan(w,y); q  Kalikan(x,z); return p * 10^2s + (r – p – q) x 10^s + q; copyright@suarga

function Karatsuba (xunder, yunder : n-digit integer; n : integer)  (2n)-digit integer is a, b, c, d : (n/2)-digit integer U, V, W : n-digit integer; begin if n = 1 then return x(0)*y(0); else a := x(n-1) ... x(n/2); b := x(n/2-1) ... x(0); c := y(n-1) ... y(n/2); d := y(n/2-1) ... y(0); U := Karatsuba ( a, c, n/2 ); V := Karatsuba ( b, d, n/2 ); W := Karatsuba ( a+b, c+d, n/2 ); return U*10^n + (W-U-V)*10^n/2 + V; end if; end Karatsuba; copyright@suarga

copyright@suarga

t(n)  t(n/2 + t(n/2 + t(1 + n/2 ) + cn Kompleksitas: t(n)  t(n/2 + t(n/2 + t(1 + n/2 ) + cn t(n)  3 t(n/2 ) + O(n) Atau O(nlg 3) = O(n1.59). copyright@suarga

r = (w + x)(y+z) = (23+45)(67+89)=68 x 156 = 10608 Contoh : u = 2345, v = 6789 n = 4, s=2, w=23, x=45 dan y=67, z=89 p = wy = 23 x 67 = 1541 q = xz = 45 x 89 = 4005 r = (w + x)(y+z) = (23+45)(67+89)=68 x 156 = 10608 Hasil = 1541 x 104 + (10608 – 1541 – 4005) x 102 + 4005 = 15,410,000 + 506,200 + 4,005 = 15,920,205 copyright@suarga

Contoh 4 : Perkalian Matrix copyright@suarga

C[i,j] := C[i,j] + A[i,k] * B[k,j] O(N3) multiplications Brute Force for i:= 1 to N do    for j:=1 to N do       C[i,j] := 0;        for k := 1 to N do          C[i,j] := C[i,j] + A[i,k] * B[k,j]  O(N3) multiplications Strassen Matrix Multiplication adalah contoh perkalian matriks memakai Divide and Conquer copyright@suarga

P1 = (A11 + A12) (B11 + B22); P2 = (A21 + A22) B11 Divide and Conquer [ C11 C12 ] = [A11 A12] x [B11 B12 ] [ C21 C22] [A21 A22] [B21 B22 ] diselesaikan dengan: P1 = (A11 + A12) (B11 + B22); P2 = (A21 + A22) B11 P3 = A11 (B12 – B22); P4 = A22 (B21 – B11) P5 = (A11 + A12) B22; P6 = (A21 – A11) (B11 + B12) P7 = (A12 – A22) (B21 + B22) C11 = P1 + P4 – P5 + P7 C12 = P3 + P5 C21 = P2 + P4 C22 = P1 + P3 – P2 + P6 T(n) = c bila n=1 = 7 T(n/2) + cn bila n > 1 Solusi : O(nlog 7) = O(n2.81) copyright@suarga

In general: Divide and Conquer complexity: T( n ) = alpha T( n/beta ) + O( n^gamma ) (where gamma is constant) has the solution : T(n) = O(n^gamma) if alpha < beta^gamma T(n) = O(n^gamma log n) if alpha = beta^gamma} T(n) = O(n^{log^-beta(alpha)) if alpha > beta^gamma copyright@suarga