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......................................................1
1.3.1 Mencari Elemen Terbesar...........................................................................1
1.3.2 Pencarian Beruntun (Sequential Search)....................................................2
1.3.3 Menghitung an (a > 0, n adalah bilangan bulat tak-negatif)........................2
1.3.4 Menghitung n! (n bilangan bulat tak-negatif).............................................2
1.3.5 Mengalikan dua buah matriks, A dan B......................................................2
1.3.6 Tes Bilangan Prima.....................................................................................2
1.3.7 Selection Sort.............................................................................................2
1.3.8 Bubble Sort.................................................................................................2
1.3.9 Mengevaluasi Polinom...............................................................................2
1.3.10 Pencocokan String (String Matching)..........................................................2
1.3.11 Mencari Pasangan Titik yang Jaraknya Terdekat (Closest Pairs).................2
1.4 Kelebihan dan Kekurangan.................................................................................2
1.4.1 Kelebihan....................................................................................................2
1.4.2 Kekurangan.................................................................................................2
BAB II ALGORITMA GREEDY......................................................................................3
2.1 Pengertian..........................................................................................................3
2.2 Tahapan Algoritma Umum.................................................................................3
2.3 Contoh Masalah.................................................................................................3
2.4 Penjelasan Penyelesaian....................................................................................3
2.5 Kelebihan dan Kekurangan.................................................................................3
BAB III IMPLEMENTASI................................................................................................4
3.1 Bubble Sort.........................................................................................................4

i
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

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

1.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. Prinsip Algoritma Greedy adalah take
what you can get now! . Hanya terdapat dua macam persoalan optimasi:[2]

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

Elemen-elemen Algoritma Greedy :

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

Algoritma Greedy melibatkan pencarian sebuah himpunan bagian, S, dari

himpunan kandidat, C; yang dalam hal ini, S harus memenuhi beberapakriteria yang
ditentukan, yaitu menyatakan suatu solusidan 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

17
 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

2.3 Contoh Masalah

2.4 Penjelasan Penyelesaian

2.5 Kelebihan dan Kekurangan

18
 BAB III
IMPLEMENTASI
3.1 Bubble Sort

* Bilangan Prima (Hal 16)

* Bilangan Polinom (Hal 18)

M08Algoritma Brute Force (lanjutan).pdf

* Perbandingan String (Hal 6)

* Jarak Antar Titik (Hal 9)

* Travelling Salesperson Problem (Temukan di Internet)

* Knapsack Problems (Temukan di Internet)

M09Algoritma Greedy.pdf

* Koin Exchange (Hal 18)

* Penjadwalan Pelanggan (Hal 23)

* Fractional Knapsack (Hal 40)

M10Algoritma Greedy (lanjutan).pdf

* JobSchedulling1 (Hal 9)

* Algoritma Prim (Temukan di Internet)

19
* Algoritma Kruskal (Temukan di Internet)

* Algoritma Dijkstra (Temukan di Internet)

* Kode Kompresi Huffman (Temukan di Internet)

20