ALGORITMA BRUTE FORCE

DAN ALGORITMA GREEDY

ANALISIS DAN PERANCANGAN ALGORITMA

Disusun oleh :

Anissa Azhari

3411181167

PROGRAM STUDI INFORMATIKA

FAKULTAS SAINS DAN INFORMATIKA

UNIVERSITAS JENDRAL ACHMAD YANI

2020
Daftar Isi

Daftar Isi..............................................................................................................................i
BAB I ALGORTIMA BRUTE FORCE............................................................................1
1.1 Pengertian..........................................................................................................1
1.2 Tahapan Algoritma Umum.................................................................................1
1.3 Contoh Masalah & Penjelasan Penyelesaian......................................................2
1.3.1 Mencari Elemen Terbesar...........................................................................2
1.3.2 Pencarian Beruntun (Sequential Search)....................................................2
1.3.3 Menghitung an (a > 0, n adalah bilangan bulat tak-negatif)........................3
1.3.4 Menghitung n! (n bilangan bulat tak-negatif).............................................4
1.3.5 Mengalikan dua buah matriks, A dan B......................................................4
1.3.6 Tes Bilangan Prima.....................................................................................5
1.3.7 Selection Sort.............................................................................................6
1.3.8 Bubble Sort.................................................................................................7
1.3.9 Mengevaluasi Polinom...............................................................................8
1.3.10 Pencocokan String (String Matching)..........................................................9
1.3.11 Mencari Pasangan Titik yang Jaraknya Terdekat (Closest Pairs)...............12
1.3.12 Exhaustive search.....................................................................................13
1.4 Kelebihan dan Kekurangan...............................................................................16
2.4.1. Kelebihan..................................................................................................16
2.4.2. Kekurangan...............................................................................................16
BAB II ALGORITMA GREEDY....................................................................................17
2.1 Pengertian........................................................................................................17
2.2 Tahapan Algoritma Umum...............................................................................18
2.3 Contoh Masalah & Penjelasan Penyelesaian....................................................19
2.3.1 Persoalan Penukaran Uang.......................................................................19
2.3.2 Minimisasi Waktu di dalam Sistem (Penjadwalan)...................................20
2.3.3 An Activity Selection Problem...................................................................22
2.3.4 Integer Knapsack......................................................................................23
2.3.5 Fractional Knapsack..................................................................................24

i
 2.3.6 Penjadwalan Job dengan Tenggat Waktu (Job Schedulling with Deadlines)
26
2.3.7 Pohon Merentang Minimum....................................................................27
2.3.8 Lintasan Terpendek (Shortest Path).........................................................29
2.3.9 Pemampatan Data dengan Algoritma Huffman........................................32
2.4 Kelebihan dan Kekurangan...............................................................................32
2.4.1. Kelebihan..................................................................................................32
2.4.2. Kekurangan...............................................................................................33
BAB III IMPLEMENTASI..............................................................................................34
3.1 Bubble Sort.......................................................................................................34
3.2 Bilangan Prima.................................................................................................35
3.3 Bilangan Polinom..............................................................................................35
3.4 Perbandingan String.........................................................................................36
3.5 Jarak Antar Titik................................................................................................37
3.6 Travelling Salesman Problem...........................................................................39
3.7 Knapsack Problem............................................................................................40
3.8 Coin Exchange..................................................................................................41
3.9 Penjadwalan Pelanggan....................................................................................42
3.10 Fractional Knapsack..........................................................................................43
3.11 Job Schedulling 1..............................................................................................45
3.12 Algoritma Prim.................................................................................................47
3.13 Algoritma Kruskal.............................................................................................49
3.14 Algoritma Dijkstra.............................................................................................52
3.15 Kode Kompresi Huffman...................................................................................54

ii
 BAB I
ALGORTIMA BRUTE FORCE
1.1 Pengertian
Dalam beberapa literature, algoritma merupakan suatu langkah-langkah
tertentu yang logis dalam memecahkan ataupun menyelesaikan masalah yang
disusun secara sistematis dan memiliki urutan langkah. Meskipun dalam hal ini
algoritma sering dikaitkan dengan komputer, akan tetapi algoritma juga dapat
diterapkan dalam menyelesaikan masalah di kehidupan sehari-hari.

Brute Force adalah sebuah pendekatan yang lempang (straight forward)

untuk memecahkan suatu masalah, biasanya didasarkan pada pernyataan masalah
(problem statement) dan definisi konsep yang dilibatkan. Algoritma Brute Force
memecahkan masalah dengan sangat sederhana, langsing dan dengan cara yang
jelas. Kekuatan algoritma brute force terletak pada kemampuannya untuk
menemukan semua pemecahan masalah yang mungkin. Algoritma brute force
membutuhkan langkah yang sangat banyak karena menelususri semua
kemungkinan penyelesaian masalah, sehingga cenderung menjadi tidak mangkus
jika digunakan untuk memecahkan masalah dengan masukan yang dangat besar.

1.2 Tahapan Algoritma Umum

1. Algoritma brute force mulai mencocokan pattern pada awal teks
2. Dari kiri ke kanan, algoritma ini akan mencocokan karakter per karakter pattern
dengan karakter di teks yang bersesuaian, sampai salah satu kondisi berikut
dipenuhi:
 Karakter di pettern dan di teks yang dibandingkan tidak cocok
 Semua karakter di pattern cocok, kemudian algoritma akan
memberitahukan penemuan di posisi ini.
3. Algoritma kemudian terus menggeser pattern sebesar satu ke kanan, dan
mengulangi langkah ke-2 sampai pattern berada si ujung teks.

1
1.3 Contoh Masalah & Penjelasan Penyelesaian

1.3.1 Mencari Elemen Terbesar

Diberikan sebuah senarai yang beranggotakan n buah bilangan bulat (a 1, a2,
…, an). Carilah elemen terbesar di salam senarai tersebut. Algoritma brute
force: bandingkan setiap elemen senarai untuk menemukan elemen terbesar.

procedure CariElemenTerbesar (input a1,a2, …, an : integer, output maks :

integer)
{Mencari elemen terbesar di antara elemen a 1,a2, …, an. Elemen terbesar
akan disimpan di dalam maks.
Masukan : a1,a2, …, an
Keluaran : maks
}
Deklarasi
k : integer
Algoritma
maks  a1
for k  2 to n do
if ak > maks then
maksak
endif
endfor
1.3.2 Pencarian Beruntun (Sequential Search)
Diberikan senarai yang berisi n buah bilangan bulat (a 1 , a2 , …, an ). Carilah
nilai x di dalam senarai tersebut. Jika x ditemukan, maka keluarannya adalah
indeks elemen senarai, jika x tidak ditemukan, maka keluarannya adalah -1.
Algoritma brute force (sequential search): setiap elemen senarai
dibandingkan dengan x. Pencarian selesai jika x ditemukan atau elemen
senarai sudah habis diperiksa.

procedure PencarianBeruntun(input a 1, a 2, ..., a n: integer, x: integer,

output idx : integer)
{Mencari x di dalam elemen a 1, a2, ..., an. Lokasi (indeks elemen)
tempat x ditemukan diisi ke dalam idx. Jika x tidak ditemukan, maka

2
 idx diisi dengan 0.
Masukan: a 1, a 2, ..., a n
Keluaran: idx
}
Deklarasi
k: integer
Algoritma:
k←1
while (k < n) and (ak != x) do
k←k+1
endwhile
{k = n or ak = x}

if ak = x then { x ditemukan }
idx ← k
else
idx ← -1 { x tidak ditemukan }
endif
1.3.3 Menghitung an (a > 0, n adalah bilangan bulat tak-negatif)
Definisi:

an = a x a x … x a (n kali) , jika n > 0

=1 , jika n = 0

Algoritma Brute Force : kalikan 1 dengan a sebanyak n kali

function pangkat(a : real, n : integer) ← real

{Menghitung a^n }
Deklarasi
i : integer
hasil : real
Algoritma:
hasil ← 1
for i ← 1 to n do
hasil ← hasil * a

3
 endfor
return hasil
1.3.4 Menghitung n! (n bilangan bulat tak-negatif)
n! = 1 × 2 × 3 × … × n , jika n > 0
=1 , jika n = 0
Algoritma Brute Force : kalikan n buah bilangan, yaitu 1, 2, 3, …, n,
bersama-sama.

function faktorial (n : integer) → integer

{ Menghitung n! }
Deklarasi
i : integer
fak : real
Algoritma:
fak ← 1
for i ← 1 to n do
fak ← fak * i
end
return fak
1.3.5 Mengalikan dua buah matriks, A dan B
Misalkan C = A × B dan elemen-elemen matrik dinyatakan sebagai c ij,
aij, dan bij.

n
Cij = a i1b1j + ai2b2j + … + a inbnj = ∑ aik bkj
k =1

Algoritma brute force: hitung setiap elemen hasil perkalian satu per
satu,dengan cara mengalikan dua vektor yang panjangnya n

procedure PerkalianMatriks(input A, B : Matriks, input n : integer,

output C : Matriks)
{ Mengalikan matriks A dan B yang berukuran n × n, menghasilkan
matriks C yang juga berukuran n × n
Masukan: matriks integer A dan B, ukuran matriks n
Keluaran: matriks C
}

4
 Deklarasi
i, j, k : integer
Algoritma
for i←1 to n do
for j←1 to n do
C[i,j]←0 { inisialisasi penjumlah }
for k ← 1 to n do
C[i,j]←C[i,j] + A[i,k]*B[k,j]
endfor
endfor
endfor
1.3.6 Tes Bilangan Prima
Diberikan sebuah bilangan bilangan bulat positif. Periksa apakah
bilangan tersebut adalah bilangan prima atau bukan. Bilangan prima
adalah bilangan yang hanya habis dibagi oleh 1 dan dirinya sendiri.
Algoritma Brute Force : bagi n dengan 2 sampai √ n. Jika semuanya
tidak habis membagi n, maka n adalah bilangan prima.

function Prima(input x : integer)→boolean

{ Menguji apakah x bilangan prima atau bukan.
Masukan: x
Keluaran: true jika x prima, atau false jika x tidak prima.
}
Deklarasi
k, y : integer
test : boolean
Algoritma:
if x < 2 then { 1 bukan prima }
return false
else if x = 2 then { 2 adalah prima, kasus khusus }
return true
else
y ← [√ x]
test ← true

5
 while (test) and (y ← 2) do
if x mod y = 0 then
test ← false
else
y←y-1
endif
endwhile
{ not test or y < 2 }
return test
endif
endif
1.3.7 Selection Sort
Pass ke –1:

1. Cari elemen terkecil mulai di dalam s[1..n]

2. Letakkan elemen terkecil pada posisi ke-1 (pertukaran)

Pass ke-2:

1. Cari elemen terkecil mulai di dalam s[2..n]

2. Letakkan elemen terkecil pada posisi 2 (pertukaran)

Ulangi sampai hanya tersisa 1 elemen. Semuanya ada n –1 kali pass.

procedure SelectionSort(input/output s : array [1..n] of integer)

{ Mengurutkan s1, s2, ..., sn sehingga tersusun menaik dengan metode
pengurutan seleksi.
Masukan: s1, s2, ..., sn
Keluaran: s1, s2, ..., sn (terurut menaik)
}
Deklarasi
i, j, imin, temp : integer
Algoritma:
for i ← 1 to n-1 do { jumlah pass sebanyak n – 1 }
{cari elemen terkecil di dalam s[i], s[i+1, ..., s[n] }
imin ← i { elemen ke-i diasumsikan sebagai elemen
terkecil sementara }

6
 for j ← i+1 to n do
if s[j] < s[imin] then
imin ← j
endif
endfor
{pertukarkan s[imin] dengan s[i] }
temp ← s[i]
s[i] ← s[imin]
s[imin] ← temp
endfor
1.3.8 Bubble Sort
Mulai dari elemen ke-1:
1. Jika s2 < s1, pertukarkan
2. Jika s3 < s2, pertukarkan
…
3. Jika sn – 1 < sn, pertukarkan
Ulangi lagi untuk pass ke-2, 3, .., n – 1 dst. Semuanya ada n – 1 kali pass
procedure BubbleSort (input/output s : TabelInt, input n : integer)
{ Mengurutkan tabel s[1..N] sehingga terurut menaik dengan metode
pengurutan bubble sort.
Masukan : Tabel s yang sudah terdefenisi nilai-nilainya.
Keluaran: Tabel s yang terurut menaik sedemikian sehingga
s[1] ≤ s[2] ≤… ≤ s[N].
}
Deklarasi
i : integer { pencacah untuk jumlah langkah }
k: integer { pencacah,untuk pengapungan pada setiap langkah }
temp : integer { peubah bantu untuk pertukaran }
Algoritma:
for i ← n-1 downto 1 do
for k ← 1 to i do
if s[k+1] < s[k] then
{pertukarkan s[k] dengan s[k+1]}
temp ← s[k]

7
 s[k] ← s[k+1]
s[k+1] ← temp
endif
endfor
endfor
1.3.9 Mengevaluasi Polinom
Persoalan: Hitung nilai polinom

p(x) = anxn + a n-1x n-1 + … + a 1x + a 0 untuk x = t.

Algoritma Brute Force : xi dihitung secara Brute Force (seperti

n i
perhitungan a ). Kalikan nilai x dengan a i, lalu jumlahkan dengan suku-
suku lainnya.

function polinom(input t : real)→real

{ Menghitung nilai p(x) pada x = t. Koefisien-koefisein polinom sudah
disimpan di dalam a[0..n].
Masukan: t
Keluaran: nilai polinom pada x = t.
}
Deklarasi
i, j : integer
p, pangkat : real
Algoritma:
p←0
for i ← n downto 0 do
pangkat ← 1
for j ← 1 to i do {hitung xi}
pangkat ← pangkat * t
endfor
p ← p + a[i] * pangkat
endfor
return p
Perbaikan (improve):

function polinom2(input t : real)→real

8
 { Menghitung nilai p(x) pada x = t. Koefisien-koefisein polinom
sudah disimpan di dalam a[0..n].
Masukan: t
Keluaran: nilai polinom pada x = t.
}
Deklarasi
i, j : integer
p, pangkat : real
Algoritma:
p ← a[0]
pangkat←1
for i ← 1 to n do
pangkat ← pangkat * t
p ← p + a[i] * pangkat
endfor
return p
1.3.10 Pencocokan String (String Matching)
Persoalan: Diberikan

a. teks (text), yaitu (long) string dengan panjang n karakter

b. pattern, yaitu string dengan panjang m karakter (asumsi: m < n)

Carilah lokasi pertama di dalam teks yang bersesuaian dengan pattern.

Algoritma Brute Force :

1. Mula-mula pattern dicocokkan pada awal teks.

2. Dengan bergerak dari kiri ke kanan, bandingkan setiap karakter
di dalam pattern dengan karakter yang bersesuaian di dalam teks
sampai:
 semua karakter yang dibandingkan cocok atau sama
(pencarian berhasil), atau
 dijumpai sebuah ketidakcocokan karakter (pencarian
belum berhasil)
3. Bila pattern belum ditemukan kecocokannya dan teks belum
habis, geser pattern satu karakter ke kanan dan ulangi langkah 2.

9
 procedure PencocokanString(input P : string, T : string, n, m :
integer, output idx : integer)
{ Masukan: pattern P yang panjangnya m dan teks T yang
panjangnya n. Teks T direpresentasika sebagai string (array of
character)
Keluaran: lokasi awal kecocokan (idx)
}
Deklarasi
i : integer
ketemu : boolean
Algoritma:
i←0
ketemu←false
while (i ← n-m) and (not ketemu) do
j←1
while (j <= m) and (Pj = Ti+j ) do
j←j+1
endwhile
{ j > m or Pj != Ti+j }
if j = m then { kecocokan string ditemukan }
ketemu←true
else
i←i+1 {geser pattern satu karakter ke kanan teks }
endif
endwhile
{ i > n – m or ketemu }
if ketemu then
idx←i+1
else
idx←-1
endif
Analisis:

a. Worst Case

10
 Pada setiap pergeseran pattern, semua karakter di pattern dibandingkan.
Jumlah perbandingan: m(n – m + 1) = O(mn)

Contoh:
T: "aaaaaaaaaaaaaaaaaaaaaaaaaah"
P: "aaah"
b. Base Case

Kompleksitas kasus terbaik adalah O(n). Terjadi bila karakter pertama

pattern P tidak pernah sama dengan karakter teks T yang dicocokkan
Jumlah perbandingan maksimal n kali.

Contoh:

T: String ini berakhir dengan zzz

P: zzz
c. Average Case

Pencarian pada teks normal (teks biasa). Kompleksitas O(m+n).

Contoh:

T: "a string searching example is standard"

P: "store"

1.3.11 Mencari Pasangan Titik yang Jaraknya Terdekat (Closest

Pairs)
Diberikan n buah titik (2-D atau 3D), tentukan dua buah titik yang
terdekat satu sama lain.

11
Jarak dua buah titik, p1 = (x1, y1) dan p2 = (x2, y2) dihitung dengan
rumus Euclidean:

d = √ ( x 1−x 2 )2+( y 1− y 2 )2
Algoritma Brute Force :

1. Hitung jarak setiap pasang titik.

2. Pasangan titik yang mempunyai jarak terpendek itulah jawabannya.

Algoritma Brute Force akan menghitung sebanyak C(n, 2) = n(n – 1)/2

pasangan titik dan memilih pasangan titik yang mempunyai jarak
terkecil. Kompleksitas algoritma adalah O(n2).

procedure CariDuaTitikTerdekat(input P : SetOfPoint, n : integer,

output P1, P2 : Point)
{ Mencari dua buah titik di dalam himpunan P yang jaraknya terdekat.
Masukan: P = himpunan titik, dengan struktur data sebagai berikut
type Point = record(x : real, y : real)
type SetOfPoint = array [1..n] of Point
Keluaran: dua buah titik, P1 dan P2 yang jaraknya terdekat.}
Deklarasi
d, dmin : real
i, j : initeger

12
 Algoritma:
dmin←9999
for i←1 to n-1 do
for j←i+1 to n do
2 2
√
d ← ( ( pi . x− p j . x ) + ( p i . y + p j . y ) )

if d < dmin then { perbarui jarak terdekat }

dmin←d
P1←Pi
P2←Pj
endif
endfor
endfor
1.3.12 Exhaustive search
Exhaustive search adalah teknik pencarian solusi secara brute force untuk
persoalan-persoalan masalah kombinatorik. Biasanya di antara objek-
objek kombinatorik seperti permutasi, kombinasi, atau himpunan bagian
dari sebuah himpunan. Langkah-langkah metode exhaustive search:

1. Enumerasi (list) setiap solusi yang mungkin dengan cara yang

sistematis.
2. Evaluasi setiap kemungkinan solusi satu per satu, simpan solusi
terbaik yang ditemukan sampai sejauh ini (the best solusi found so
far).
3. Bila pencarian berakhir, umumkan solusi terbaik (the winner) •
Meskipun exhaustive search secara teoritis menghasilkan solusi,
namun waktu atau sumberdaya yang dibutuhkan dalam pencarian
solusinya sangat besar.
Contoh exhaustive search
1. Travelling Salesperson Problem
Diberikan n buah kota serta diketahui jarak antara setiap kota
satu sama lain. Temukan perjalanan (tour) terpendek yang
melalui setiap kota lainnya hanya sekali dan kembali lagi ke
kota asal keberangkatan. Pesoalan TSP tidak lain adalah
menemukan sirkuit Hamilton dengan bobot minimum.

13
 Algoritma exhaustive search untuk TSP:
1. Enumerasikan (list) semua sirkuit Hamilton dari graf lengkap
dengan n buah simpul.
2. Hitung (evaluasi) bobot setiap sirkuit Hamilton yang
ditemukan pada langkah 1.
3. Pilih sirkuit Hamilton yang mempunyai bobot terkecil. 50
Contoh 4: TSP dengan n = 4, simpul awal = a
Contoh:
TSP dengan n = 4, simpul awal = a

R
ute perjalananan terpendek dengan bobot = 32 adalah:
acbda
adbca
2. 1/0 Knapsack Problem

14
Diberikan n buah objek dan sebuah knapsack dengan
kapasitas bobot K. Setiap objek memiliki properti bobot
(weigth) wi dan keuntungan(profit) pi. Bagaimana memilih
memilih objek-objek yang dimasukkan ke dalam knapsack
sedemikian sehingga diperoleh keuntungan yang maksimal.
Total bobot objek yang dimasukkan ke dalam knapsack
tidak boleh melebihi kapasitas knapsack. Persoalan 0/1
Knapsack dapat kita pandang sebagai mencari himpunan
bagian (subset) dari keseluruhan objek yang muat ke dalam
knapsack dan memberikan total keuntungan terbesar.

Solusi persoalan dinyatakan sebagai:

X = {x1, x2, …, x}

xi = 1, jika objek ke-i dipilih,

xi = 0, jika objek ke-i tidak dipilih.

Algoritma Exhaustive Search:

1. Enumerasikan (list) semua himpunan bagian dari himpunan

dengan n objek.
2. Hitung (evaluasi) total keuntungan dari setiap himpunan
bagian dari langkah 1.

15
 3. Pilih himpunan bagian yang memberikan total keuntungan
terbesar.

1.4 Kelebihan dan Kekurangan

2.4.1. Kelebihan
 Metode brute force dapat digunakan untuk memecahkan hampir sebagian
besar masalah (wide applicability).
 Metode brute force sederhana dan mudah dimengerti.
 Metode brute force menghasilkan algoritma yang layak untuk beberapa
masalah penting seperti pencarian, pengurutan, pencocokan string, perkalian
matriks.
 Metode brute force menghasilkan algoritma baku (standard) untuk tugas-
tugas komputasi seperti penjumlahan/perkalian n buah bilangan, menentukan
elemen minimum atau maksimum di dalam tabel (list).

2.4.2. Kekurangan
 Metode brute force jarang menghasilkan algoritma yang mangkus.
 Beberapa algoritma brute force lambat sehingga tidak dapat diterima.
 Tidak sekontruktif/sekreatif teknik pemecahan masalah lainnya.

16
 BAB II
ALGORITMA GREEDY
2.1 Pengertian
Algoritma Greedy merupakan metode yang paling populer untuk
memecahkan persoalan optimasi. Persoalan optimasi (optimization
problems) merupakan persoalan untuk mencari solusi optimum. . Terdapat
dua macam persoalan optimasi:

1. Maksimasi (maximization)
2. Minimasi (minimization)

Algoritma Greedy membentuk solusi langkah per langkah (step by

step). Pada setiap langkah, terdapat banyak pilihan yang perlu dievaluasi.
Oleh karena itu, pada setiap langkah harus dibuat keputusan yang terbaik
dalam menentukan pilihan tanpa memperhatikan konsekuensi ke depan.
Pada setiap langkah, algoritma Greedy membuat pilihan optimum lokal
(local optimum) dengan harapan bahwa langkah sisanya mengarah ke
solusi optimum global (global optimum).

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.

Elemen-elemen Algoritma Greedy :

1. Himpunan kandidat, C.
2. Himpunan solusi, S
3. Fungsi seleksi (selection function)
4. Fungsi kelayakan (feasible)
5. Fungsi obyektif

17
 Algoritma Greedy melibatkan pencarian sebuah himpunan bagian, S,
dari himpunan kandidat, C, yang dalam hal ini, S harus memenuhi
beberapa kriteria yang ditentukan, yaitu menyatakan suatu solusi dan S
dioptimisasi oleh fungsi obyektif.

2.2 Tahapan Algoritma Umum

function Greedy (input C: himpunan_kandidat) → himpunan_kandidat
{ Mengembalikan solusi dari persoalan optimasi dengan algoritma Greedy
Masukan: himpunan kandidat C
Keluaran: himpunan solusi yang bertipe himpunan_kandidat
}
Deklarasi
x : kandidat
S : himpunan_kandidat
Algoritma:
S ← {} { inisialisasi S dengan kosong }
while (not SOLUSI(S)) and (C != {} ) do
x ← SELEKSI(C) {pilih sebuah kandidat dari C}
C ← C - {x} {elemen himpunan kandidat berkurang satu}
if LAYAK (S U {x}) then
S ← S U {x}
endif
endwhile
{SOLUSI(S) or C = {} }
if SOLUSI(S) then
return S
else
write(’tidak ada solusi’)
endif
Pada akhir setiap lelaran, solusi yang terbentuk adalah optimum lokal.
Pada akhir perulangan while-do diperoleh optimum global. Optimum global
belum tentu merupakan solusi optimum (terbaik), tetapi sub-optimum atau
pseudo optimum. Alasannya:

18
  Algoritma Greedy tidak beroperasi secara menyeluruh terhadap
semua alternatif solusi yang ada (sebagaimana pada metode
exhaustive search).
 Terdapat beberapa fungsi SELEKSI yang berbeda, sehingga kita
harus memilih fungsi yang tepat jika kita ingin algoritma
menghasilkan solusi optimal.

Jadi, pada sebagian masalah algoritma Greedy tidak selalu berhasil

memberikan solusi yang optimal.

2.3 Contoh Masalah & Penjelasan Penyelesaian

2.3.1 Persoalan Penukaran Uang

Nilai uang yang ditukar: A Himpunan koin (multiset): {d1 , d2 , …}.
Himpunan solusi: X = {x1 , x2 , …, xn }, xi = 1 jika di dipilih, xi = 0 jika di
tidak dipilih.

Obyektif persoalan:

n
Minimisasi : F = ∑ xi (fungsi objektif)
i=1

n
Dengan kendala ∑ dixi= A
i=1

Penyelesaian dengan Exhaustive Search

 Terdapat 2 n kemungkinan solusi (nilai-nilai X = {x 1, x2, …,

xn}).
 Untuk mengevaluasi fungsi obyektif = O(n).

Kompleksitas algoritma exhaustive search seluruhnya = O(n2 n).

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 }

19
 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 U {x}
endif
endwhile
if (Σ (nilai semua koin di dalam S) = A then
return S
else
write(’tidak ada solusi’)
endif
Agar pemilihan koin berikutnya optimal, maka perlu mengurutkan
himpunan koin dalam urutan yang menurun (noninceasing order). Jika
himpunan koin sudah terurut menurun,maka kompleksitas algoritma
Greedy = O(n). Algoritma Greedy untuk masalah penukaran uang ini tidak
selalu menghasilkan solusi optimal (lihat contoh sebelumnya).

2.3.2 Minimisasi Waktu di dalam Sistem (Penjadwalan)

Sebuah server (dapat berupa processor, pompa, kasir di bank, dll)
mempunai n pelanggan (customer, client) yang harus dilayani. Waktu
pelayanan untuk setiap pelanggan i adalah t i.

Minimumkan total waktu di dalam sistem:

n
T = ∑ ❑ (Waktu di dalam sistem)
i=1

Ekivalen dengan meminimumkan waktu rata-rata pelanggan di dalam

sistem.

Penyelesaian dengan Exhaustive Search

 Urutan pelangan yang dilayani oleh server merupakan suatu

permutasi

20
  Jika ada n orang pelanggan, maka tedapat n! urutan pelanggan
 Untuk mengevaluasi fungsi obyektif : O(n)
 Kompleksitas algoritma exhaustive search = O(nn!)

Penyelesaian dengan algoritma greedy

 Strategi greedy: Pada setiap langkah, pilih pelanggan yang

membutuhkan waktu pelayanan terkecil di antara pelanggan lain
yang belum dilayani.

function PenjadwalanPelanggan(input C : himpunan_pelanggan) →

himpunan_pelanggan
{mengembalikan urutan jadwal pelayanan pelanggan yang
meminimumkan waktu di dalam sistem}
Deklarasi
S : himpunan_pelanggan
i : pelanggann
Algoritma
S ← {}
while (C != {}) do
i ← pelanggan yang mempunyai t[i] terkecil
C ← C - {i}
S ← S U {i}
endwhile
return S
Agar proses pemilihan pelanggan berikutnya optimal, urutkan pelanggan
berdasarkan waktu pelayanan dalam urutan yang menaik. Jika pelanggan
sudah terurut, kompleksitas algoritma Greedy = O(n).Algoritma Greedy
untuk penjadwalan pelanggan akan selalu menghasilkan solusi optimum.

Jika pelanggan sudah terurut, kompleksitas algoritma greedy = O(n).

procedure PenjadwalanPelanggan (input n:integer)

{ Mencetak informasi deretan pelanggan yang akan diproses oleh server
tunggal
Masukan: n pelangan, setiap pelanggan dinomori 1, 2, …, n
Keluaran: urutan pelanggan yang dilayani }

21
 Deklarasi
i : integer
Algoritma:
{pelanggan 1, 2, ..., n sudah diurut menaik berdasarkan ti}
for i1 to n do
write(‘Pelanggan ‘, i, ‘ dilayani!’)
endfor
Algoritma greedy untuk penjadwalan pelanggan akan selalu menghasilkan
solusi optimum.

 Teorema. Jika t1  t2  …  tn maka pengurutan ij = j, 1  j  n

n k
meminimumkan T = ∑ ∑ t i j
k =1 j=1

untuk semua kemungkinan permutasi ij .

2.3.3 An Activity Selection Problem

Misalkan kita memiliki S = {1, 2, …, n} yang menyatakan n buah
aktivitas yang ingin menggunakan sebuah resource, misalnya ruang
pertemuan, yang hanya dapat digunakan satu aktivitas setiap saat.

Tiap aktivitas i memiliki waktu mulai s i dan waktu selesai f i, dimana

si ≤ fi. Dua aktivitas i dan j dikatakan kompatibel jika interval [s i, fi]
dan [sj, fj] tidak bentrok. Masalah Activity selection problem ialah
memilih sebanyak mungkin aktivitas yang bisa dilayani.

Penyelesaian dengan Exhaustive Search

 Tentukan semua himpunan bagian dari himpunan dengan n

aktivitas.
 Evaluasi setiap himpunan bagian apakah semua aktivitas di
dalamnya kompatibel.
 Jika kompatibel, maka himpunan bagian tersebut adalah
solusinya
 Kompleksitas waktu algoritmanya O(2 n)

Strategi Greedy :

22
  Urutkan semua aktivitas berdasarkan waktu selesai dari kecil
ke besar.
 Pada setiap step, pilih aktivitas yang waktu mulainya lebih
besar atau sama dengan waktu selesai aktivitas yang dipilih
sebelumnya.

aktivitas yang dipilih adalah 1, 3, 6, 7, dan 11

Function Greedy ActivitySelector (s, f)

{Asumsi: aktivitas sudah diurut terlebih dahulu. Berdasarkan waktu
selesai: f1 ≤ f2 ≤ … ≤ fn }
Algoritma
n ← length(s)
A ← {1}
j←1
for i ← 2 to n do
if si>= fj then
A ← A Ụ {i]
j←i
endif
endfor
Kompleksitas algoritma: O(n). Usulan strategi Greedy yang lain adalah
pilih aktivitas yang durasinya paling kecil lebih dahulu dan waktu mulainya
tidak lebih besar dari waktu selesai aktivitas lain yang telah terpilih

2.3.4 Integer Knapsack

n n
Maksimasi F = ∑ pi x i dengan kendala ∑ wi xi < K yang dalam hal ini,
i=1 i=1

xi = 0 atau 1, dan i = 1,2,3,…,n.

23
 Kompleksitas algoritma exhaustive search untuk persoalan ini =
O(n.2n).

Penyelesaian dengan algoritma greedy

 Masukkan objek satu per satu ke dalam knapsack. Sekali objek

dimasukkan ke dalam knapsack, objek tersebut tidak bisa
dikeluarkan lagi.
 Terdapat beberapa strategi greedy yang heuristik yang dapat
digunakan untuk memilih objek yang akan dimasukkan ke dalam
knapsack:
1) Greedy by profit. - Pada setiap langkah, pilih objek yang
mempunyai keuntungan terbesar. - Mencoba
memaksimumkan keuntungan dengan memilih objek yang
paling menguntungkan terlebih dahulu.
2) Greedy by weight. - Pada setiap langkah, pilih objek yang
mempunyai berat teringan. - Mencoba memaksimumkan
keuntungan dengan dengan memasukkan sebanyak
mungkin objek ke dalam knapsack. 40
3) Greedy by density. - Pada setiap langkah, knapsack diisi
dengan objek yang mempunyai pi /wi terbesar. - Mencoba
memaksimumkan keuntungan dengan memilih objek yang
mempunyai keuntungan per unit berat terbesar.

Pemilihan objek berdasarkan salah satu dari ketiga strategi di atas tidak
menjamin akan memberikan solusi optimal.

Kesimpulan: Algoritma greedy tidak selalu berhasil menemukan solusi

optimal untuk masalah 0/1 Knapsack.

2.3.5 Fractional Knapsack

n n
Maksimasi F = ∑ pixi dengan kendala ∑ wixi< K yang dalam hal ini,
i=1 i=1

xi = 0 atau 1, dan i = 1,2,3,…,n.

Penyelesaian dengan exhaustive search

24
  Oleh karena 0  xi  1, maka terdapat tidak berhinga nilai-nilai xi .
 Persoalan Fractional Knapsack menjadi malar (continuous)
sehingga tidak mungkin dipecahkan dengan algoritma exhaustive
search.

Penyelesaian dengan algoritma greedy

 Ketiga strategi greedy yang telah disebutkan di atas dapat

digunakan untuk memilih objek yang akan dimasukkan ke dalam
knapsack.
 Strategi pemilihan objek ke dalam knapsack berdasarkan
densitas pi /wi terbesar pasti memberikan solusi optimal.
 Agar proses pemilihan objek berikutnya optimal, maka kita
urutkan objek berdasarkan pi /wi yang menurun, sehingga
objek berikutnya yang dipilih adalah objek sesuai dalam urutan
itu.
 Jika p1/w1 >= p2/w2 >= ... >= pn/wn maka algoritma Greedy
dengan strategi pemilihan objek berdasarkan pi /wi terbesar
menghasilkan solusi yang optimum.

function FractionalKnapsack (input C : himpunan_objek, K : real ) →

himpunan_solusi
{Menghasilkan solusi persoalan fractional knapsack dengan
algoritma Greedy yang menggunakan strategi pemilihan objek
berdasarkan density (pi/wi). Solusi dinyatakansebagai vektor X =
x[1], x[2], …, x[n].
Asumsi: Seluruh objek sudah terurut berdasarkan nilai pi/wi yang
menurun
}
Deklarasi
i, TotalBobot : integer
MasihMuatUtuh : boolean
x : himpunan_solusi
Algoritma:
for i ← 1 to n do

25
 x[i] ← 0 { inisialisasi setiap fraksi objek i dengan 0 }
endfor
i←0
TotalBobot ← 0
MasihMuatUtuh ← true
while (i <= n) and (MasihMuatUtuh) do
{ tinjau objek ke-i }
i←i+1
if TotalBobot + C.w[i] <= K then
{ masukkan objek i ke dalam knapsack }
x[i] ← 1
TotalBobot ← TotalBobot + C.w[i]
else
MasihMuatUtuh  false
x[i] ← (K – TotalBobot)/C.w[i]
endif
endwhile
{ i > n or not MasihMuatUtuh }
return x
Kompleksitas waktu algoritma = O(n).

2.3.6 Penjadwalan Job dengan Tenggat Waktu (Job

Schedulling with Deadlines)
Persoalan:

 Ada n buah job yang akan dikerjakan oleh sebuah mesin;

 tiap job diproses oleh mesin selama 1 satuan waktu dan tenggat
waktu (deadline) setiap job i adalah di  0;
 job i akan memberikan keuntungan sebesar p i jika dan hanya jika
job tersebut diselesaikan tidak melebihi tenggat waktunya;

Bagaimana memilih job-job yang akan dikerjakan oleh mesin sehingga

keuntungan yang diperoleh dari pengerjaan itu maksimum?

Fungsi obyektif persoalan ini:

26
 MaksimasiF = ∑ pi
i∊J

Solusi layak: himpunan J yang berisi urutan job yang sedemikian

sehingga setiap job di dalam J selesai dikerjakan sebelum tenggat
waktunya.

Solusi optimum ialah solusi layak yang memaksimumkan F.

Pemecahan Masalah dengan Exhaustive Search

Cari himpunan bagian (subset) job yang layak dan memberikan total
keuntungan terbesar.

Pemecahan Masalah dengan Algoritma Greedy

Strategi greedy untuk memilih job: Pada setiap langkah, pilih job i
dengan pi yang terbesar untuk menaikkan nilai fungsi obyektif F.

function JobSchedulling1 (input C : himpunan_job) →

himpunan_job
{ Menghasilkan barisan job yang akan diproses oleh mesin }
Deklarasi
i : integer
J : himpunan_job { solusi }
Algoritma
J ← {}
while C  {} do
i ← job yang mempunyai p[i] terbesar
C ← C – {i}
if (semua job di dalam J  {i} layak) then
J ← J U {i}
endif
endwhile
{ C = {} }
return J
Kompleksitas algoritma greedy : O(n 2 ).

27
 2.3.7 Pohon Merentang Minimum
A. Algoritma Prim

Strategi greedy yang digunakan:

Pada setiap langkah, pilih sisi e dari graf G(V, E) yang mempunyai bobot
terkecil dan bersisian dengan simpul simpul di T tetapi e tidak membentuk
sirkuit di T.

Algoritma Prim

Langkah 1: ambil sisi dari graf G yang berbobot minimum, masukkan ke

dalam T.

Langkah 2: pilih sisi (u, v) yang mempunyai bobot minimum dan bersisian
dengan simpul di T, tetapi (u, v) tidak membentuk sirkuit di T. Masukkan
(u, v) ke dalam T.

Langkah 3: ulangi langkah 2 sebanyak n – 2 kali.

procedure Prim(input G : graf, output T : pohon)

{Membentuk pohon merentang minimum T dari graf terhubun
gberbobot G.
Masukan: graf-berbobot terhubung G = (V, E), dengan |V|=n
Keluaran: pohon rentang minimum T = (V, E’)
}
Deklarasi
i, p, q, u, v : integer
Algoritma
Cari sisi (p,q) dari E yang berbobot terkecil
T  {(p,q)}
for i1 to n-2 do
Pilih sisi (u,v) dari E yang bobotnya terkecil namun
bersisian dengan simpul di T
T  T U {(u,v)}
endfor
Komplesitas algoritma: O(n2)

B. Algoritma Kruskal

28
 Strategi greedy yang digunakan:
Pada setiap langkah, pilih sisi e dari graf G yang mempunyai bobot minimum
tetapi e tidak membentuk sirkuit di T.
Algoritma Kruskal
Langkah 0: sisi-sisi dari graf sudah diurut menaik berdasarkan bobotnya – dari
bobot kecil ke bobot besar
Langkah 1: T masih kosong
Langkah 2: pilih sisi (u, v) dengan bobot minimum yang tidak membentuk
sirkuit di T. Tambahkan (u, v) ke dalam T.
Langkah 3: ulangi langkah 2 sebanyak n – 1 kali.

procedure Kruskal(input G : graf, output T : pohon)

{ Membentuk pohon merentang minimum T dari graf terhubung –
berbobot G.
Masukan: graf-berbobot terhubung G = (V, E), dengan |V|= n
Keluaran: pohon rentang minimum T = (V, E’)
}
Deklarasi
i, p, q, u, v : integer
Algoritma
(Asumsi: sisi-sisi dari graf sudah diurut menaik berdasarkan bobotnya –
dari bobot kecil ke bobot besar)
T  {}
while jumlah sisi T < n-1 do
Pilih sisi (u,v) dari E yang bobotnya terkecil
if (u,v) tidak membentuk siklus di T then
T  T U {(u,v)}
endif
endfor
Kompleksitas algoritma: O(|E| log |E|)

2.3.8 Lintasan Terpendek (Shortest Path)

Beberapa macam persoalan lintasan terpendek:

a. Lintasan terpendek antara dua buah simpul tertentu (a pair shortest

path).

29
b. Lintasan terpendek antara semua pasangan simpul (all pairs shortest
path).
c. Lintasan terpendek dari simpul tertentu ke semua simpul yang lain
(single-source shortest path).
d. Lintasan terpendek antara dua buah simpul yang melalui beberapa
simpul tertentu (intermediate shortest path).

Persoalan: Diberikan graf berbobot G = (V, E). Tentukan lintasan

terpendek dari sebuah simpul asal a ke setiap simpul lainnya di G. Asumsi
yang kita buat adalah bahwa semua sisi berbobot positif

Penyelesaian dengan Algoritma Brute Force

Misalkan ingin menentukan jarak terpendek dari a ke b, Enumerasi semua

lintasan yang mungkin dibentuk dari a ke b, hitung panjangnya. Lintasan
yang memiliki panjang terkecil adalah lintasan terpendek dari a ke b.
Ulangi cara yang sama untuk jarak terpendek dari a ke c, dari a ke d, dan
seterusnya.

Algoritma Dijkstra Strategi greedy:

Pada setiap langkah, ambil sisi yang berbobot minimum yang

menghubungkan sebuah simpul yang sudah terpilih dengan sebuah simpul
lain yang belum terpilih. Lintasan dari simpul asal ke simpul yang baru
haruslah merupakan lintasan yang terpendek diantara semua lintasannya ke
simpul-simpul yang belum terpilih.

30
procedure Dijkstra (input G: weighted_graph, input a: intial_vertex)
Deklarasi:
S : himpunan simpul solusi
L : array[1..n] of real { L(z) berisi panjang lintasan terpendek dari a
ke z}
Algoritma
for i←1 to n
L(vi) ← infinite
endfor
L(a) ← 0
S←{}
while z !E S do
u ← simpul yang bukan di dalam S dan memiliki L(u)
minimum
S ← S U {u}
for semua simpul v yang tidak terdapat di dalam S
if L(u) + G(u,v) < L(v) then L(v) ← L(u) + G(u,v)
endfor
endwhile

31
2.3.9 Pemampatan Data dengan Algoritma Huffman
Prinsip kode Huffman:

 karakter yang paling sering muncul di dalam data dengan kode

yang lebih pendek;
 sedangkan karakter yang relatif jarang muncul dikodekan dengan
kode yang lebih panjang.

Algoritma Greedy untuk Membentuk Kode Huffman:

1. Baca semua karakter di dalam data untuk menghitung frekuensi

kemunculan setiap karakter. Setiap karakter penyusun data
dinyatakan sebagai pohon bersimpul tunggal. Setiap simpul di-
assign dengan frekuensi kemunculan karakter tersebut.
2. Terapkan strategi greedy sebagai berikut: pada setiap langkah
gabungkan dua buah pohon yang mempunyai frekuensi terkecil
pada sebuah akar. Akar mempunyai frekuensi yang merupakan
jumlah dari frekuensi dua buah pohon penyusunnya.
3. Ulangi langkah 2 sampai hanya tersisa satu buah pohon Huffman.
Kompleksitas algoritma Huffman: O(n log n)

32
2.4 Kelebihan dan Kekurangan

2.4.1. Kelebihan
 Mudah diimplementasikan, algoritma Greedy sangat mudah untuk
diimplementasikan pada persoalan-persoalan yang ada.
 Efisien, algoritma Greedy merupakan algoritma yang sangat efisien
karena algoritma ini selalu berusaha memilih hasil optimal.

2.4.2. Kekurangan
 Tidak adanya penanganan kasus jika titik tujuan tidak ditemukan.
 Tidak dapat melakukan pemantauan parameter yang melibatkan lebih
dari satu perangkat

33
 BAB III
IMPLEMENTASI
3.1 Bubble Sort
a. Source Code
import java.util.Scanner;
class BubbleSort
{
private static Scanner sc;
void bubbleSort(int arr[])
{
int n = arr.length;
for (int i = 0; i < n-1; i++)
for (int j = 0; j < n-i-1; j++)
if (arr[j] > arr[j+1])
{
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
void printArray(int arr[])
{
int n = arr.length;
for (int i=0; i<n; ++i)
System.out.print(arr[i] + " ");
System.out.println();
}
public static void main(String args[])
{
BubbleSort ob = new BubbleSort();
sc = new Scanner (System.in);
System.out.print("Masukan Jumlah Angka =");
int angka = sc.nextInt();
int arr[] = new int[angka];
for (int i=0;i<angka;i++) {
arr[i] = sc.nextInt();
}
ob.bubbleSort(arr);
System.out.println("Hasil Pengurutan
Angka :");
ob.printArray(arr);
}
}
b. Hasil Program

34
3.2 Bilangan Prima
a. Source Code
import java.util.*;
public class Prima {
private static Scanner s;
static boolean Cek(int n)
{
if (n <= 1)
return false;
for (int i = 2; i < n; i++)
if (n % i == 0)
return false;

return true;
}
public static void main(String[] args)
{
s = new Scanner (System.in);
System.out.print("Masukan Angka yang ingin
diperiksa :");
int nilai = s.nextInt();
if(Cek(nilai))
System.out.println(nilai+" adalah Bilangan
Prima") ;

else
System.out.println(nilai+" Bukan Bilangan
Prima");
}
}
b. Hasil Program

3.3 Bilangan Polinom

a. Source Code
import java.util.Scanner;
public class Polinom {
private static Scanner sc;
static void printPoly(int poly[], int n)

35
 {
for (int i = 0; i < n; i++)
{
System.out.print(poly[i]);
if (i != 0)
{
System.out.print("x^" + i);
}
if (i != n - 1)
{
System.out.print(" + ");
}
}
}
public static void main(String[] args)
{
sc = new Scanner (System.in);
System.out.println("Masukan banyak pangkat
untuk membuat Polinom");
int pangkat = sc.nextInt();
System.out.println("Masukan angka Polinom :
");
int A[] = new int [pangkat];
for (int i=0;i<pangkat;i++) {
A[i] = sc.nextInt();
}

System.out.println("Polinom adalah ");

printPoly(A, pangkat);
}

}
b. Hasil Program

3.4 Perbandingan String

a. Source Code
import java.io.*;
import java.util.Scanner;
public class Bruteforce {
public static int bruteforce(String text,String
tobematched){
int length = text.length();
int plength = tobematched.length();
for(int i=0;i<length-plength;i++){
int j=0;

36
 while((j < plength) && (text.charAt(i+j)
== tobematched.charAt(j))){
j++;
}
if(j == plength){
return i;
}
}
return -1;
}

public static void main(String[] args){

Bruteforce obj = new Bruteforce();
Scanner sc = new Scanner(System.in);
System.out.println("Masukan Kalimat Sumber :
");
String text = sc.nextLine();
System.out.println("Masukan Kalimat yang
dicari : ");
String tobematched = sc.nextLine();
int position =
obj.bruteforce(text,tobematched);
int endindex = position+1;
if(position == -1){
System.out.println("Pattern is not
matched in the text");
}else{
System.out.println("Karakter dimulai
pada urutan :" + (position+1));
System.out.println("Karakter berakhir
pada urutan :" + (endindex + tobematched.length()));
}
}

}
b. Hasil Program

3.5 Jarak Antar Titik

a. Source Code
import java.util.Scanner;
public class Titik {
private double x;
private double y;
public Titik() {

37
 }
public Titik(double x, double y) {
this.x = x;
this.y = y;
}
public double getX() {
return x;
}
public void setX(double x) {
this.x = x;
}
public double getY() {
return y;
}
public void setY(double y) {
this.y = y;
}
public String getKoordinat() {
return "("+x+","+y+")";
}
public static double hitJarak(Titik t1, Titik t2) {
double dx = t1.x - t2.x;
double dy = t1.y - t2.y;
return Math.sqrt(dx * dx + dy * dy);
}

public static void main(String[] args) {

// TODO code application logic here
Scanner sc = new Scanner (System.in);
System.out.println("Masukan Nilai Titik Pertama
(X,Y) : ");
int a = sc.nextInt();
int b = sc.nextInt();
System.out.println("Masukan Nilai Titik Kedua
(X,Y) : ");
int i = sc.nextInt();
int j = sc.nextInt();
Titik t1 = new Titik();
t1.setX(a);
t1.setY(b);
System.out.println("Koordinat Titik Pertama :");
System.out.println(t1.getKoordinat());
Titik t2 = new Titik(i, j);
System.out.println("Koordinat Titik Kedua :");
System.out.println(t2.getKoordinat());
System.out.println("Jarak Pertama dan Kedua: " +
Titik.hitJarak(t1, t2));
}

}
b. Hasil Program

38
3.6 Travelling Salesman Problem
a. Source Code
import java.util.Scanner;
public class TSP {
static int tsp(int[][] graph, boolean[] v,
int currPos, int n,
int count, int cost, int ans)
{
if (count == n && graph[currPos][0] > 0)
{
ans = Math.min(ans, cost + graph[currPos][0]);
return ans;
}
for (int i = 0; i < n; i++)
{
if (v[i] == false && graph[currPos][i] > 0)
{
v[i] = true;
ans = tsp(graph, v, i, n, count + 1,
cost + graph[currPos][i],
ans);
v[i] = false;
}
}
return ans;
}
public static void main(String[] args)
{
Scanner sc = new Scanner (System.in);
System.out.println("Masukan Jumlah Node : ");
int sim = sc.nextInt();
//int arr[] = new int[angka];
int graph[][] = new int[sim][sim];
for(int i=0;i<sim;i++) {
System.out.println("Titik "+(i+1));
for(int j=0;j<sim;j++) {
System.out.println("Masukan jarak dari
titik "+(i+1)+" ke titik "+(j+1));
graph[i][j]= sc.nextInt();
}
}

39
 boolean[] v = new boolean[sim];
v[0] = true;
int ans = Integer.MAX_VALUE;
ans = tsp(graph, v, 0, sim, 1, 0, ans);
System.out.println("Jarak Terdekat adalah "+ans);
}
}

b. Hasil Program

3.7 Knapsack Problem

a. Source Code
import java.util.Scanner;
public class Knapsack {
static int max(int a, int b) { return (a > b) ? a :
b; }
static int knapSack(int W, int wt[], int val[], int
n)
{
if (n == 0 || W == 0)
return 0;
if (wt[n - 1] > W)
return knapSack(W, wt, val, n - 1);
else
return max(val[n - 1] + knapSack(W -
wt[n - 1], wt, val, n - 1),
knapSack(W, wt, val, n -
1));

40
 }
public static void main(String args[])
{
Scanner sc = new Scanner (System.in);
System.out.print("Masukan Jumlah Barang : ");
int n = sc.nextInt();
System.out.print("Masukan Jumlah Maksimal
Berat Barang : ");
int W = sc.nextInt();
int val[] = new int[n];
int wt[] = new int[n] ;

for (int i=0;i<n;i++) {

System.out.println("Barang ke - "+
(i+1));
System.out.print("Masukan Profit barang
ke - "+(i+1)+" : ");
val[i] = sc.nextInt();
System.out.print("Masukan Weight barang
ke - "+(i+1)+" : ");
wt[i] = sc.nextInt();
}
System.out.println(knapSack(W, wt, val, n));
}

}
b. Hasil Program

3.8 Coin Exchange

a. Source Code
import java.io.*;
import java.util.Scanner;

public class Coin {

static int count( int S[], int m, int n )
{
if (n == 0)

41
 return 1;
if (n < 0)
return 0;
if (m <=0 && n >= 1)
return 0;
return count( S, m - 1, n ) +
count( S, m, n-S[m-1] );
}
public static void main(String[] args)
{
Scanner sc = new Scanner (System.in);
System.out.print("Masukan Nilai Uang yang
ingin ditukar : ");
int uang = sc.nextInt();
System.out.print("Masukan Jumlah Uang
Pecahan : ");
int jum = sc.nextInt();
int arr[] = new int [jum];
for (int i=0;i<jum;i++){
System.out.print("Uang Pecahan ke - "+
(i+1)+" : ");
arr[i] = sc.nextInt();
}
System.out.println("Jumlah Penyelesaian adalah
"+count (arr, jum, uang));
}
}

b. Hasil Program

3.9 Penjadwalan Pelanggan

a. Source Code
import java.util.*;
import java.lang.*;
import java.io.*;

public class Penjadwalan {

public static void printMaxActivities(int s[], int
f[], int n)
{
int i, j;
System.out.print("Pekerjaan yang dipilih adalah ");
i = 0;
System.out.print(i+" ");

42
 for (j = 1; j < n; j++)
{
if (s[j] >= f[i])
{
System.out.print(j+" ");
i = j;
}
}
}
public static void main(String[] args)
{
Scanner sc = new Scanner (System.in);
System.out.print("Masukan Jumlah Pekerjaan :
");
int n = sc.nextInt();
int s[] = new int [n];
int f[] = new int[n];
for(int i=0;i<n;i++) {
System.out.println("Pekerjaan ke - "+
(i));
System.out.print("Masukan Waktu Awal:
");
s[i]= sc.nextInt();
System.out.print("Masukan Waktu Akhir :
");
f[i]= sc.nextInt();
System.out.println();
}
printMaxActivities(s, f, n);
System.out.println();
}
}
b. Hasil Program

3.10 Fractional Knapsack

a. Source Code
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;

public class Fractional {

public static void main(String[] args)

43
 {
Scanner sc = new Scanner (System.in);
System.out.print("Masukan Jumlah Barang : ");
int n = sc.nextInt();
System.out.print("Masukan Jumlah Maksimal
Berat Barang : ");
int capacity = sc.nextInt();
int val[] = new int[n];
int wt[] = new int[n] ;

for (int i=0;i<n;i++) {

System.out.println("Barang ke - "+
(i+1));
System.out.print("Masukan Profit barang
ke - "+(i+1)+" : ");
val[i] = sc.nextInt();
System.out.print("Masukan Weight barang
ke - "+(i+1)+" : ");
wt[i] = sc.nextInt();
}
double maxValue = getMaxValue(wt, val,
capacity);
System.out.println("Maksimun Profit yang
didapat adalah " +
maxValue);
}
private static double getMaxValue(int[] wt,
int[] val, int
capacity)
{
ItemValue[] iVal = new ItemValue[wt.length];

for(int i = 0; i < wt.length; i++)

{
iVal[i] = new ItemValue(wt[i], val[i],
i);
}
Arrays.sort(iVal, new Comparator<ItemValue>()
{
public int compare(ItemValue o1,
ItemValue o2)
{
return
o2.cost.compareTo(o1.cost) ;
}
});
double totalValue = 0d;

for(ItemValue i: iVal)
{
int curWt = (int) i.wt;
int curVal = (int) i.val;

if (capacity - curWt >= 0)

{
capacity = capacity-curWt;

44
 totalValue += curVal;
}
else
{
double fraction =
((double)capacity/(double)curWt);
totalValue += (curVal*fraction);
capacity = (int)(capacity -
(curWt*fraction));
break;
}
}
return totalValue;
}
static class ItemValue
{
Double cost;
double wt, val, ind;
public ItemValue(int wt, int val, int ind)
{
this.wt = wt;
this.val = val;
this.ind = ind;
cost = new Double(val/wt );
}
}
}
b. Hasil Program

3.11 Job Schedulling 1

a. Source Code
import java.io.*;
import java.util.*;

public class Jobs {

public static class Job {

45
 char id;
int deadline;
int profit;
Job(char id, int deadline, int profit)
{
this.id = id;
this.deadline = deadline;
this.profit = profit;
}
}
public static class Sorted implements Comparator {
public int compare(Object o1, Object o2)
{
Job j1 = (Job)o1;
Job j2 = (Job)o2;

if (j1.profit != j2.profit)
return j2.profit - j1.profit;
else
return j2.deadline - j1.deadline;
}
}
public static void printJobScheduling(Job jobs[],
int n)
{
Sorted sorter = new Sorted();
Arrays.sort(jobs, sorter);
TreeSet<Integer> ts = new TreeSet<>();
for (int i = 0; i < n; i++)
ts.add(i);
for (int i = 0; i < n; i++) {
Integer x = ts.floor(jobs[i].deadline -
1);
if (x != null) {
System.out.print(jobs[i].id + "
");
ts.remove(x);
}
}
}
public static void main(String[] args)
{
Scanner sc = new Scanner (System.in);
System.out.print("Masukan Jumlah Pekerjaan :
");
int n = sc.nextInt();
Job[] jobs = new Job[n];

for (int i=0;i<n;i++) {

System.out.print("Nama Pekerjaan ke - "+
(i+1)+" : ");
char nama = sc.next().charAt(0);
System.out.print("Masukan Waktu
Pekerjaan ke - "+(i+1)+" : ");
int waktu = sc.nextInt();
System.out.print("Masukan Profit

46
 Pekerjaan ke - "+(i+1)+" : ");
int prof = sc.nextInt();
jobs[i] = new Job(nama,waktu,prof);
System.out.println();
}
System.out.print("Urutan Pekerjaan yang
Dikerjakan adalah ");
printJobScheduling(jobs, n);
System.out.println();
}
}

b. Hasil Program

3.12 Algoritma Prim

a. Source Code
import java.util.*;
import java.lang.*;
import java.io.*;

public class Prim {

private static final int V = 5;
int minKey(int key[], Boolean mstSet[])
{
int min = Integer.MAX_VALUE, min_index = -1;
for (int v = 0; v < V; v++)
if (mstSet[v] == false && key[v] < min)
{
min = key[v];
min_index = v;
}
return min_index;
}
void printMST(int parent[], int graph[][])
{
System.out.println("Langkah \tJarak");
for (int i = 1; i < V; i++)

47
 System.out.println(parent[i] + " - " + i
+ "\t" + graph[i][parent[i]]);
}
void primMST(int graph[][])
{
int parent[] = new int[V];
int key[] = new int[V];
Boolean mstSet[] = new Boolean[V];
for (int i = 0; i < V; i++) {
key[i] = Integer.MAX_VALUE;
mstSet[i] = false;
}
key[0] = 0;
parent[0] = -1;
for (int count = 0; count < V - 1; count++) {
int u = minKey(key, mstSet);
mstSet[u] = true;
for (int v = 0; v < V; v++)
if (graph[u][v] != 0 && mstSet[v]
== false && graph[u][v] < key[v]) {
parent[v] = u;
key[v] = graph[u][v];
}
}
printMST(parent, graph);
}

public static void main(String[] args)

{
/* Let us create the following graph
2 3
(0)--(1)--(2)
| / \ |
6| 8/ \5 |7
| / \ |
(3)-------(4)
9 */
Prim t = new Prim();

Scanner sc = new Scanner (System.in);

System.out.print("Masukan Jumlah Node : ");
int sim = sc.nextInt();

int graph[][] = new int[sim][sim];

for(int i=0;i<sim;i++) {
System.out.println("Titik "+(i+1));
for(int j=0;j<sim;j++) {
System.out.print("Masukan jarak
dari titik "+(i+1)+" ke titik "+(j+1)+" : ");
graph[i][j]= sc.nextInt();
}
}
System.out.println("Jarak Terdekat adalah ");
t.primMST(graph);

48
 }
b. Hasil Program

3.13 Algoritma Kruskal

a. Source Code
import java.util.*;
import java.lang.*;
import java.io.*;

public class Kruskal {

class Edge implements Comparable<Edge>
{
int src, dest, weight;
public int compareTo(Edge compareEdge)

49
 {
return this.weight-compareEdge.weight;
}
};
class subset
{
int parent, rank;
};

int V, E;
Edge edge[];
Kruskal(int v, int e)
{
V = v;
E = e;
edge = new Edge[E];
for (int i=0; i<e; ++i)
edge[i] = new Edge();
}
int find(subset subsets[], int i)
{
if (subsets[i].parent != i)
subsets[i].parent = find(subsets,
subsets[i].parent);

return subsets[i].parent;
}
void Union(subset subsets[], int x, int y)
{
int xroot = find(subsets, x);
int yroot = find(subsets, y);
if (subsets[xroot].rank < subsets[yroot].rank)
subsets[xroot].parent = yroot;
else if (subsets[xroot].rank >
subsets[yroot].rank)
subsets[yroot].parent = xroot;
else
{
subsets[yroot].parent = xroot;
subsets[xroot].rank++;
}
}
void KruskalMST()
{
Edge result[] = new Edge[V];
int e = 0;
int i = 0;
for (i=0; i<V; ++i)
result[i] = new Edge();
Arrays.sort(edge);
subset subsets[] = new subset[V];
for(i=0; i<V; ++i)
subsets[i]=new subset();
for (int v = 0; v < V; ++v)
{
subsets[v].parent = v;

50
 subsets[v].rank = 0;
}
i = 0;
while (e < V - 1)
{
Edge next_edge = new Edge();
next_edge = 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);
}
}
System.out.println("Hasil Langkah Tercepat
adalah");
for (i = 0; i < e; ++i)
System.out.println(result[i].src+" -- "
+
result[i].dest+" == " +
result[i].weight);
}
public static void main (String[] args)
{

/* Let us create following weighted graph

10
0--------1
| \ |
6| 5\ |15
| \ |
2--------3
4 */

Scanner sc = new Scanner (System.in);

System.out.print("Masukan Jumlah Simpul : ");
int V = sc.nextInt();
System.out.print("Masukan Jumlah Sisi : ");
int E = sc.nextInt();
Kruskal graph = new Kruskal(V, E);

for(int i=0;i<E;i++) {
System.out.print("Masukan Titik
Awal: ");
graph.edge[i].src= sc.nextInt();
System.out.print("Masukan Titik
Tujuan : ");
graph.edge[i].dest= sc.nextInt();
System.out.print("Masukan Jaraknya
: ");
graph.edge[i].weight=
sc.nextInt();
System.out.println();
}

51
 graph.KruskalMST();
}

}
b. Hasil Program

3.14 Algoritma Dijkstra

a. Source Code
import java.util.*;
import java.lang.*;
import java.io.*;

public class Dijkstra {

static final int V = 3;
int minDistance(int dist[], Boolean sptSet[])
{
int min = Integer.MAX_VALUE, min_index = -1;

for (int v = 0; v < V; v++)

if (sptSet[v] == false && dist[v] <=
min) {
min = dist[v];
min_index = v;
}

return min_index;
}
void printSolution(int dist[], int n)
{
System.out.println("Jarak dari Titik Awal");
for (int i = 0; i < V; i++)
System.out.println(i + " tt " +

52
 dist[i]);
}
void dijkstra(int graph[][], int src)
{
int dist[] = new int[V];
Boolean sptSet[] = new Boolean[V];
for (int i = 0; i < V; i++) {
dist[i] = Integer.MAX_VALUE;
sptSet[i] = false;
}
dist[src] = 0;
for (int count = 0; count < V - 1; count++) {
int u = minDistance(dist, sptSet);
sptSet[u] = true;
for (int v = 0; v < V; v++)
if (!sptSet[v] && graph[u][v] != 0
&&
dist[u] != Integer.MAX_VALUE &&
dist[u] + graph[u][v] < dist[v])
dist[v] = dist[u] + graph[u]
[v];
}
printSolution(dist, V);
}
public static void main(String[] args)
{
Scanner sc = new Scanner (System.in);
System.out.println("Masukan Jumlah Node : ");
int sim = sc.nextInt();

int graph[][] = new int[sim][sim];

for(int i=0;i<sim;i++) {
System.out.println("Titik "+(i+1));
for(int j=0;j<sim;j++) {
System.out.print("Masukan jarak
dari titik "+(i+1)+" ke titik "+(j+1)+" : ");
graph[i][j]= sc.nextInt();
}
}
Dijkstra t = new Dijkstra();
t.dijkstra(graph, 0);
}

}
b. Hasil Program

53
3.15 Kode Kompresi Huffman
a. Source Code
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Comparator;
class HuffmanNode {

int data;
char c;

HuffmanNode left;
HuffmanNode right;
}
class MyComparator implements Comparator<HuffmanNode> {
public int compare(HuffmanNode x, HuffmanNode y)
{

return x.data - y.data;

}
}

public class Huffman {

public static void printCode(HuffmanNode root,
String s)
{
if (root.left
== null
&& root.right
== null
&& Character.isLetter(root.c)) {
System.out.println(root.c + ":" + s);
return;
}
printCode(root.left, s + "0");

54
 printCode(root.right, s + "1");
}
public static void main(String[] args)
{

Scanner s = new Scanner(System.in);

System.out.print("Masukan Jumlah Karakter :
");
int jum = s.nextInt();

char[] charArray = new char[jum];

int[] charfreq = new int [jum];
for(int i=0;i<jum;i++) {
System.out.print("Masukan Karakter ke -
"+(i+1)+" : ");
charArray[i]= s.next().charAt(0);
System.out.print("Masukan Frequensi
Karakter: ");
charfreq[i]= s.next().charAt(0);
System.out.println();
}
PriorityQueue<HuffmanNode> q
= new PriorityQueue<HuffmanNode>(jum,
new MyComparator());

for (int i = 0; i < jum; i++) {

// and add it to the priority queue.
HuffmanNode hn = new HuffmanNode();
hn.c = charArray[i];
hn.data = charfreq[i];
hn.left = null;
hn.right = null;
q.add(hn);
}
HuffmanNode root = null;
while (q.size() > 1) {
HuffmanNode x = q.peek();
q.poll();
HuffmanNode y = q.peek();
q.poll();
HuffmanNode f = new HuffmanNode();
f.data = x.data + y.data;
f.c = '-';
f.left = x;
f.right = y;
root = f;
q.add(f);
}
System.out.println("Hasilnya adalah");
printCode(root, "");
}
}

b. Hasil Program

55
56