aal presentasi kelompok

Greedy Method

• Algoritma dalam problem optimasi umumnya melalui serangkaian langkah dengan sejumlah pilihan di tiap langkahnya.

• Penggunaan dynamic programming untuk menentukan pilihan terbaik dalam problem optimasi kadang kala terlalu berlebihan, karena terkadang masih ada algoritma yang lebih sederhana dan efisien.

• Algoritma greedy selalu mengambil keputusan yang terbaik di suatu waktu, atau dalam hal ini mengambil pilihan yang optimal dalam lingkup local dengan harapan pilihan tersebut berujung pada solusi optimal di lingkup global.

• Algoritma greedy tidak selalu menghasilkan solusi yang optimal, meski demikian sebagian besar problem dapat diselesaikan dengan algoritma ini.

Contoh 1: tersedia banyak koin 1, 5, 10, 25

• Uang senilai A = 32 dapat ditukar dengan banyak cara berikut: 32 = 1 + 1 + … + 1 (32 koin) 32 = 5 + 5 + 5 + 5 + 10 + 1 + 1 (7 koin) 32 = 10 + 10 + 10 + 1 + 1 (5 koin) … dst

• Minimum: 32 = 25 + 5 + 1 + 1 (4 koin)

• Algoritma greedy adalah algoritma yang memecahkan masalah langkah per langkah;

pada setiap langkah:

1. mengambil pilihan yang terbaik yang dapat diperoleh pada saat itu tanpa memperhatikan konsekuensi ke depan (prinsip “take what you can get now!”)

2. berharap bahwa dengan memilih optimum lokal pada setiap langkah akan berakhir dengan optimum global.

• Tinjau masalah penukaran uang:

Strategi greedy: Pada setiap langkah, pilihlah koin dengan nilai

terbesar dari himpunan koin yang tersisa.

• Misal: A = 32, koin yang tersedia: 1, 5, 10, dan 25 Langkah 1: pilih 1 buah koin 25 (Total = 25)Langkah 2: pilih 1 buah koin 5 (Total = 25 + 5 = 30)Langkah 3: pilih 2 buah koin 1 (Total = 25+5+1+1= 32)

• Solusi: Jumlah koin minimum = 4 (solusi optimal!)

• Contoh 2: tinjau masalah penukaran uang.

(a) Koin: 5, 4, 3, dan 1 Uang yang ditukar = 7.

Solusi greedy: 7 = 5 + 1 + 1 ( 3 koin) tidak optimalSolusi optimal: 7 = 4 + 3 ( 2 koin)

(b) Koin: 10, 7, 1 Uang yang ditukar: 15 Solusi greedy: 15 = 10 + 1 + 1 + 1 + 1 + 1 (6 koin) Solusi optimal: 15 = 7 + 7 + 1 (hanya 3 koin)

(c) Koin: 15, 10, dan 1Uang yang ditukar: 20Solusi greedy: 20 = 15 + 1 + 1 + 1 + 1 + 1 (6 koin)Solusi optimal: 20 = 10 + 10 (2 koin)

• Untuk sistem mata uang dollar AS, euro Eropa, dan crown Swedia, algoritma greedy selalu memberikan solusi optimum.

• Contoh: Uang $6,39 ditukar dengan uang kertas (bill) dan koin sen (cent), kita dapat memilih:

- Satu buah uang kertas senilai $5- Satu buah uang kertas senilai $1- Satu koin 25 sen- Satu koin 10 sen- Empat koin 1 sen

$5 + $1 + 25c + 10c + 1c + 1c + 1c + 1c = $6,39

Penyelesaian dengan algoritma greedy• Strategi greedy: Pada setiap langkah, pilih koin dengan nilai terbesar dari

himpunan koin yang tersisa.

function CoinExchange(input C : himpunan_koin, A : integer) himpunan_koin { mengembalikan koin-koin yang total nilainya = A, tetapi jumlah koinnya minimum } Deklarasi S : himpunan_koin x : koin Algoritma S {} while ((nilai semua koin di dalam S) A) and (C {} ) do x koin yang mempunyai nilai terbesar C C - {x} if ((nilai semua koin di dalam S) + nilai koin x A then S S {x} endif endwhile if ((nilai semua koin di dalam S) = A then return S else write(’tidak ada solusi’) endif

Contoh 3: Tiga pelanggan dengant1 = 5, t2 = 10, t3 = 3,

Enam urutan pelayanan yang mungkin:============================================Urutan T ============================================

1, 2, 3: 5 + (5 + 10) + (5 + 10 + 3 ) = 381, 3, 2: 5 + (5 + 3) + (5 + 3 + 10) = 312, 1, 3: 10 + (10 + 5) + (10 + 5 + 3) = 432, 3, 1: 10 + (10 + 3) + (10 + 3 + 5) = 413, 1, 2: 3 + (3 + 5) + (3 + 5 + 10) = 29 (optimal)3, 2, 1: 3 + (3 + 10) + (3 + 10 + 5) = 34============================================

Contoh 5. w1 = 100; p1 = 40; w2 = 50; p2 = 35; w3 = 45; p3 = 18;

w4 = 20; p4 = 4; w5 = 10; p5 = 10; w6 = 5; p6 = 2Kapasitas knapsack K = 100

Properti objek Greedy by

i wi pi pi /wi profit weight density Solusi Optimal

1 100 40 0,4 1 0 0 0 2 50 35 0,7 0 0 1 1 3 45 18 0,4 0 1 0 1 4 20 4 0,2 0 1 1 0 5 10 10 1,0 0 1 1 0 6 5 2 0,4 0 1 1 0

Total bobot 100 80 85 100 Total keuntungan 40 34 51 55

Ketiga strategi gagal memberikan solusi optimal!

Contoh 6. w1 = 18; p1 = 25; w2 = 15; p1 = 24w3 = 10; p1 = 15 Kapasitas knapsack K = 20

Properti objek Greedy by i wi pi pi /wi profit weight density 1 18 25 1,4 1 0 0 2 15 24 1,6 2/15 2/3 1 3 10 15 1,5 0 1 1/2

Total bobot 20 20 20 Total keuntungan 28,2 31,0 31,5

Solusi optimal: X = (0, 1, 1/2) yang memberikan keuntungan maksimum = 31,5.

Activity-Selection Problem

• Penjadwalan aktivitas yang membutuhkan pemanfaatan sumberdaya umum secara eksklusif. (contohnya ruangan kelas)

• Tujuan: menentukan ukuran maksimum dari himpunan aktivitas yang saling compatible.

• Himpunan S = {a1, a2 , …, an} dengan n aktivitas yang memerlukan pemanfaatan sumberdaya umum secara eksklusif.

• Tiap aktivitas ai memiliki si = waktu mulai dan fi = waktu selesai yang berlangsung dalam half-open interval [si, fi).

• Aktivitas ai dan aj saling compatible jika interval [si,fi) dan [sj,fj) tidak overlap.

• Aktivitas diasumsikan terurut berdasarkan waktu finish secara increasing:f1 ≤ f2 ≤ ... ≤ fn-1 ≤ fn

S Terurut Berdasarkan Waktu Selesai

• Ukuran maksimum dari himpunan yang saling compatible:{a1,a3,a6,a8},

• Bisa juga {a2,a5,a7,a9}

S Terurut Berdasarkan Waktu Selesai

• Ukuran maksimum dari himpunan yang saling compatible:{a1,a3,a6,a8}, dan {a2,a5,a7,a9}

Illustration Knapsack problem

Contoh Kasus Knapsack

W1 = 1 kg P1 = $10 , W2 = 1 kg P2 = $1

W3 = 1 kg P3 = $2 , W4 = 2 kg P4 = $2

W5 = 12kg P5= $4, Kapasitas Knapsack = 15 kg

Solusi Optimal X = (1,0,1,0,1)Greedy by profit memberikan solusi optimal

Property Objek Greedy by Solusi Optimali wi pi pi/wi weight profit density

1 1 10 10 1 1 1 12 1 1 1 1 0 1 03 1 2 2 1 1 1 14 2 2 1 1 0 1 05 12 4 0.33 0 1 0 1

Total Bobot 5 14 5 14Total Keuntungan 15 16 15 16

Penyelesaian dengan Greedy• Greedy by Profit

Pada setiap langkah Knapsack diisi dengan obyek yang mempunyai keuntungan terbesar.

Strategi ini mencoba memaksimumkan keuntungan dengan memilih objek yang paling menguntungkan terlebih dahulu.

Pertama kali dilakukan adalah menurutkan secara menurun obyek-obyek berdasarkan profitnya . Kemudian obyek-obyek yang dapat ditampung oleh knapsack diambil satu persatu sampai knapsack penuh atau (sudah tidak ada obyek lagi yang bisa dimasukan).

Penyelesaian dengan GreedyContoh Soal 1Data awal :

w1 = 6; p1 = 12 w2 = 5; p2 = 15 w3 = 10; p3 = 50 w4 = 5; p4 = 10

Kapasitas knapsack W = 16

Penyelesaian dengan Greedy

• Greedy by Wight

• Pada setiap langkah, knapsack diisi dengan objek yang mempunyai berat paling ringan. Strategi ini mencoba memaksimumkan keuntungan dengan memasukan sebanyak mungkin objek kedalam knapsack.

• Pertama kali yang dilakukan adalah mengurutkan secara menaik objek-objek berdasarkan weight-nya. Kemudian obyek-obyek yang dapat ditampung oleh knapsack diambil satu persatu sampai knapsack penuh atau (sudah tidak ada obyek lagi yang bisa dimasukan).

Penyelesaian dengan GreedyData awal :

w1 = 6; p1 = 12 w2 = 5; p2 = 15 w3 = 10; p3 = 50 w4 = 5; p4 = 10


Penyelesaian dengan Greedy• Greedy By Density

• Pada setiap langkah, knapsack diisi dengan obyek yang mempunyai densitas terbesar (perbandingan nilai dan berat terbesar).

• Strategi ini mencoba memaksimumkan keuntungan dengan memilih objek yang mempunyai keuntungan per unit berat terbesar.

• Pertama kali yang dilakukan adalah mencari nilai profit per unit/ density dari tiap-tiap objek. Kemudian obyek-obyek diurutkan berdasarkan densitasnya.

• Kemudian obyek-obyek yang dapat ditampung oleh knapsack diambil satu persatu sampai knapsack penuh atau (sudah tidak ada obyek lagi yang bisa dimasukan).

Penyelesaian dengan GreedyData awal :

w1 = 6; p1 = 12 w2 = 5; p2 = 15 w3 = 10; p3 = 50 w4 = 5; p4 = 10


Penyelesaian dengan GreedyPerbandingan hasil :

• Solusi optimal: X = (0, 1, 1, 0)• Greedy by profit dan greedy by density memberikan solusi optimal!

Prefix code

• Prefix code adalah kode dimana tidak ada satu codeword yang merupakan prefix dari codeword yang lain. Dalam pembahasan, kita selalu mengacu pada prefix code.

• Encoding=dengan menggabungkan karakter .– Contoh:bad=101.0.111

• DECODING– 11111010111=111.1101.0.111=

0 101 100 111 1101 1100

Representasi dengan Tree

• Untuk mempermudah proses decoding, kode bisa digambar dengan binary tree– Left child =0– Right child=1

• Kode yang optimal selalu direpresentasikan dengan full binary tree, dimana setiap node bukan daun selalu mempunyai dua anak.

• Dengan sifat dari binary tree, maka jika kita mempunyai alphabet C yang berisi karakter-karakter yang akan diambil, maka– Pohon akan mempunyai |C| daun dan– |C|-1 internal node

Membangun Huffman Code

• Pseudocode

• Running time = O(n lg n)

Penjabaran algoritma

• Step 1: ambil x dan y dari alphabet, dimana x dan y adalah karakter dengan frequensi terkecil. Buat subtree yang berisi x dan y sebagai anak dan z sebagai parent

• Step 2: atur frequensi z f(z)=f(x) + f(y)– Hilangkan x dan y dari queue dan masukkan subtree z ke

dalam queue• Ulangi langkah 2 sampai tinggal tersisa satu symbol• Pohon hasil dari metode di atas adalah Huffman

code

A B C D E F

Frequency(dalam ribu)

45 13 12 16 9 5

Panjang bervariasi 0 101 100 111 1101 1100

Misalnya sebuah berkas berisi 100.000 karakter dengan frekuensi kemunculan karakter dalam data dengan 3 bit kode untuk setiap karakternya

Maka untuk menyimpan data di dalam berkas tersebut, kita membutuhkan 300.000 karakter bit. Bila menggunakan kode Huffman:

Untuk menyimpan data di dalam berkas berisi 100.000 karakter, kita membutuhkan : ((0.45x1)+(0.13x3)+(0.12x3)+(0.16x3)+(0.09x4)+(0.05x4))x100.000=224.000bitDengan demikian kita telah melakukan kompresi data sebesar

Contoh

Misalnya data dengan panjang 100 karakter dan disusun oleh huruf-huruf a,b,c,d,e dengan frekuensi kemunculan setiap huruf sebagai berikut :

Langkah-Langkah Pembentukan Pohon Huffman

Algoritma BFS1. Deklarasikan dua list kosong, Open dan Close2. Tambahkan vertex awal ke Open3. Ketika Open tidak kosong, lakukan looping:

a. Hapus vertex awal dari Openb. Cek dan lihat apakah vertex yang dihapus adalah tujuan

i. Jika vertex yang dihapus adalah tujuan, keluar dari loop, tambahkan vertex ke Close, dan kembali ke nilai dari Close

ii. Jika vertex yang dihapus bukan tujuan, lanjutkan loopingc. Ekstrak tetangga dari vertex yang dihapus di atasd. Tambahkan tetangga ke akhir dari Open, dan tambahkan

vertex yang dihapus ke Close

⇒ Lintasan akhir yang akan diambil oleh metode BFS adalah nilai terakhir dari list Close

Contoh Penelusuran BFS• Mencari lintasan antara vertex A dan E• Langkah awal:

a. Dimulai dari vertex akar, yaitu A.b. Tambahkan A ke list Open.

Open: AClose: <kosong>

• Langkah 1:a. Periksa tetangga-tetangga dari A.b. Hapus A dari Open, tambahkan ke list Close.c. Tambahkan tetangga A, yaitu B dan C, ke list Open.

Open: B, CClose: A

Contoh Penelusuran BFS• Langkah 2:

a. Periksa vertex yang muncul pertama pada list Open, yaitu B.b. Karena B bukan tujuan, telusuri tetangganya, yaitu D dan E. Pindah B ke list Close.c. Tambahkan D dan E ke

akhir dari list Open.Open: C, D, EClose: A, B

• Langkah 3:a. Periksa vertex C.b. Karena C tidak memiliki tetangga, hapus C dari list Open.

Open: D, EClose: A, B, C

Contoh Penelusuran BFS• Langkah 4:

a. Periksa vertex D.b. Karena D bukan tujuan, dan tidak memiliki tetangga, hapus D dari list

Open dan tambahkan ke list Close.Open: EClose: A, B, C, D

• Langkah 5:a. List Open hanya memiliki satu vertex, yaitu E.b. Karena E adalah tujuan, maka penelusuran dapat dihentikan.

Open: <kosong>Close: A, B, C, D, E

Algoritma DFS1. Deklarasikan dua list kosong, Open dan Close2. Tambahkan vertex awal ke Open3. Ketika list Open tidak kosong, lakukan looping:

a. Hapus vertex awal dari Openb. Cek dan lihat apakah vertex yang dihapus adalah tujuan

i. Jika vertex yang dihapus adalah tujuan, keluar dari loop, tambahkan vertex ke list Close, dan kembali ke nilai dari list Close

ii. Jika vertex yang dihapus bukan tujuan, lanjutkan loopingc. Ekstrak tetangga dari vertex yang dihapus di atasd. Tambahkan tetangga ke awal dari Open, dan tambahkan vertex yang

dihapus ke Close

⇒ Lintasan akhir yang akan diambil oleh metode DFS adalah nilai terakhir dari list Close

Contoh Penelusuran DFS• Mencari lintasan antara vertex A dan F• Langkah awal:

a. Dimulai dari vertex akar, yaitu A.b. Tambahkan A ke list Open.

Open: AClose: <kosong>

• Langkah 1:a. Periksa tetangga-tetangga dari A.b. Hapus A dari Open, tambahkan ke list Close.c. Tambahkan tetangga A, yaitu B dan C, ke list Open.

Open: B, CClose: A

Contoh Penelusuran DFS• Langkah 2:

a. Periksa vertex yang muncul pertama pada list Open, yaitu B.b. Karena B bukan tujuan, telusuri tetangganya, yaitu D dan E. Pindah B ke list

Close.c. Tambahkan D dan E ke

awal dari list Open.Open: D, E, CClose: A, B

• Langkah 3:a. Periksa vertex pada awal dari list Open, yaitu D.b. Karena D bukan tujuan dan tidak mempunyai tetangga, hapus D dari list Open

dan tambahkan ke list Close.Open: E, CClose: A, B, D

Contoh Penelusuran DFS• Langkah 4:

a. Periksa vertex pada awal dari list Open, yaitu E.b. Karena E bukan tujuan, telusuri tetangga-tetangganya, yaitu F dan G.

Kemudian hapus E dari list Open dan tambahkan ke list Close.c. Tambahkan F dan G ke awal dari list Open.

Open: F, G, CClose: A, B, D, E

• Langkah 5:a. Periksa vertex pada awal dari list Open, yaitu F.b. Karena F adalah tujuan, maka penelusuran dapat dihentikan.c. Hapus F dari list Open dan tambahkan ke list Close.

Open: G, CClose: A, B, D, E, F

Minimum Spanning Tree

1 2

3

5

2

1 2

3

5

2

3

1 2

3

53

1 2

3

2

3

Terdapat 3 spanning tree :

Spanning Tree 1 Spanning Tree 2 Spanning Tree 3

Algoritma Prim1. Ambil sisi dari graf G yang

berbobot minimum, masukkan ke dalam T.

2. Pilih sisi (u,v) yang mempunyai bobot minimum dan bersisian dengan T, tetapi (u,v) tidak membentuk sirkuit di T. Tambahkan (u,v) ke dalam T.

3. Ulangi langkah 2 sampai pohon rentang minimum terbentuk, yaitu setelah mengalami pengulangan sebanyak n-2 kali (n adalah jumlah simpul graf G).

42

Contoh Prim1 2

3

44

Ilustrasi PRIM (i)

45

Algoritma Kruskal• Tahap pertama, jika dalam V terdapat n

verteks maka diinisialisasi n buah subset yang disjoint, masing-masing berisi satu verteks, sebagai subset-subset awal.

• Tahap berikutnya, urutkan sisi-sisi dengan bobot yang terkecil hingga terbesar.

• Mulai dari sisi dengan bobot terkecil hingga terbesar lakukan dalam iterasi: jika sisi tsb. menghubungkan dua verteks dalam satu subset (berarti membentuk siklik) maka skip sisi tersebut dan periksa sisi berikutnya jika tidak (berarti membentuk siklik) maka kedua subset dari verteks-verteks yang bersangkutan digabungkan menjadi satu subset yang lebih besar. Iterasi akan berlangsung hingga semua sisi terproses.

46

Ilustrasi Kruskal (i)

47

Ilustrasi Kruskal (iii)

Algoritma Kruskal(Implementasi)

Mencari Minimum Spanning Tree pada graph berbobot berikut ini :


Edge No Vertex Pair Edge Weight

E1 (0,2) 1

E2 (3,5) 2

E3 (0,1) 3

E4 (1,4) 3

E5 (2,5) 4

E6 (1,2) 5

E7 (2,3) 5

E8 (0,3) 6

E9 (2,4) 6

E10 (4,5) 6

Langkah 1 :Edge diurutkan secara ascending berdasarkan bobot


Langkah 2 :Menambahkan edge sesuai urutan, dengan mencegah Terbentuknya sirkuit

GraphTambahkan

edge E1


Tambahkan edge E2

Tambahkan edge E3


Tambahkan edge E4

Tambahkan edge E5

Algoritma Dijkstra

1. Tetapkan jarak semua simpul terhadap simpul A, yaitu infinity atau tak-hingga

untuk simpul yang lain dan 0 untuk simpul A. 2. Tandai semua simpul dengan status belum dikunjungi. Jadikan simpul awal sebagai

simpul terkini. 3. Untuk node terkini, hitung jarak semua tetangga simpul ini dengan menghitung

jarak (dari awal simpul). Misalnya, jika saat ini node (C) memiliki jarak dari simpul A sebesar 6, dan sisi yang menghubungkannya dengan node lain (B) adalah 2, jarak ke B melalui C akan menjadi 6 +2 = 8. Jika jarak ini kurang dari jarak yang sebelumnya (tak- hingga di awal) maka nilai jarak simpul B dengan simpul A akan berubah.

4. Setelah selesai mengecek semua tetangga dari simpul terkini, simpul terkini ditandai dangna status sudah dikunjungi.

5. Mengulang langkah tiga hingga lima, hingga semua simpul telah dikunjungi.

Setelah semua simpul dikunjungi maka akan didapati jarak minimum semua simpul terhadap simpul A.

Langkah – langkah floyd warshall

Proses penentuan nilai minimum algoritma floyd-warshall dapat dituliskan sebagai berikut: 1. Pada iterasi ke-1, setiap sel matriks dilakukan pengecekan apakah jarak

antar dua titik mula mula lebih besar dari penjumlahan antar jarak titik asal ke titik tujuan (titik tujuan=iterasi ke-1) dengan jarak titik asal (titik asal=iterasi ke-1) ke titik tujuan. Dengan kata lain apakah W[i,j] > W[i,k] + W[k,j].

2. Jika iya maka jarak antar dua titik mula mula diganti dengan penjumlahan antar jarak titik asal ke titik tujuan (titik tujuan=iterasi ke-1) dengan jarak titik asal (titik asal=iterasi ke-1) ke titik tujuan (W[i,k] + W[k,j]).

3. Jika tidak, maka jarak yang digunakan yaitu jarak antar dua titik mula mula (W[i,j]).

4. Proses iterasi dilakukan hingga pada iterasi terakhir (jumlah iterasi=jumlah total titik).

Bellman ford

Algoritma Welch Powell

1. Urutkan semua titik berdasarkan derajatnya dari derajat terbesar sampai yang terkecil

2. Ambil warna pertama. Warnai titik dengan derajat tertinggi dengan warna tersebut dan cari titik lain yang tak terhubung langsung dan berderajat maksimal lalu warnai dengan warna yang sama dan cari titik lain yang tak terhubung langsung.

3. Cari titik dengan derajat tinggi lainnya lalu beri warna yang beda

4. Ulangi langkah 2-3 sampai semua titik telah di beri warna setelah itu STOP

Contoh

Contoh

Titik v1 v3 v5 v7 v2 v4 v6

Derajat 5 4 4 4 3 3 3

warna a b b c c a d

Aplikasi / Penerapan Algoritma Welsh Powell

Sumber : Detty Purnamasari, Muhammad Zidni, Dessy Wulandari. 2012. Algoritma Welch-Powell untuk Pengendalian Lampu Lalu Lintas. UG Jurnal Vol.6 No.03.

– Kasus : Pengaturan lampu lalu lintas di simpang empat Kalimas tergolong tidak efektif

– Ilustrasi :


• Langkah-langkah penyelesaian :

1. Tentukan simpul dari perjalanan yang diperbolehkan langsung : AB, BC, CD, dan DA

2. Tentukan ruas yang menghubungkan 2 simpul yang menyatakan 2 perjalanan yang saling melintas (memungkinkan untuk saling bertabrakan)


3. Menyatukan simpul dan ruas menjadi satu-kesatuan yang utuh. Simpul AB, BC, CD, dan DA tidak dihubungkan karena simpul tersebut selalu berlaku lampu hijau.


4. Urutkan simpul yang memiliki derajat simpul terbesar hingga yang memiliki derajat simpul terkecil


d(AD) = 5 ; d(BA) = 5 ; d(CB) = 5 ; d(DC) = 5 ; d(AC) = 4 ; d(BD) = 4 ; d(CA) = 4 ; d(DB) = 45. Beri warna pada setiap simpul dengan warna baru.

Langkah-langkah untuk mewarnai setiap simpul : Beri warna pada setiap simpul secara berurutan dari yang

memiliki derajat simpul terbesar sampai dengan derajat simpul terkecil. Urutannya : AD, BA, CB, DC, AC, BD, CA, DB.

Ambil warna pertama misal Merah. Beri warna Merah simpul AD. Kemudian cari simpul yang tidak berdampingan dengan simpul AD, beri warna yang sama (Merah). Kita berikan warna yang sama pada simpul AC dengan warna simpul AD yaitu Merah, karena simpul AC tidak berdampingan dengan simpul AD.


Ambil warna kedua, misalnya Kuning. Warnai simpul BA. Kemudian cari simpul yang tidak berdampingan dengan simpul BA, beri warna yang sama (Kuning). Kita berikan warna yang sama pada simpul BD dengan warna simpul BA yaitu Kuning, karena simpul BD tidak berdampingan dengan simpul BA.

Ambil warna ketiga, misalnya Biru. Warnai simpul CB. Kemudian cari simpul yang tidak berdampingan dengan simpul CB, beri warna yang sama (Biru). Kita berikan warna yang sama pada simpul CA dengan warna simpul CB yaitu Biru, karena simpul CA tidak berdampingan dengan simpul CB.

Ambil warna keempat, misalnya Hijau. Warnai simpul DC dan DB.

6. Pewarnaan simpul telah selesai.


• Hasil Akhir : Fase 1 : Hijau (AD, AC, AB, CD, BC, DA)

Merah (BD, CA, DB, BA, CB, DC) Fase 2 : Hijau (BA, BD, AB, CD, BC, DA)

Merah (AC, CA, DB, AD, CB, DC) Fase 3 : Hijau (CB, CA, AB, CD, BC, DA)

Merah (AC, BD, DB, AD, BA, DC) Fase 4 : Hijau (DC, DB, AB, CD, BC, DA)

Merah (AC, BD, CA, AD, BA, CB)

aal presentasi kelompok

Documents