MAKALAH

STRATEGI ALGORITMA DYNAMIC PROGRAMMING

Diajukan untuk memenuhi salah satu tugas mata kuliah
Analisis Algoritma

Disusun Oleh :
NAMA

: Raden Hasbie Finno H (10114558)

: Yogi Sugiarto (10114298)

KELAS

: Analgo-3

Dosen :
Angga Setiyadi, S.Kom.

TEKNIK INFORMATIKA
FAKULTAS TEKNIK DAN ILMU KOMPUTER
UNIVERSITAS KOMPUTER INDONESIA
2016
KATA PENGANTAR

Puji dan syukur kita panjatkan ke hadirat Tuhan Yang Maha Esa, karena
atas berkat dan hidayah-Nya kami bisa menyelesaikan tugas ini dengan baik.
Tugas ini dikerjakan untuk memenuhi salah satu tugas mata kuliah Analisis
Algoritma dengan judul Strategi Algoritma Dynamic Programming.
Didalam tugas ini terdapat banyak kekurangan, untuk itu kami ingin
mengucapkan permohonan maaf yang sebesar-besarnya. Tidak lupa kami
sampaikan terima kasih yang sebesar-besarnya kepada semua pihak yang telah
membantu terselesaikannya tugas ini, mudah-mudahan semua bantuannya di
berikan balasan yang terbaik oleh Tuhan Yang Maha Esa.
Untuk itu, sekali lagi kami ucapkan maaf yang sebesar-besarnya, mudahmudahan tugas ini bermanfaat bagi kita semua. Terima kasih.

Bandung, 20 Januari 2016

Penulis

DAFTAR ISI

Contents
BAB 1

PENDAHULUAN.................................................................................3

1.1.

Latar Belakang..........................................................................................3

1.2.

Maksud dan Tujuan...................................................................................4

1.3.

Batasan Masalah........................................................................................4

BAB 2

DYNAMIC PROGRAMMING.............................................................5

2.1.

Definisi Strategi Dynamic Programming..................................................5

2.2.

Kelebihan dan Kekurangan Strategi Dynamic Programming...................7

2.3.

Multistage Graph Problem (Permasalahan mencari lintasan terpendek)..9

2.4.

Studi Kasus Dynamic Programming.......................................................11

2.4.1

Knapsack Problem...........................................................................11

2.4.2

Coin Change Problem......................................................................15

2.4.3

Traveling Salesman Problem...........................................................16

BAB 3

PROGRAM..........................................................................................18

3.1.

Algoritma & Program Knapsack Problem..............................................18

3.2.

Algoritma & Program Coin Change Problem.........................................23

3.3.

Algoritma & Program Traveling Salesman Problem..............................31

BAB 4
4.1.

PENUTUP...........................................................................................36
Kesimpulan..............................................................................................36

BAB 1
PENDAHULUAN

1.1.

Latar Belakang

Masalah merupakan suatu hal yang sudah tidak asing kita jumpai dalam
kehidupan sehari-hari. Dalam menyelesaikan masalah tersebut terdapat berbagai
macam cara yang dapat kita gunakan, salah satunya adalah dengan menggunakan
algoritma. Algoritma merupakan suatu langkah dalam menyelesaikan suatu
masalah dengan menggunakan teknik tertentu yang tersusun secara logis dan
sistematis (dalam bentuk kalimat dan jumlah kata yang terbatas).
Untuk mendapatkan hasil yang optimal dalam menyelesaikan masalahmasalah tersebut algoritma memiliki beberapa metode yang dapat digunakan,
salah satunya adalah dengan menggunakan Strategi Algoritma Dynamic
Programming. Strategi Algoritma Dynamic Programming merupakan suatu teknik
algoritma untuh menyelesaikan suatu masalah dengan cara menguraikan solusi
menjadi sekumpulan langkah atau tahapan sehingga solusi dari permasalahan
tersebut dapat kita lihat sebagai suatu deret keputusan.
Pada umumnya, Dynamic Programming digunakan untuk masalah
optimisasi dimana suatu permasalahan memiliki banyak solusi. Setiap solusi
memiliki nilai masing-masing dan ingin ditemukan solusi dengan nilai yang
optimum (maksimal atau minimal).
Dalam menyelesaikan permasalahan-permasalahannya, Strategi Algoritma
Dynamic Programming memiliki beberapa metode yang dapat kita gunakan untuk
menyelesaikan masalah tersebut seperti metode Knapsack Problem, Coin Change
Problem, dan Traveling Salesman Problem yang untuk lebih jelasnya akan kita
bahas didalam makalah ini.

1.2.

Maksud dan Tujuan

Maksud dan tujuan yang ingin dicapai dalam penulisan makalah ini adalah
sebagai berikut :

a.

Untuk mengetahui dan memahami mengenai Strategi Algoritma Dynamic

b.

Programming.
Untuk mengetahui kelebihan dan kekurangan dari Strategi Algoritma

Dynamic Programming.
c. Untuk mengetahui dan memahami permasalahan dalam mencari lintasan
terpendek (Multistage Graph Problem).
d. Untuk mengetahui dan memahami penerapan dari Strategi Algoritma
Dynamic Programming.

1.3.

Batasan Masalah

Batasan masalah yang ditentukan dalam penulisan makalah ini adalah sebagai
berikut :
1. Membagi permasalahan awal menjadi beberapa bagian permasalahan
(subproblem) dengan aturan-aturan keputusan pada setiap tahapannya.
2. Memecahkan tahapan terakhir dari permasalahan dengan semua kondisi
dan keadaan yang memungkinkan.
3. Mencari keputusan optimal pada setiap tahapan sampai dengan tahapan
terakhir.
4. Solusi optimal dari permasalahan didapatkan jika semua tahap sudah
terpecahkan.

BAB 2
DYNAMIC PROGRAMMING

2.1.

Definisi Strategi Dynamic Programming

Dynamic Programming dapat didefinisikan sebagai suatu teknik algoritma

yang digunakan untuk menyelesaikan suatu masalah dengan cara menguraikan
solusi dari penyelesaian masalah tersebut menjadi sekumpulan langkah (step)
atau tahapan (stage) hingga sedemikian rupa sehingga solusi dari
permasalahan tersebut dapat dilihat sebagai suatu keputusan yang saling
berkaitan satu sama lain. Istilah Dynamic Programming awalnya digunakan
pada tahun 1940-an oleh Richard Bellman untuk menggambarkan proses
pemecahan suatu masalah dengan tujuan untuk menemukan keputusan terbaik
satu demi satu dari suatu masalah.
Dynamic Programming biasanya digunakan untuk masalah optimisasi,
dimana suatu permasalahan memiliki banyak solusi, dan setiap solusi
memiliki nilai masing-masing dimana ingin ditemukan solusi dengan nilai
yang optimum (maksimal atau minimal).
Prosedur penyelesaian suatu masalah dengan menggunakan algoritma
Dynamic Programming yaitu dengan prosedur rekursif yang berarti bahwa
setiap kali mengambil keputusan harus memperhatikan keadaan yang
dihasilkan oleh keputusan optimal sebelumnya dan merupakan acuan bagi
keputusan optimal berikutnya. Terdapat dua macam prosedur penyelesaian
rekursif yang dapat digunakan dalam algoritma Dynamic Programming, yaitu
sebagai berikut :
a.) Prosedur maju (forward atau up-down).
Dikatakan prosedur maju karena dalam perhitungan dimulai dari
tahap pertama ke tahap akhir. Perhitungan dimulai dengan mencari
nilai keuntungan di tahap ke-1, lalu dilanjutkan mencari nilai
keuntungan di tahap ke-2 sampai ke tahap n. Setelah dilakukan

perhitungannya, diperoleh keputusan optimal. Runtunan tahapannya

adalah x1, x2, . , xn.

b.) Prosedur mundur (backward atau bottom-up).

Dikatakan prosedur mundur karena perhitungannya dimulai pada
tahap terakhir dan berlanjut ke tahap ke-1. Perhitungan dimulai dengan
mencari nilai keuntungan di tahap n, lalu dilanjutkan mencari nilai
keuntungan n-1 sampai tahap ke-1. Setelah dilakukan perhitungan,
diperoleh keputusan optimal. Runtunan tahapannya adalah xn, xn-1, . ,
x1.

Perbedaan pokok dari kedua prosedur diatas adalah terletak pada cara
mendefinisikan tahap yang dipakai, apakah tahap pertama atau tahap
terakhir untuk memulai perhitungan.
Melihat ke dua macam prosedur diatas, berikut adalah beberapa
karakteristik persoalan yang dimiliki oleh algoritma Dynamic Programming,
diantaranya adalah sebagai berikut :
a. Persoalan dapat dibagi menjadi beberapa tahap (stage), yang pada
setiap tahap hanya dapat diambil satu keputusan.
b. Masing-masing tahap terdiri dari sejumlah status (state) yang
berhubungan dengan tahap tersebut.
c. Hasil dari keputusan yang diambil pada setiap tahap ditransformasikan
dari status yang bersangkutan ke status berikutnya pada tahap
berikutnya.
d. Ongkos (cost) pada suatu tahap meningkat secara teratur (steadily)
dengan bertambahnya jumlah tahapan.
e. Ongkos pada suatu tahap bergantung pada ongkos tahap-tahap yang
sudah berjalan dan ongkos pada tahap tersebut.
f. Keputusan terbaik pada suatu tahap bersifat independen terhadap
keputusan yang dilakukan pada tahap sebelumnya.

g. Adanya hubungan rekursif yang mengidentifikasikan keputusan terbaik

untuk setiap status pada tahap k memberikan keputusan terbaik untuk
setiap status pada tahap k + 1.
h. Prinsip optimalitas berlaku pada persoalan tersebut.
Secara umum, terdapat empat langkah yang dapat dilakukan dalam
mengembangkan algoritma Dynamic Programming, yaitu sebagai berikut :
1.
2.
3.
4.

2.2.

Karakterisitikkan struktur solusi optimal.

Definisikan secara rekursif nilai solusi optimal.
Hitung nilai solusi optimal secara maju atau mundur.
Konstruksi solusi optimal.

Kelebihan

dan

Kekurangan

Strategi

Dynamic Programming
a. Kelebihan Dynamic Programming
Terdapat beberapa kelebihan yang dimiliki oleh Strategi Algoritma
Dynamic Programming dalam penggunaanya, diantaranya adalah
sebagai berikut :
Mengoptimalkan penyelesaian suatu masalah tertentu yang
diuraikan menjadi sub-sub masalah yang lebih kecil yang terkait
satu sama lain dengan tetap memperhatikan kondisi dan batasan
permasalahan tersebut.
Proses pemecahan suatu masalah yang kompleks menjadi sub-sub
masalah yang lebih kecil membuat sumber permasalahan dalam
rangkaian proses masalah tersebut menjadi lebih jelas untuk
diketahui.
Pendekatan Dynamic Programming dapat diaplikasikan untuk
berbagai macam masalah pemrograman matematik, karena
Dynamic Programming cenderung lebih fleksibel daripada teknik
optimasi lain.
Prosedur
perhitungan

Dynamic

Programming

juga

memperkenankan bentuk analisis sensitivitasi terdapat pada setiap

variable status (state) maupun pada variable yang ada di masingmasing tahap keputusan (stage).

 Dynamic

Programming

dapat

menyesuaikan

sistematika

perhitungannya menurut ukuran masalah yang tidak selalu tetap

dengan melakukan perhitungan satu per satu secara lengkap dan
menyeluruh.

b. Kekurangan Dynamic Programming

Selain memiliki kelebihan, Dynamic Programming juga memiliki
beberapa kekurangan dalam penggunaannya. Berikut adalah beberapa
kekurangan dari penggunaan Dynamic Programming :
Penggunaan Dynamic Programming jika tidak dilakukan secara
tepat, akan mengakibatkan ketidak-efisienan biaya maupun
waktu. Karena dalam menggunakan Dynamic Programming
diperlukan keahlian, pengetahuan, dan seni untuk merumuskan
suatu masalah yang kompleks, terutama yang berkaitan dengan
penerapan fungsi transformasi dari permasalahan tersebut.
Dynamic Programming tidak memiliki suatu bentuk formulasi
matematik yang baku untuk digunakan secara konsekuen,
sehingga perhitungan untuk menghasilkan keputusan optimal
yang dilakukan terbatas pada kondisi tertentu.
Hambatan terbesar pada Dynamic Programming adalah masalah
dimensionalitas, yaitu masalah dimana peningkatan variable
keadaan yang digunakan dalam Dynamic Programming akan
menambah beban memory computer serta menambah lama waktu
perhitungan.
2.3.

Multistage Graph Problem (Permasalahan

mencari lintasan terpendek)

Permasalahan mencari lintasan/rute terpendek merupakan salah satu
masalah dalam kehidupan sehari-hari. Seiring dengan perkembangan zaman
telah dikembangkan berbagai algoritma untuk memecahkan permasalahan ini.
Berbagai kalangan menemui permasalahan serupa dengan variasi yang
berbeda, contohnya seorang pengemudi yang mencari jalur terpendek dari
tempat asal ke tempat tujuan, pengantar pesanan makanan cepat saji yang juga
mencari jalur terpendek dari tempat asal ke tempat tujuan, dan juga seorang

desainer jaringan computer yang harus mendesain skema perutean pada

jaringan yang dia tangani agar memaksimalkan performa jaringan dan
meminimalkan beban yang harus ditangani oleh jaringan tersebut.
Untuk menyelesaikan persoalan dalam menentukan rute terpendek pada
Multistage Graph, tersedia algoritma dengan strategi Dynamic Programming
yang efisien untuk menghitung rute terpendek. Rute terpendek yang diperoleh
akan meminimumkan fungsi linier lintasan jarak dan waktu. Perumusan
persoalan ini akan menjadi salah satu kegunaan dari penyelesaian rute
terpendek.
Multistage Graph adalah graph dengan sifat-sifat khusus, seperti :
1.
2.
3.
4.
5.

Graph berarah (Directed Graph).

Setiap edge-nya memiliki weight (bobot).
Hanya terdapat satu source (s) dan satu sink (t).
Lintasan dari source ke sink terdiri atas beberapa stage V1 sampai Vk.
Semua edge menghubungkan node di Vi ke sebuah node di Vi + 1

dimana 1 i k.
6. Terdapat stage sebanyak k, dimana k 2.
7. Setiap path dari source ke sink merupakan konsekuensi dari pilihan
sebanyak k 2.
Multistage Graph merupakan bentuk permodelan yang dapat digunakan untuk
menyelesaikan berbagai permasalahan dalam dunia nyata, seperti pemilihan
project untuk mendapatkan keuntungan maksimal, serta pemilihan langkahlangkah yang harus dipilih dalam menyelesaikan sebuah tugas.
Teknik

penyelesaian

Multistage

Graph

Problem

dengan

Dynamic

Programming berdasar pada sebuah prinsip bahwa jalur terpendek dari satu node
(awal atau akhir) ke node lain di stage tertentu merupakan jalur terpendek dari
stage sebelumnya ditambah panjang salah satu edge penghubung stage. Terdapat
beberapa metode dalam penyelesaiannya yaitu sebagai berikut :
a. Metode Forward
Menghitung jarak ke depan (menuju sink).
Prinsip : Analisis dilakukan dengan menghitung path (jalur) dari suatu node
ke sink.

10

Rumus : cost (i,j) = min { c (j,k) + cost (i + l,k) }.

Perhitungan dimulai dari node-node di stage k 2.
Cost (i,j) artinya panjang lintasan dari node j di stage i menuju sink (t).
C (j,l) artinya panjang lintasan dari node j ke node 1.

b. Metode backward
Menghitung jarak ke belakang (dari source).
Prinsip : Analisis dilakukan dengan menghitung path (jalur) dari source ke

suatu node.
Rumus : bcost (i,j) = min { bcost (i 1,l) + c (l,j) }
Perhitungan dimulai dari node-node di stage-3.
Bcost (i,j) artinya panjang lintasan backward dari source (s) menuju node j

di stage i.
C (j,l) artinya panjang lintasan dari node j ke node 1.

2.4.

Studi Kasus Dynamic Programming

2.4.1 Knapsack Problem

Knapsack dapat diartikan sebagai tas atau karung yang dapat
digunakan untuk membawa/memuat sesuatu. Tentunya tidak semua barang
dapat dimasukkan ke dalam karung/tas tersebut. Karung/tas tersebut hanya
dapat memuat beberapa barang saja dengan total ukuran (weight) yang
lebih kecil atau sama dengan ukuran kapasitas karung/tas tersebut. Tidak
seluruh barang tersebut harus kita masukkan semuanya tetapi bisa juga
sebagiannya saja.
Terdapat tiga metode yang dapat digunakan dalam Knapsack Problem,
yaitu :
1. Knapsack 0/1 (Zero One)
Sesuatu yang dimasukkan ke dalam karung/tas dimensinya harus
dimasukkan semua atau tidak sama sekali atau setiap barang hanya
tersedia satu unit.
2. Knapsack Bounded
Sesuatu yang dimasukkan ke dalam karung/tas dimensinya bisa
dimasukkan sebagian atau seluruhnya.
3. Knapsack Unbounded
11

Setiap barang barang tersedia lebih dari satu unit dan juga jumlahnya
tidak terbatas.
Berikut adalah contoh permasalahannya :

Seorang

kolektor

menemukan

sebuah

bangunan

kuno

yang

didalamnya terdapat barang berharga. Dia membawa tas yang hanya

dapat memuat barang seberat 6 kg. Terdapat 4 buah barang yang dapat
dibawa oleh kolektor tersebut yaitu barang A, B, C, dan D dengan
rincian sebagai berikut :
- Barang A : Memiliki berat 3 kg, dan bernilai $6.
- Barang B : Memiliki berat 2 kg, dan bernilai $5.
- Barang C : Memiliki berat 5 kg, dan bernilai $9.
- Barang D : Memiliki berat 4 kg, dan bernilai $8.
Dengan aturan :

Setiap barang hanya terdapat 1 buah, dan tidak bisa diambil sebagian.
Si

kolektor

hanya

memiliki

pilihan

untuk

membawa

atau

meninggalkan barang tersebut, tidak bias membawa setengahnya.

Barang apa saja yang harus dibawa oleh si kolektor agar mendapatkan
hasil yang maksimal ?
Representasi masalah :
- n = 4;
- (b1, b2, b3, b4) = (6, 5, 9, 8);
- W = 6;
- (w1, w2, w3, w4) = (3, 2, 5, 4);
n
= Banyaknya barang.
W
= Total berat maksimal yang bisa dibawa
bn
= keuntungan dari barang n.
wn
= Berat barang n.
Solusi Feasible :

12

Langkah 1 :
-

n = 4;
W = 6;

- (b1, b2, b3, b4) = (6, 5, 9, 8);

- (w1, w2, w3, w4) = (3, 2, 5, 4);

Langkah 2 :
-

n = 4;
- (b1, b2, b3, b4) = (6, 5, 9, 8);
W = 6;
- (w1, w2, w3, w4) = (3, 2, 5, 4);
Kondisi : i = 1;
b[1] = 6;
w[1] = 3;

13

Langkah 3 :
-

n = 4;
- (b1, b2, b3, b4) = (6, 5, 9, 8);
W = 6;
- (w1, w2, w3, w4) = (3, 2, 5, 4);
Kondisi : i = 2;
b[2] = 5;
w[2] = 2;

Langkah 4 :
-

n = 4;
- (b1, b2, b3, b4) = (6, 5, 9, 8);
W = 6;
- (w1, w2, w3, w4) = (3, 2, 5, 4);
Kondisi : i = 3;
b[3] = 9;
w[3] = 5;

Langkah 5 :
-

n = 4;
- (b1, b2, b3, b4) = (6, 5, 9, 8);
W = 6;
- (w1, w2, w3, w4) = (3, 2, 5, 4);
Kondisi : i = 4;
b[4] = 8;
w[4] = 4;

14

Langkah 6 :
-

n = 4;
W = 6;

- (b1, b2, b3, b4) = (6, 5, 9, 8);

- (w1, w2, w3, w4) = (3, 2, 5, 4);

Dari ke-6 langkah di atas dapat kita lihat keuntungan maksimal

yang dapat diperoleh si kolektor adalah $13, dengan membawa dua barang
yaitu (B) dan (D)
2.4.2 Coin Change Problem
Coin Change Problem adalah sebutan atau sebuah metode dalam
strategi algoritma Dynamic Programming yang menguraikan suatu
masalah menjadi masalah-masalah yang lebih kecil sehingga lebih optimal
pengerjaannya.
Coin Change Problem ini berguna untuk memecahkan masalah dalam
mencari jumlah pecahan minimum untuk mendapatkan sejumlah nilai
uang yang diinginkan, di mana pecahan-pecahan uang tersebut berjumlah
tidak terbatas.
Berikut adalah contoh permasalahannya :

Jika di Indonesia hanya terdapat tiga keping uang logam dengan nilai
Rp.3, Rp.5, dan Rp.12.
1. Apakah kembalian Rp.23 dapat dibentuk dari pecahan-pecahan
tersebut ?
15

2. Ada berapa koin minimal untuk membentuk nilai kembalian

Rp.23 ?
3. Ada berapa kombinasi cara untuk membentuk nilai Rp.23 ?
Penyelesaian 1 :

Jika nilai x bisa dibentuk, maka nilai x-3 atau x-5 atau x-12 bisa
dibentuk.
-

Jika kita melihat pada kolom ke-23, kolom tersebut berisikan

tanda B, yang berarti nilai kembalian Rp.23 bisa dibentuk dari
koin-koin yang bernilai Rp.3, Rp.5, dan Rp.12.

Penyelesaian 2 :

Jumlah minimal koin untuk membentuk nilai x didapat dari 1

ditambah dengan jumlah koin minimal untuk membentuk nilai x-3
atau x-5 atau x-12 (diambil dari yang lebih kecil).
-

Pada kolom ke-23 berisikan angka 4, yang berarti nilai kembalian

Rp.23 bisa dibentuk dari koin-koin yang bernilai Rp.3, Rp.5, dan
Rp.12 dengan jumlah koin minimal sebanyak 4 keping.

Penyelesaian 3 :

Banyaknya kombinasi untuk membentuk nilai x adalah jumlah dari

kombinasi yang dapat membentuk nilai x-3, x-5, dan x-12.
-

Pada langkah ini, kolom ke-23 berisi angka 24, yang berarti nilai
kembalian Rp.23 bisa dibentuk dari koin-koin yang bernilai Rp.3,
Rp.5, dan Rp.12 dengan total kemungkinan kombinasi sebanyak
24 kombinasi.

2.4.3 Traveling Salesman Problem

Traveling Salesman Problem merupakan suatu permasalahan
dimana seorang salesman harus mengunjungi semua kota dimana tiap kota
hanya dikunjungi satu kali, dan salesman tersebut harus memulai dari dan
16

kembali ke kota asal. Tujuannya adalah menentukan rute dengan jarak

total atau biaya yang paling minimum.
Berikut adalah contoh permasalahannya :

Seorang salesman akan mengawali perjalanannya di kota asal (Kota

A) untuk mengunjungi seluruh kota yaitu kota A sampai kota F.
Perhatikan gambar berikut :

Dari study kasus diatas didapatkan salah satu kemungkinan jalur yang
paling optimum dengan jalur urutan kota di mulai dari kota A, di
lanjutkan menuju ke kota E, dilanjutkan menuju ke kota F, dilanjutkan
menuju ke kota C, dilanjutkan menuju ke kota D, dilanjutkan kembali
menuju ke kota B, lalu yang terakhir kembali ke kota A. Tentunya
hasil tersebut dengan mempertimbangkan jarak dari masing-masing
kota hingga menghasilkan kombinasi urutan kota dengan jarak yang

optimum.
Dengan hasil seperti pada gambar dibawah ini :

17

BAB 3
PROGRAM
3.1.

Algoritma & Program Knapsack Problem

a. Algoritma
Program knapsack
{I.S : }
{F.S : }
Kamus : {Kamus Global}
Const
maks : 20
Type
satu : array [1..maks] of integer
dua

: array [1..maks] of integer

tiga

: array [1..maks,1..maks] of integer

br

: satu

nl

: dua

: tiga

W, n

: integer

Function max(a:integer,b:integer) integer

Algoritma :
Procedure knapsack(input/output n, W : integer, br : satu,
nl : dua, v : tiga)
{I.S : }
{F.S : }

18

Kamus :
i, j : integer
Algoritma :
For i=0 to W do
v[0][i] 0
endfor
For i=0 to n do
v[i][0] 0
endfor
for i=1 to n do
for j=1 to w do
if ((j-br[i]) < 0) then
v[i][j] v[i-1][j]
else
v[i][j]max(v[i-1][j],v[i-1][j-br[i]]
+nl[i])
endif
endfor
endfor
for i=0 to W do
output(i)
output(--------------------)
for i=0 to n do
output(i,br[i],i,nl[i])
for j=0 to w do
output(v[i][j])
endfor
endfor
output(-------------------)
output(v[n][W])
output(-------------------)
endprocedure
function max(a:integer, b:integer) integer
return (a>b)?a:b
procedure backtrack()
{I.S : }
{F.S : }

19

Kamus :
j1, i : integer
Algoritma :
j1W
output(Objek

Berat

Nilai)

output(---------------------------)
for i=n to i-1 do
if (v[i][j1] != v[i-1][j1] and (v[i][j1] = v[i-1][j1br[i]]+nl[i])) then
output(i,br[i],nl[i])
j1 j1-br[i]
endif
endfor
endprocedure
//algoritma utama
Algoritma :
I,j : integer
W 6
Input(n)
For i=1 to n do
Input(br[i])
Input(nl[i])
Endfor
Output(W)
Knapsack(n, W)
Backtrack()
endprogram

b. Program
#include <stdio.h>
#include <stdlib.h>
/* run this program using the console pauser or add your own
getch, system("pause") or input loop */
#define maks 20
void knapsack(int,int);
int max(int,int);
void backtrack();
int br[maks], nl[maks], W, n;

20

int v[maks][maks];
void main()
{
int i, j;
W=6;
system("cls");
printf("\n Jumlah objek : "); scanf("%d",&n);
printf("\n Masukkan berat dan nilai untuk setiap objek :
");
for(i=1; i<=n; i++)
{
printf("\n");
printf(" Berat objek ke-%d : ",i); scanf("%d",&br[i]);
printf(" Nilai objek ke-%d : ",i); scanf("%d",&nl[i]);
printf("\n");
}
printf(" Kapasitas Knapsack : %d",W);
knapsack(n, W);
backtrack();
getch();
}
void knapsack(int n,int W)
{
int i,j;
for(i=0; i<=W; i++)
v[0][i]=0;
for(i=0; i<=n; i++)
v[i][0]=0;
for(i=1; i<=n; i++)
{
for(j=1; j<=W; j++)
{
if((j-br[i]) < 0)
v[i][j] = v[i-1][j];
else
v[i][j] = max(v[i-1][j], v[i-1][j-br[i]]+nl[i]);
}
}
printf("\n
\t\t");
for(i=0; i<=W; i++)
printf("%2d ",i);
printf("\n-------------------------------------------------------------------");
for(i=0; i<=n; i++)
{

21

printf("\n Br-%d=%2d Nl-%d=%2d |",i,br[i],i,nl[i]);

for(j=0; j<=W; j++)
printf("%2d ",v[i][j]);
}
printf("\n-------------------------------------------------------------------");
printf("\n Maksimum nilai yang dapat dibawa knapsack : %2d
",v[n][W]);
printf("\n-------------------------------------------------------------------");
}
int max(int a,int b)
{
return (a >b)?a:b;
}
void backtrack()
{
int j1,i;
j1=W;
printf("\n Objek \t Berat \t Nilai");
printf("\n-------------------------------------------------------------------");
for(i=n; i>=0; i--)
{
if(v[i][j1]!=v[i-1][j1] && (v[i][j1] == v[i-1][j1br[i]]+nl[i]))
{
printf("\n

%2d \t

%2d

\t

%2d",i,br[i],nl[i]);
j1=j1-br[i];
}
}
}

3.2.

Algoritma & Program Coin Change Problem

a. Algoritma
Program coinchangeproblem
{I.S : }
{F.S : }
Kamus : {Kamus Global}
Const

22

makscari : 25
Type
bkoin : array [1..makscari] of integer
satu

: array [1..makscari] of string

dua

: array [1..makscari] of integer

tiga

: array [1..makscari] of integer

koin

: bkoin

iNilaiCari

: integer

iJmlKoin

: integer

i, j, n

: integer

: satu

C2

: dua

C3

: tiga

benar : boolean
Algoritma :
Procedure tahapsatu
{I.S : }
{F.S : }
Kamus

Algoritma :
i 1
j 1
for i=1 to makscari do
C[i] x
endfor
for j=1 to iJmlKoin do
C[koin[j]] b
endfor
for n=1 to makscari do
for j=1 to iJmlKoin do
if (n-koin[j]) >= 1 then
if C[n-koin[j]] = b then
C[n] b
endif
endif

23

endfor
endfor
if C[iNilaiCari] = b then
benar true
else
benar false
endif
endprocedure
Procedure tahapdua
{I.S : }
{F.S : }
Kamus

Algoritma :
for i=1 to makscari do
C2[i] 0
endfor
for j=1 to iJmlKoin do
C2[koin[j]] 1
endfor
for n=1 to makscari do
for j=1 to iJmlKoin do
if ((n-koin[j]) >= 1) and (C2[n-koin[j]] >
0) then
if (C2[n] = 0) or (C2[n] > (1+C2[nkoin[j]]))then
C2[n] := 1+C2[n-koin[j]]
endif
endif
endfor
endfor
if C2[iNilaiCari] > 0 then
benar true
else
benar false
endif

24

endprocedure
Procedure tahaptiga
{I.S : }
{F.s : }
Kamus

Algoritma :
for i=1 to makscari do
C3[i] 0
endfor
for j=1 to iJmlKoin do
C3[koin[j]] 1
endfor
for n=1 to makscari do
for j=1 to iJmlKoin do
if (n-koin[j]) >= 1 then
C3[n] := C3[n]+C3[n-koin[j]]
endif
endfor
endfor
if C3[iNilaiCari] > 0 then
benar true
else
benar false
endif
endprocedure
{Program Utama}
Algoritma :
iJmlKoin 3
koin[1] 3
koin[2] 5
koin[3] 12

output(' "Coin Change Problem" ')

25

output('

-------------------

')

output('Pecahan koin yang tersedia : ')

output('1. Rp.',koin[1])
output('2. Rp.',koin[2])
output('3. Rp.',koin[3])
output('Total Kembalian [1-25] : Rp.')
input(iNilaiCari)
// Memasukkan procedure
tahapsatu
tahapdua
tahaptiga
if benar = true then
output('Nilai
kembalian
"dapat" dibentuk dari pecahan
',koin[2],', ',koin[3],'.')

Rp.',iNilaiCari,'
koin ',koin[1],',

output('Nilai kembalian Rp.',iNilaiCari,' dapat

diberikan dengan minimal "',C2[iNilaiCari],'" keping koin.')
output('Nilai
kembalian
Rp.',iNilaiCari,'
memiliki kemungkinan kombinasi sebanyak ',C3[iNilaiCari],'
kombinasi.')
else
output('Maaf, uang kembalian Rp.',iNilaiCari,'
"tidak dapat" dibentuk dari pecahan koin ',koin[1],',
',koin[2],', ',koin[3],'.')
endprogram

b. Program
program coinchangeproblem;
uses crt;
const
makscari = 25;
type

bkoin = array[1..makscari] of integer;

satu = array[1..makscari] of string;
dua = array[1..makscari] of integer;
tiga = array[1..makscari] of integer;

var

koin : bkoin;
iNilaiCari : integer;
iJmlkoin : integer;
i, j, n : integer;
C : satu;
C2 : dua;
C3 : tiga;

26

benar : boolean;
procedure tahapsatu;
begin
i:=1;
j:=1;
for i:=1 to makscari do
C[i] := 'x';
for j:=1 to iJmlKoin do
C[koin[j]] := 'b';
for n:=1 to makscari do
begin
for j:=1 to iJmlKoin do
begin
if (n-koin[j]) >= 1 then
begin
if C[n-koin[j]] = 'b' then
C[n] := 'b';
end;
end;
end;

end;

if C[iNilaiCari] = 'b' then

benar := true
else
benar := false;

procedure tahapdua;
begin
for i:=1 to makscari do
C2[i]:=0;
for j:=1 to iJmlKoin do
C2[koin[j]]:=1;
for n:=1 to makscari do
begin
for j:=1 to iJmlKoin do
begin
if ((n-koin[j]) >= 1) AND (C2[n-koin[j]] > 0)
then
begin

if (C2[n] = 0) OR (C2[n] > (1+C2[n-

koin[j]])) then
end;
end;

end;

C2[n]:=1+C2[n-koin[j]];

end;

if C2[iNilaiCari] > 0 then

benar := true
else
benar := false;

27

procedure tahaptiga;
begin
for i:=1 to makscari do
C3[i] := 0;
for j:=1 to iJmlKoin do
C3[koin[j]] := 1;
for n:=1 to makscari do
begin
for j:=1 to iJmlKoin do
begin
if (n-koin[j]) >= 1 then
C3[n] := C3[n]+C3[n-koin[j]];
end;
end;
if C3[iNilaiCari] > 0 then
benar := true
else
benar := false;
end;
// Program Utama
begin
iJmlKoin := 3;
koin[1] := 3;
koin[2] := 5;
koin[3] := 12;
gotoxy(28,1);
writeln(' "Coin Change Problem" ');
gotoxy(28,2);
writeln(' ------------------- ');
writeln;
writeln('Pecahan koin yang tersedia : ');
gotoxy(2,5);
write('1. Rp.',koin[1]);
gotoxy(16,5);
write('2. Rp.',koin[2]);
gotoxy(28,5);
write('3. Rp.',koin[3]);
writeln;
writeln;
write('Total
readln(iNilaiCari);
tahapsatu;
tahapdua;
tahaptiga;
if benar = true then
begin
writeln();

28

Kembalian

[1-25]

Rp.');

write('Nilai kembalian Rp.',iNilaiCari,'

"dapat" dibentuk dari pecahan koin ',koin[1],', ',koin[2],',
',koin[3],'.');
writeln();
write('Nilai kembalian Rp.',iNilaiCari,' dapat
diberikan

dengan

minimal

"',C2[iNilaiCari],'"

keping

koin.');
writeln();
write('Nilai kembalian Rp.',iNilaiCari,'
memiliki kemungkinan kombinasi sebanyak ',C3[iNilaiCari],'
kombinasi.');
end
else
write('Maaf, uang kembalian Rp.',iNilaiCari,'
"tidak

dapat"

dibentuk

dari

pecahan

koin

',koin[1],',

',koin[2],', ',koin[3],'.');
readln;
end.

3.3.

Algoritma & Program Traveling Salesman

Problem
a. Algoritma
Program travelingsalesman
{I.S : }
{F.S : }
Kamus : {Kamus Global}
Const
maks : 10
const : 0
Type
satu : array [1..maks] of integer
dua

: array [1..maks,1..maks] of integer

kj

: satu

: dua

: integer

Algoritma :
Procedure satu(output n,a:integer)
{I.S : }

29

{F.S : }
Kamus :
i, j : integer
Algoritma :
Output(Jumlah kota yang alan dikunjungi : )
Input(n)
Output(Masukkan Cost untuk setiap matrix : ;)
For i=0 to n do
Output(Elemen baris ke- : ,i+1);
For j=0 to n do
Input(a[i][j]);
kj[i] 0;
endfor
endfor
output(List Cost perjalanan : )
for i=0 to n do
for j=0 to n do
output(a[i][j])
endfor
endfor
endprocedure
procedure mincost(input kj:satu)
{I.S : }
{F.S : }
Kamus :
Kota : integer
I, nkota : integer
Algoritma :
kj[kota] 1
output( ,kota+1)
nkota least(kota)
if nkota=999 then
nkota 0
output(nkota+1)
cost+=a[kota][nkota]
return
endif
mincost(nkota)
endprocedure
function least(input c:integer)integer
Kamus :
i, nc, min, kmin : integer
Algoritma :
nc 999
min 999
for i=0 to n do
if((a[c][i]!=0) and (kj[i]=0)) then
if(a[c][i]<min)then
min a[i][0]+a[c][i]

30

endif

kmin a[c][i]
nc i

endif
endfor
if(min!=999)then
cost+=kmin
endif
return nc
endfunction
procedure dua(input cost:integer)
{I.S : }
{F.S : }
Kamus :
Algoritma :
Output(Cost minimum perjalanan : )
Output(cost)
endprocedure
//algoritma utama
Algoritma :
Satu()
Output(Jalur perjalanan : )
Mincost(0)
Dua()
endprogram

b. Program

#include <stdio.h>
#include <stdlib.h>
/* run this program using the console pauser or add your own
getch, system("pause") or input loop */
int a[10][10], kj[10], n, cost=0;
void satu()
{
int i, j;
printf("Jumlah kota yang akan di kunjungi : ");
scanf("%d",&n);
printf("\nMasukkan Cost untuk setiap matrix : \n");
for(i=0; i<n; i++)
{
printf("\nElemen baris ke-%d : \n",i+1);
for(j=0; j<n; j++)
scanf("%d",&a[i][j]);
kj[i]=0;
}
printf("\n\nList Cost perjalanan : \n");

31

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

{
printf("\n");
for(j=0; j<n; j++)
printf("\t%d ",a[i][j]);
}

void mincost(int kota)

{
int i,nkota;
kj[kota]=1;
printf("%d --> ",kota+1);
nkota=least(kota);
if(nkota==999)
{
nkota=0;
printf("%d",nkota+1);
cost+=a[kota][nkota];
return;
}
mincost(nkota);
}
int least(int c)
{
int i, nc=999;
int min=999, kmin;
for(i=0; i<n; i++)
{
if((a[c][i]!=0) && (kj[i]==0))
if(a[c][i] < min)
{
min=a[i][0]+a[c][i];
kmin=a[c][i];
nc=i;
}
}
if(min!=999)
cost+=kmin;
return nc;
}
void dua()
{
printf("\n\nCost minimum perjalanan : ");
printf("%d",cost);
}
void main()
{
system("cls");
satu();
printf("\n\nJalur perjalanan :\n\n");
mincost(0);
dua();
getch();
}

32

BAB 4
PENUTUP
4.1.

Kesimpulan
Dynamic Programming merupakan suatu teknik algoritma yang

digunakan untuk menyelesaikan suatu masalah dengan cara menguraikan

solusi dari penyelesaian masalah tersebut menjadi sekumpulan langkah
(step) atau tahapan (stage) hingga sedemikian rupa sehingga solusi dari
permasalahan tersebut dapat dilihat sebagai suatu keputusan yang saling
berkaitan satu sama lain.
Dynamic

Programming

bekerja

dengan

cara

membagi

permasalahan menjadi beberapa tahap keputusan dimana hasil keputusan

disetiap tahapnya akan mempengaruhi keputusan-keputusan dari tahapan
selanjutnya.
Dynamic Programming memiliki beberapa metode atau cara untuk
menyelesaikan suatu rangkaian permasalahan. Diantaranya adalah dengan
menggunakan metode Knapsack Problem, Coin Change Problem, dan
metode Traveling Salesman Problem yang dapat membantu penyelesaian
masalah dengan cara Dynamic Programming.

33

DAFTAR PUSTAKA
-

Munir, Rinaldi. (2011). Algoritma & Pemrograman dalam Bahasa Pascal

dan C. Bandung : Informatika Bandung
http://gtucse.blogspot.co.id/2012/12/01-knapsack-problem-using-

dynamic.html
http://www.scribd.com/doc/110045673/Metode-Greedy-amp-Dynamic-

Programming#scribd
repository.binus.ac.id/content/T0034/T003457363.ppt
repository.binus.ac.id/content/T0034/T003422229.ppt
repository.binus.ac.id/content/T0034/T003445625.ppt
informatika.stei.itb.ac.id/~rinaldi.munir/Stmik/.../MakalahStmik30.pdf
http://soksnotsocks.tumblr.com/post/3961361150
http://soalparna.blogspot.co.id/2015/03/teori-system-dynamic-

programming.html#
http://arissupri.blogspot.co.id/2013/06/jenis-jenis-algoritma.html
http://dokumen.tips/documents/metode-greedy-dan-dynamic-

programming-55c092483c9e4.html
http://nigold.blogspot.co.id/2013/04/dynamic-programming-secaralengkap.html

34