Modul 6 : Analisis Algoritma dan Struktur Data

Presentasi berjudul: "Modul 6 : Analisis Algoritma dan Struktur Data"— Transcript presentasi:

1 Modul 6 : Analisis Algoritma dan Struktur Data
Divide and Conquer Modul 6 : Analisis Algoritma dan Struktur Data

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

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

4 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)

5 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)

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

7 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);

8 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)

9

10 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

11 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 .

12 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

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

14 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;

15 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;

16

17 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).

18 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 (10608 – 1541 – 4005) x = 15,410, , ,005 = 15,920,205

19 Contoh 4 : Perkalian Matrix

20 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

21 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)

22 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