STUDI MINIMUM SPANNING TREE DENGAN ALGORITMA PRIM DAN KRUSKAL

TB 1 DESAIN DAN ANALISIS ALGORITMAKELAS: L

Oleh :

Kelompok 3

Maryamah 135150201111008

Vivilia Putri A 135150201111230

Weni Agustina 135150201111019

Riza Rizqiana 135150207111019

Sema Yuni F 135150201111189

Dosen Pengampu: Ratih Kartika Dewi, S.T, M.Kom.

PROGRAM TEKNOLOGI INFORMASI DAN ILMU KOMPUTER

UNIVERSITAS BRAWIJAYA

2014

1. Review Paper

Judul :

STUDI MINIMUM SPANNING TREE DENGAN ALGORITMA PRIM DAN

KRUSKAL

Nama Pengarang :

Hadyan Ghaziani Fadli

Nama Jurnal :

Studi Minimum Spanning Tree Dengan Algoritma Prim Dan

Kruskal

Masalah :

Untuk kendaraan motor seperti mobil, menghubungkan

beberapa kota besar mungkin akan dihubungkan secara langsung

dengan jalan tol. Namun pada umumnya, seperti pada jalan

kereta api, untuk penghematan pembuatan jalan, rel kereta

api dibuat tidak langsung, seperti jalan tol menghubungkan 2

kota yang cukup jauh secara langsung. Namun, melalui kota-

kota yang beradi diantaranya, jadi jalan ini sekaligus

menghubungkan kota-kota yang ada diantara kota asal dan kota

tujuan kita.

Untuk menentukan jalur mana yang akan dipakai agar

efisien maka diperlukan cara untuk mendapatkan jalur

terpendek. Karenanya pencarian sebuah jalan dengan jarak

minimal sangatlah dibutuhkan khususnya dalam dunia

transportasi di dunia. Pada Tahun 1926, seorang Czech

scientist, Otakar Boruvka menemukan sebuah algoritma yang

dikenal dengan Boruvks’s Algoritma. Seiring berjalannya

waktu, ada 2 algoritma lain yang lebih umum untuk dipakai

yaitu Algoritma Prim da Algoritma Kruskal.

Walaupun ada lebih dari 1 algoritma yang berbeda, namun

jalan yang didapat akan sama panjangnya. Metode yang dipakai

oleh ketiga Algoritma ini adalah metode Minimum Spanning

Tree.

2. Algoritma

o Algoritma Prim

Algoritma Prim adalah suatu algoritma di dalam teori

graf yang bertujuan menemukan Minimum Spanning tree untuk

menghubungkan graf berbobot.

Ini berarti algoritma ini menemukan subset dari sebuah

tepi yang membentuk sebuah Tree diminimalkan. Jika graf

tidak terhubung, maka ini hanya akan menemukan sebuah

Minimum Spanning Tree menjadi satu jalur untuk komponen

yang terhubung.

Algoritma ini ditemukan pada tahun 1930 oleh seorang

ahli matematika Vojtech Jamik, dan kemudian

dipublikasikan oleh seorang computer scientist Robert C. Prim

pada tahun 1957 dan ditemukan kembali oleh Dijkstra pada

tahun 1959. Oleh karena itu, terkadang Algoritma ini juga

disebut DJP algoritma atau algoritma Jamik.

Alur dan Cara Kerja Algoritma Prim

Alur :

AB

C

D E

F

G

5 915

6

7

11

9

7 5

8 Ini adalah sebuah grafberbobot yang asli, ini bukansebuah Tree karena definisisebuah Tree tidak memilikisirkuit, dan diagram inimemiliki sirkuit. Nama yanglebih benar untuk diagram iniadalah sebuah graf atau

AB

C

D E

F

G

5 915

6

7

11

9

7 5

8Kedua, pilih vertex terdekatdengan D : A memiliki jarak 5dengan D, B memiliki jarak 9,E memiliki jarak 15, dan Fmemiliki jarak 6. Dari

AB

C

D E

F

G

5 915

6

7

11

9

7 5

AB

C

D E

F

G

5 915

6

7

11

9

7

AB

C

D E

F

G

5 915

6

7

11

9

5

7

8

5

8

8

Vertex berikutnya adalahvertex yang terdekat ke Datau A. B memiliki jarak 9dari D dan 7 dari A, Ememiliki jarak 15 dan Fmemiliki jarak 6. Jadi F yangmemiliki jarak terpendek.

Algoritma yang disebutkandiatas, vertex B, yangmemiliki jarak 7 dari A, dihighlight. Disini , sisi DBdi highlight warna merah,

Dalam kasus ini, kita dapatmemilih antara C, E dan G. Cmemiliki jarak 8 dai B, Ememiliki jarak v dari B dan Gmemiliki jarak 11 dari F. Eyang terdekat.jadi kitahighlight E dan sisi EB. Dia

Cara Kerja :

Membuat sebuah tree yang mengandung vertex tunggal,

pilih yang berbobot minimum.

AB

C

D E

F

G

5 915

BC

6

D E

7

F

A

G

5

11

915

9

6

7

7

11

9

5

7 5

8

8

Disin, vertices yang masihtersedia adalah C dan G. Cmemiliki jarak5 dari E dan Gmemiliki jarak 9 dari E. Cyang dipilih. Jadi kita

Vertex G adalah vertexterakhir. Ini berjarak 11dari F, dan 9 dari E. E yangterdekat , jadi kitahighlight sisi EG. Sekarangsemua vertices telah di

Membuat sebuah set (yang belum tercakup) yang

mengandung semua vertices yang

lain di dalam graf.

Membuat sebuah set (fringe vertices) yang di

inisialisasi kosong.

Loop (jumlah vertices -1) :

Memindahkan tiap vertices yang belum tercakup dan

secara langsung terhubung kepada node terakhir,

menambahkan ke fringe set.

Untuk setiap titik di set sisi, menentukan jika

sebuah sisi menghubungkan vertices dengan node

terakhir ysng ditambahkan jika iya, maka jika sisi

tersebut memiliki bobot lebih kecil dari sisi

sebelumnya yang menghubungkan vertex ke Tree yang

telah terbuat. Memasukkan sisi baru ini melalui

node terakhir yang ditambahkan sebagai rute

terbaik di Tree yang telah dibuat.

Memilih sisi dengan bobot minimum yang

menghubungkan vertex dalam fringe set ke vertex

pada Tree yang sudah terbuat.

Menambahkan sisi tersebut ke Tree dan memindahkan

fringe vertex dalam fringe set ke sebuah vertex

dalam Tree yang sudah terbuat.

Meng-update node terakhir yang ditambahkan untuk

menjadi fringe vertex yang baru ditambahkan.

Hanya | V | -1, dimana | V | adalah jumlah dari

vertices dalam graf, pengulangan diperlukan. Sebuah

Tree menghubungkan | V | -1 sisi dan tiap pengulangan

dari algoritma yang dideskripsikan diatas tertarik

dalam tepat 1 sisi.

Implementasi yang simple menggunakan representasi

adjacency matrix graph dan mencari sebuah barisan bobot

untuk mencari sisi dengan bobot minimum. o Algoritma Kruskal

Algoritma Kruskal pertama kali dipopulerkan oleh Joseph

Kruskal pada tahun 1959. Algoritma Kruskal adalah sebuah

algoritma dalam teori grf yang mencari sebuah Minimum

Sanning Tree untuk sebuah graf yang berbobot dan yang

terhubung. Ini berarti mencari subset dari sisi yang

membentuk sebuah Tree yag menampung setiap vertex, dimana

total bobot dari semua sisi dalam Tree adalah minimum.

Jika graf tidak terhubung, kemudian ini mencari sebuah

Minimum Spanning Forest (sebuah Minimumu Spanning Tree

untuk tiap komponen yang terhubung). Algoritma Kruskal

adalah suatu contoh dari Algoritma Greedy.

Perbedaan prinsip antara algoritma prim dan Kruskal

adalah jika pada algoritma prim sisi yang dimasukkan ke

dalam Tree harus bersisian dengan sebuah simpul di Tree,

maka pada algoritma kruskal sisi yang dipilih tidak perlu

bersisian dengan sebuah simpul di Tree, asalkan penambahan

sisi tersebut tidak membentuk cycle.

Kedua algoritma ini berbeda dalam metodologinya, tetapi

keduanya mempunyai tujuan menemukan minimum spanning

Algoritma Kruskal menggunakan edge, dan

Algoritma Prim menggunakan vertex yang terhubung

Alur dan Cara Kerja Algoritma Kruskal :

Alur :

BC

D E

F

A

G

5 915

BC

6

D E

7

F

A

G

5

11

915

9

6

7

7

11

9

5

7 5

8

8

Ini adalah graf asli. Angka-Angka dekat sisi menandaibobot mereka. Tidak satupun

AD dan CE adalah sisi yangpaling pendek, denganpanjangnya 5, dan AD

BC

D E

F

A

G

5 915

BC

6

D E

7

F

A

G

5

11

915

B

9

C

6

D E

7

F

A

G

7

5

11

915

9

6

5

7

7

11

9

5

7

8

5

8

8

CE sekarang adalah sisiterpendek yang tidakmembentuk loop, dengan

Sisi selanjutnya , DF denganpanjang 6, di highlightmenggunakan metode yang sama

Sisi terpendek berikutnyaadalah AB dan BE, keduanyamemiliki panjang 7, ABdipilih, dai di highlight,Sisi BD di Highlight merah,

Cara Kerja :

Membuat sebuah Forest F (set dari Tree) yang tiap vertex

dalam graf adalah Tree pemisah.

Membuat sebuah set S yang mengandung semua sisi di dalam

graf.

While S tidak kosong :

BC

D E

F

A

G

5 915

BC

6

D E

7

F

A

G

5

11

915

9

6

7

7

11

9

5

7 5

8

8

Proses berlanjut dengan meng-highlight ke sisi terpendekberikutnya, BE dengan panjang7. akan lebih banyak sisiyang di highlight dengan

Terakhir, proses berakhirdengan sisi EG dengan panjang9, dan Minimum Spanning Tree

Membuang sebuah sisi dengan bobot minimum dari S

Jika sebuah sisi menghubungkan dua Tree yang berbeda,

kemudian menambahkan ini ke dalam Forest,

mengkombinasikan dua Tree ke dalam 1 Tree

Dilain pihak membuang sisi tersebut Dalam terminasi

dari algoritma ini, Forest hanya memiliki satu

komponen dan membentuk sebuah Minimum Spanning Tree

dari graf.

3. Implementasi

Source code utama yang berisi algoritma

o Algoritma Prim

Graph.javapublic void Prim( ) { int i, j, k, x, y;

boolean[] RuteDilewati = new boolean[Nodes]; int[] predNode = new int[Nodes]; // dimulai pada node awal = 0 pada sebuah vertex

RuteDilewati[0] = true;

for ( k = 1; k < Nodes; k++ ) { RuteDilewati[k] = false; }

predNode[0] = 0; printSeluruhRute( RuteDilewati );

for (k = 1; k < Nodes; k++) { x = y = 0; for ( i = 0; i < Nodes; i++ ) for ( j = 0; j < Nodes; j++ )

{ if ( RuteDilewati[i] && !RuteDilewati[j] && Jarak[i][j] < Jarak[x][y] ) {

x = i; y = j;

} }

System.out.println("Jarak Min : (" + + x + "," + + y + ")" +"Jarak = " + Jarak[x][y]);

predNode[y] = x; RuteDilewati[y] = true;

printSeluruhRute( RuteDilewati ); System.out.println(); }

printRuteMin( predNode ); }

o Algoritma Kruskal

Graph.cppvoid KruskalMST(struct Graph* graph){ int V = graph->V; struct Edge result[V]; int e = 0; int i = 0; qsort(graph->edge, graph->E, sizeof(graph->edge[0]), myComp);

struct subset *subsets = (struct subset*) malloc( V * sizeof(struct subset));

for (int v = 0; v < V; ++v){ subsets[v].parent = v; subsets[v].rank = 0; } while (e < V - 1) { struct Edge next_edge = graph->edge[i++]; int x = find(subsets, next_edge.src); int y = find(subsets, next_edge.dest);

if (x != y) { result[e++] = next_edge; Union(subsets, x, y); } } printf("Following are the edges in the constructed MST\n"); for (i = 0; i < e; ++i) printf("%d -- %d == %d\n", result[i].src, result[i].dest, result[i].weight); return;}

Screenshoot: tampilan hasil program

o Algoritma Prim

o Algoritma Kruskal

4. Analisis kompleksitas

4.1 Penentuan n

o Algoritma Prim n = 8.

o Algoritma Kruskal

Pada algoritma kruskal ini kita menginputkan n = v-i

4.2 Basic operation & alasan pemilihan

o Algoritma Prim for ( i = 0; i < Nodes; i++ )

for ( j = 0; j < Nodes; j++ )

Alasan : Karena for i dan for j sering dieksekusi dalamprogram algoritma prim.

o Algoritma KruskalWhile (e < V-1)

Alasan : eksekusi dilakukan berulang-ulang sesuai

dengan nilai edge dan vertex yang diinputkan. Jika

nilai yang diinputkan 5 maka eksekusi akan dilakukan 5

kali.

4.3 Proses memperoleh C(n)

Penentuan kelas OOG

o Algoritma Prim

C (n)=∑i=1

n−m.∑j=1

n−m1

¿∑i=1

n−m1(n−m−1+1)

¿∑i=1

n−m1(n−m)

¿ (n−m−1+1) (n−m)¿ (n−m ) (n−m )¿n2−nm−nm−m2¿n2−2nm−m2

T (n)=n (n−m )+1

o Algoritma Kruskal

Best case : Cn = ∑i=1

11

e= edge dan v = vertex

Dengan kondisi e = v-1 dapat ditulis e log v

Waktu untuk 2e untuk menemukan operasinya adalah = log

v

Untuk operasi v-1= n

Sehingga total running time

T(n) = e log v + 2e log v + n

T(n) = (e+v) log n

Notasi asymptotic

o Algoritma Prim

O(n (n−m )+1)

o Algoritma Kruskal

Best case = O (1)

T (n) = O ((n+m)log n )

Catatan Dosen Pengampu

Kelas : TIF-LKelompok : 03

1 Pemilihan paper acuan Jur

Int

Al>1

2 Review Jud+Nam

Mslh Ut

Desc Al

3 Kompleksitas N

Bo

C(n)

OOG

ASYM

4 Implementasi Cde

Scrst

5 Lain2 Rap

Tep

Jumlah

(Ratih Kartika Dewi, S.T, M.Kom.)