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

 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
optimal!)

(solusi

 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
optimal
Solusi optimal: 7 = 4 + 3
( 2 koin)
(b)
koin)
koin)

Koin: 10, 7, 1
Uang yang ditukar: 15
Solusi greedy: 15 = 10 + 1 + 1 + 1 + 1 + 1
Solusi optimal: 15 = 7 + 7 + 1

(6

(hanya 3

(c) Koin: 15, 10, dan 1

Uang yang ditukar: 20
Solusi 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.

Contoh 3: Tiga pelanggan dengan

t1 = 5, t2 = 10, t3 = 3,
Enam urutan pelayanan yang mungkin:
=====================================
=======
Urutan T
=====================================
=======
1, 2, 3: 5 + (5 + 10) + (5 + 10 + 3 ) = 38
1, 3, 2: 5 + (5 + 3) + (5 + 3 + 10) = 31
2, 1, 3: 10 + (10 + 5) + (10 + 5 + 3) = 43
2, 3, 1: 10 + (10 + 3) + (10 + 3 + 5) = 41
3, 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
=2
Kapasitas knapsack K = 100

Ketiga strategi gagal memberikan solusi

Contoh 6.
w1 = 18;
w3 = 10;

p1 = 25; w2 = 15; p1 = 24
p1 = 15 Kapasitas knapsack K = 20

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
Property Objek
Greedy by
i
wi
pi pi/wi weight profit density
1
2
3
4
5

1
1
1
2
12

10
10
1
1
2
2
2
1
4
0.33
Total Bobot
Total Keuntungan

1
1
1
1
0
5
15

1
0
1
0
1
14
16

1
1
1
1
0
5
15

Solusi
Optimal
1
0
1
0
1
14
16

Solusi Optimal X = (1,0,1,0,1)

Greedy by profit memberikan solusi optimal

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
Greedy
Contoh Soal 1
Data awal :
w1
w2
w3
w4

=
=
=
=

6;
5;
10;
5;

p1
p2
p3
p4

=
=
=
=

12
15
50
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
Greedy
Data awal :
w1
w2
w3
w4

=
=
=
=

6;
5;
10;
5;

p1
p2
p3
p4

=
=
=
=

12
15
50
10

Kapasitas knapsack W = 16

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
Greedy
Data awal :
w1
w2
w3
w4

=
=
=
=

6;
5;
10;
5;

p1
p2
p3
p4

=
=
=
=

12
15
50
10

Kapasitas knapsack W = 16

Penyelesaian dengan
Greedy
Perbandingan 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.
0 10 10 11 110 1100
Encoding=dengan menggabungkan
1
0
1
1
karakter .
Contoh:bad=101.0.111

DECODING
11111010111=111.1101.0.111=

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

Frequency(dalam 45
ribu)

13

12

16

Panjang
bervariasi

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))x1
00.000=224.000bit
Dengan 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 BFS
1. Deklarasikan dua list kosong, Open dan Close
2. Tambahkan vertex awal ke Open
3. Ketika Open tidak kosong, lakukan looping:
a. Hapus vertex awal dari Open
b. 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 looping
c. Ekstrak tetangga dari vertex yang dihapus di atas
d. 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: A
Close: <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, C
Close: 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, E
Close: A, B

. Langkah 3:
a.
Periksa vertex C.
b.
Karena C tidak memiliki tetangga, hapus C dari list Open.
Open: D, E
Close: 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: E
Close: 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 DFS
1. Deklarasikan dua list kosong, Open dan Close
2. Tambahkan vertex awal ke Open
3. Ketika list Open tidak kosong, lakukan looping:
a. Hapus vertex awal dari Open
b. 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 looping
c. Ekstrak tetangga dari vertex yang dihapus di atas
d. 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: A
Close: <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, C
Close: 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, C
Close: 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, C
Close: 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, C
Close: 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, C
Close: A, B, D, E, F

Minimum Spanning Tree

1

3
3

Terdapat 3 spanning tree :

1

5
3

Spanning
Tree 1

3
3

Spanning
Tree 2

3
3

Spanning
Tree 3

Algoritma
Prim

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

Contoh Prim
2

42

Ilustrasi PRIM (i)

44

Algoritma Kruskal
Tahap pertama, jika dalam V
terdapat
n
verteks
maka
diinisialisasi n buah subset yang
disjoint, masing-masing berisi
satu verteks, sebagai subsetsubset awal.
Tahap berikutnya, urutkan sisisisi 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
45

Ilustrasi Kruskal (i)

46

Ilustrasi Kruskal (iii)

47

Algoritma Kruskal
(Implementasi)
Mencari Minimum Spanning Tree pada graph
berbobot berikut ini :

Algoritma Kruskal
(Implementasi)

ngkah 1 :Edge diurutkan secara ascending berdasarkan bobo

Edge No

Vertex Pair

Edge Weight

E1

(0,2)

E2

(3,5)

E3

(0,1)

E4

(1,4)

E5

(2,5)

E6

(1,2)

E7

(2,3)

E8

(0,3)

E9

(2,4)

E10

(4,5)

Algoritma Kruskal
(Implementasi)

ngkah 2 :Menambahkan edge sesuai urutan, dengan menceg

bentuknya sirkuit

Graph

Tambahkan
edge E1

Algoritma Kruskal
(Implementasi)

Tambahkan
edge E2

Tambahkan
edge E3

Algoritma Kruskal
(Implementasi)

Tambahkan
edge E4

Tambahkan
edge E5

Algoritma Dijkstra
1.Tetapkan jarak semua simpul terhadap simpul A, yaitu infinity atau takhingga 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

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

warna

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 :

Aplikasi / Penerapan Algoritma

Welsh Powell
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)

Aplikasi / Penerapan Algoritma

Welsh Powell

Aplikasi / Penerapan Algoritma

Welsh Powell

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.

Aplikasi / Penerapan Algoritma

Welsh Powell

4. Urutkan simpul yang memiliki derajat simpul terbesar hingga

yang memiliki derajat simpul terkecil

Aplikasi / Penerapan Algoritma

Welsh Powell
d(AD) = 5 ; d(BA) = 5 ; d(CB) = 5 ; d(DC) = 5 ; d(AC) =
4 ; d(BD) = 4 ; d(CA) = 4 ; d(DB) = 4
5. 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.

Aplikasi / Penerapan Algoritma

Welsh Powell

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.

Aplikasi / Penerapan Algoritma Welsh

Powell

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)