LAPORAN

ANALISIS ALGORITMA

“DYNAMIC PROGRAMMING”

Laporan Ini Disusun Sebagai Tugas Pengganti Kuis

Pada Mata Kuliah Analisis Algoritma

Disusun Oleh :
Agung Eka Lukmantara
(10113319)
Analgo - 4

Dosen :
Angga Setiyadi, S.Kom

JURUSAN TEKNIK INFORMATIKA

FAKULTAS TEKNIK dan ILMU KOMPUTER
UNIVERSITAS KOMPUTER INDONESIA
BANDUNG, Januari 2015
 KATA PENGANTAR

Puji syukur kami panjatkan kepada Allah SWT. Yang telah melimpahkan

rahmat dan hidayah-Nya, serta dengan do’a restu kedua orang tua, sehingga

penulis dapat menyelesaikan laporan ini.

Laporan ini merupakan salah satu tugas pada mata kuliah “Analisis

Algoritma” tahun ajaran 2014 / 2015.

Penulis sadar bahwa laporan ini masih sangar kurang dari apa yang

diharapkan, namun penulis berharap mudah-mudahan hasil laporan ini dapat

dimanfaatkan bagi semua pihak, dan untuk kesempurnaan laporan ini bersedia

untuk menerima kritikan dan saran.

Bandung, Januari 2015

Penulis
 DAFTAR ISI
KATA PENGANTAR.....................................................................................................2
DAFTAR ISI ..................................................................................................................3
BAB I .............................................................................................................................4
1.1. Latar Belakang Masalah.......................................................................................4
1.2. Maksud dan Tujuan .............................................................................................4
1.3. Batasan Masalah ..................................................................................................5
BAB II ............................................................................................................................6
2.1. Definisi Strategi Dynamic Programming .............................................................6
2.2. Kekurangan dan Kelebihan Strategi Dynamic Programming .............................. 10
2.2.1. Kelebihan Dynamic Programming ................................................................ 10
2.2.2. Kekurangan Dynamic Programming ............................................................. 10
2.3. Multistage Graph Problem (Permasalah Mencari Lintasan Terpendek) ............. 11
2.4. Study Kasus Dynamic Programming ................................................................. 13
2.4.1. Knapsack Problem (Pendekatan Dynamic Programming).............................. 13
2.4.2. Coin Cange Problem ..................................................................................... 16
2.4.3. Traveling Salesman Problem ......................................................................... 16
BAB III ......................................................................................................................... 19
3.1. Algoritma .......................................................................................................... 19
3.1.1. Algoritma Knapsack Problem ........................................................................ 19
3.1.2. Algoritma Coin Change Problem .................................................................. 21
3.1.3. Algoritma Traveling Salesman Problem ......................................................... 22
3.2. Program............................................................................................................. 24
1.1.1. Program Knapsack Problem ........................................................................... 24
1.1.2. Program coin Change Problem ...................................................................... 26
1.1.3. Program Traveling Salesman Problem ........................................................... 27
BAB IV ........................................................................................................................ 29
4.1. Kesimpulan ....................................................................................................... 29
4.2. Saran ................................................................................................................. 29
DAFTAR PUSTAKA ................................................................................................... 31
 BAB I
PENDAHULUAN

1.1. Latar Belakang Masalah

Untuk menyelesaikan suatu masalah tentunya membutuhkan suatu cara atau

solusi agar masalah tersebut terselesaikan dengan baik. Setiap masalah apapun

tentunya membutuhkan yang namanya solusi atau cara. Dalam sebuah

penelitianpun diperlukan solusi untuk membantu memecahkan suatu masalah.

Sama halnya dengan laporan ini yang membahas tentang “Dynamic

Programming”.

Dynamic Programming mirip seperti metode divide-and-conquer yang

menyelesaikan suatu problem dengan mengkobinasikan solusi menjadi

subproblem. Divide-and-conquer membagi problem menjadi subproblem yang

independen. Kemudian menyelesaikan subproblem secara rekursif dan

mengkombinasikan solusi tersebut untuk menyelesaikan problem utama.

Sedangkan dynamic programming cocok digunakan ketika subproblem tidak

indepen-den, jadi ketika subproblem terbagi menjadi sub-subproblem.

1.2. Maksud dan Tujuan

Maksud dari program dinamis adalah suatu teknik matematis yang

biasanya digunakan untuk membuat suatu keputusan dari serangkaian keputusan

yang saling berkaitan. Dalam hal ini program dinamis menyediakan prosedur

sistematis untuk menentukan kombinasi keputusan yang optimal.

 Tujuan utama model ini ialah untuk mempermudah penyelesaian persoalan

optimasi yang mempunyai karakteristik tertentu. Tidak seperti pemrograman

linier, tidak ada bentuk matematis standar untuk perumusan pemrograman

dinamis. Akan tetapi, pemrograman dinamis adalah pendekatan umum untuk

pemecahan masalah dan persamaan tertentu yang digunakan di dalamnya harus

dibentuk sesuai dengan situasi masalah yang dihadapi.

1.3. Batasan Masalah

Terdapat beberapa poin dalam batasan masalah laporan ini, yaitu :

1. Memecah permasalahan asli (original problem) menjadi bagian

permasalahan (subproblem) yang juga disebut sebagai tahapan (stage),

dengan aturan keputusan di tiap-tiap tahapan.

2. Memecahkan tahapan terakhir dari permasalahan dengan semua kondisi dan

keadaan yang memungkinkan.

3. Bekerja mundur dari tahap terakhir, dan memecahkan tiap tahap. Hal ini

dikerjakan dengan mencari keputusan optimal dari tahap tersebut sampai

dengan tahap terakhir.

4. Solusi optimal dari permasalhan didapatkan jika semua tahap sudah

terpecahkan.
 BAB II
DYNAMIC PROGRAMMING

2.1. Definisi Strategi Dynamic Programming

Dynamic programming dapat didefinisikan sebagai suatu pendekatan

matematik yang memiliki prosedure sistematis yang dirancang sedemikian rupa

dengan tujuan untuk 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.

Struktur dynamic programming untuk dapat dimengerti secara lebih jelas

dan lebih spesifik, umumnya dideskripsikan dengan suatu sistem notasi. Struktur

dynamic programming disebut juga dengan model dynamic programming. Notasi

dan simbol yan digunakan dalam model dynamic programming adalah beragam,

namun secara umum dapat dinyatakan sebagai berikut :

i = Tahap keputusan ke - i.

n = Banyak tahap keputusan.

Xi = Variable keputusan pada tahap keputusan ke – i.

Si(Si – 1, Xi) = Status pada tahap keputusan ke – i.

ri(Si,Xi) = Return pada tahap keputusan ke – i.

fi(Si,Xi) = Nilai keputusan pada tahap keputusan ke – i, untuk status

Si dan variable keputusan Xi.

fi*(Si) = Nilai keputusan optimal pada tahap keputusan ke – i,

untuk status Si.

 X1 X2 Xi Xn-1 Xi

Stage Stage Stage Stage Stage

S0 S1 S2 Si-1 i Si Sn-2 n-1 Sn-1 n Sn
1 2

r1(S1,X1) r2(S2,X2) ri(Si,Xi) rn-1(Sn-1,Xn-1) rn(Sn,Xn)

f1(S1,X1) f2(S2,X2) fi(Si,Xi) fn-1(Sn-1,Xn-1) fn(Sn,Xn)

* Struktur dan Sistem Notasi Dynamic Programming

Dynamic Programming (biasa disingkat DP) adalah suatu teknik algoritma

untuk memecahkan masalah dimana solusi optimal dari masalah tersebut dapat

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

Dynamic programming dapat dibagi menjadi empat tahap yang berurutan

sebagai berikut :

1. Karakterisasi struktur pada solusi optimasi

2. Mendefinisikan nilai solusi optimal secara rekursif

3. Menghitung nilai solusi optimal pada model bottom-up

4. Menyusun solusi optimal dari informasi hasil perhitungan

Langkah 1 sampai langkah 3 adalah dasar dynamic-programming dalam

menemukan solusi untuk suatu problem, langkah ke-4 dapat dilakukan jika nilai

solusinya optimal diperlukan.

 Dynamic programming sebagai suatu pendekatan matematik memiliki

beberapa prinsip dasar yang terkait erat satu sama lain. Prinsip-prinsip dasar

tersebut, yaitu :

Prinsip pertama dalam model Dynamic programming adalah bahwa

masalah dapat dibagi menjadi bagian-bagian masalah yang lebih kecil. Masalah

yang lebih kecil atau sub masalah ini tersebut sebagai tahap keputusan (stage).

Setiap masalah uang akan diselesaikan, terlebih dahulu dibagi-bagi menjadi

beberapa masalah kecil dengan maksud memudahkan evaluasi masalah untuk

mendapatkan keputusan optimal dari tiap-tiap tahap yang pada akhirnya akan

menghasilkan satu keputusan yang optimal. Oleh karena itu model Dynamic

programming disebut juga model multi stage programming (model multi tahap).

Proses urutan pembagian masalah dalam model Dynamic programming

ditunjukan pada gambar berikut :

Tahap 3 Tahap 2 Tahap 1

**Proses Urutan pembagian masalah Secara Mundur

Prinsip kedua dalam model Dynamic programming adalah tentang status

(state). Pengertian status (state) dalam Dynamic programming adalah arus

informasi dari suatu tahap ke tahap berikutnya. Arus informasi yang masuk ke

suatu tahap disebut status input, sedangkan arus informasi yang keluar dari suatu

tahap diseebut stats output. Status input penting, karena keputusan pada tahap

berikutnya tergantung dari status input sebelumnya. Jadi, status input untuk tahap

keputusan n-1 merupakan status output dari tahap keputusan sebelumnya, yaitu
tahap keputusan n. Sedangkan status output dari tahao keputusan n akan menjadi

status input untuk tahap kepututsan berikutnya, yaitu tahap keputusan n-1.

Status Input Status Input Status Input

Tahap 3 Tahap 2 Tahap 1

Tahap Tahap Tahap

Keputusan 3 Keputusan 2 Keputusan 1

Status output Status output

Tahap 3 Tahap 2

***Hubungan Status Input Dengan Tahap Keputusan

Prinsip ketiga dalam model Dynamic Programming adalah tentang

variabel keputusan. Variabel keputusan dalam Dynamic Programming

dainyatakan dalam berbagai bentuk keputusan alternatif yang dapat dipilih pada

saat pengambilan keputusan pada tahap tertentu. Berbagai alternatif keputusan

yang dapat diambil dalam setiap tahap keputusan dapat dibatasi dengan sejumlah

persyaratan yang dikenalkan dalam struktur masalah.

Prinsip keempat dalam model Dynamic Programming adalah tentang

fungsi transformasi. Fungsi transformasi memberikan penjelasan tentang

bagaimana hubungan antara tahap keputusan yang satu dengan tahap keputusan

yang lain dalam Dynamic Programming diformulasikan. Selain itu fingsi

transformasi juga menyatakan tentang hubungan fungsional nilai status pada

setiaptahap keputusan. Hubngan status dalam tahap keputusan yang berurutan

bersifat berulang, artinya jika terdapat tahap keputusan n dalam hubungannya

dengan thap keputusan n-1 maka perhitungan untuk nilai status n-1 menggunakan

nilai status n dari keputusan pada tahap n.

2.2. Kekurangan dan Kelebihan Strategi Dynamic Programming

2.2.1. Kelebihan Dynamic Programming

Terdapat beberapa kelebihan pada Dynamic Programming, diantaranya :

 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 dari pada teknik optimasi lain.

 Prosedure perhitungan Dynamic Programming juga memperkenankan

bentuk analisis sensitivitasi terdapat pada setiap variabel status (state)

maupun pada variabel yang ada di masing-masing tahap keputusan (stage).

 Dynamic Programming dapat menyesuaikan sistematik perhitungannya

menurut ukuran masalah yang tidak selalu tetap dengan melakukan

perhitungan satu per satu secara lengkap dan menyeluruh.

2.2.2. Kekurangan Dynamic Programming

Disamping memiliki kelebihan, Dynamic Programming juga memiliki

beberapa kekurangan, diantaranya :

 Penggunaan Dynamic Programming jjika tidak dilakukan secara tepat,

akan mengakibatkan ketidakefisienan biata maupun waktu. Karena dalam

menggunakan Dynamic Programming diperlukan keahlian, pengetahuan,

dan seni untuk merumuskan suatu masalah yang kompleks, terutama yang
 berkaitan dengan penetapan 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 variabel keadaan yang

digunakan dalam perhitungan pemrograman dinamis akan menambah

beban memory komputer serta menambah lama waktu perhiutngan.

2.3. Multistage Graph Problem (Permasalah Mencari Lintasan Terpendek)

Permasalahan pencarian rute terpendek merupakan suatu masalah yang

sangat terkenal di dunia Informatika. Dari dahulu hingga sekarang telah

dikembangkan berbagai algoritma untuk memecahkan permasalahan ini.

Penentuan rute terpendek dari satu titik ke titik yang lain adalah masalah yang

sering ditemui dalam kehidupan sehari-hari.

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 komputer yang harus mendesain skema perutean pada jaringan yang dia
tangani agar memaksimalkan performa jaringan dan meminimalkan beban yang

harus ditangani oleh jaringan tersebut.

Persoalan untuk menentukan rute terpendek pada graph multitahap

(multistage graph) dan algoritma efisien yang tersedia 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 rute jarak terpendek. Algoritma yang digunakan untuk menentukan

rute terpendek pada graph multitahap (multistage graph) adalah Dynamic

Programming. Seiring dengan waktu yang berjalan dan juga perkembangan ilmu

pengetahuan dan teknologi permasalahan pencarian rute terpendek ini telah

terpecahkan dengan berbagai algoritma salah satunya dengan algoritma Dynamic

Programming.

Algoritma yang digunakan untuk menentukan rute terpendek pada

graph multitahap (multistage graph) adalah Dynamic Programming. Algoritma

Dynamic Programming adalah suatu metode pemecahan masalah dengan cara

menguraikan solusi menjadi sekumpulan langkah (step) atau tahapan (stage)

sedemikian sehingga solusi dari persoalan dapat dipandang dari serangkaian

keputusan yang saling berkaitan. Pada Algoritma Dynamic Programming

rangkaian keputusan yang optimal dibuat dengan menggunakan prinsip

optimalitas. Prinsip optimalitas yaitu jika solusi total optimal, maka bagian solusi

sampai tahap ke-k juga optimal. Prinsip optimalitas berarti bahwa jika kita bekerja

dari tahap k ke tahap k + 1, kita dapat menggunakan hasil optimal dari tahap k

tanpa harus kembali ke tahap awal.

2.4. Study Kasus Dynamic Programming

2.4.1. Knapsack Problem (Pendekatan Dynamic Programming)

Knapsack adalah tas atau karung. Karung digunakan untuk memuat

sesuatu. Dan tentunya tidak semua objek dapat ditampung di dalam karung

tersebut, hanya menampung barang yang pentingnya saja. Karung tersebut hanya

dapat menyimpan beberapa objek dengan total ukurannya (weight) lebih kecil atau

sama dengan ukuran kapasitas karung. Setiap objek itupun tidak harus kita

masukkan seluruhnya. Tetapi bisa juga sebagian saja.

Knapsack problem memiliki tiga jenis solusi, yaitu:

 Solusi Knapsack 0/1 (Zero One)

Sesuatu yang dimasukkan kedalam karung dimensinya harus dimasukkan

semua atau tidak sama sekali atau setiap barang hanya tersedia satu unit.

 Solusi Knapsack Bounded

Sesuatu yang dimasukkan kedalam karung dimensinya bisa dimasukkan

sebagaian atau seluruhnya.

 Solusi Knapsack Unbounded

Setiap barang tersedia lebih dari satu unit dan juga jumlahnya tak terbatas.

Knapsack problem bisa diselesaikan dengan berbagai cara. Ada beberapa

strategi algoritma yang bisa menghasilkan solusi optimal, diantaranya adalah

Brute Force. Tapi strategi ini tidak efisien, jadi knapsack problem pada laporan ini

akan diselesaikan dengan Greedy Algorithm yaitu solusi yang mencari nilai

optimum. Algoritma ini memecahkan permasalahan langkah per langkah, pada

setiap langkah:
 Mengambil pilihan terbaik yang bisa diperoleh saat itu juga tanpa

memperatikan konsekuensi kedepan (prinsip “take what you can get now!”).

 Berharap bahwa dengan memilih optimum lokal pada setiap langkah akan

berakhir dengan optimum global.

Contoh Permasalah :

 Jumlah barang yang dapat diambil

Barang-i wi pi
n=3
1 2 65
 Kapasitas maksimum karung
2 3 80
M=5
3 1 30
f1(y) = max{f0(y), p1 + f0(y – w1)}
M=5
= max{f0(y), 65 + f0(y – 2)}

Solusi Optimum

Y f0(y) 65 + f0(y – 2) f1(y) (x1*, x2*, x3*)

0 0 - 0 (0, 0, 0)

1 0 - 0 (0, 0, 0)

2 0 65 65 (1, 0, 0)

3 0 65 65 (1, 0, 0)

4 0 65 65 (1, 0, 0)

5 0 65 65 (1, 0, 0)
 f2(y) = max{f1(y), p2 + f1(y – w2)}

= max{f1(y), 80 + f1(y – 3)}

Solusi Optimum

Y f1(y) 80 + f1(y – 3) f2(y) (x1*, x2*, x3*)

0 0 80 + (-) = - 0 (0, 0, 0)

1 0 80 + (-) = - 0 (0, 0, 0)

2 65 80 + (-) = - 65 (1, 0, 0)

3 65 80 + 0 = 80 80 (0, 1, 0)

4 65 80 + 0 = 80 80 (0, 1, 0)

5 65 80 + 65 = 145 145 (1, 1, 0)

f3(y) = max{f2(y), p3 + f2(y – w3)}

= max{f2(y), 30 + f2(y – 1)}

Solusi Optimum

Y f2(y) 30 + f2(y – 1) f3(y) (x1*, x2*, x3*)

0 0 30 + (-) = - 0 (0, 0, 0)

1 0 30 + (-) = - 0 (0, 0, 0)

2 65 30 + 0 = 30 65 (1, 0, 0)

3 80 30 + 65 = 95 95 (1, 0, 1)

4 80 30 + 80 = 110 110 (0, 1, 1)

5 145 30 + 80 = 110 145 (1, 1, 0)

Solusi optimum X = (1, 1, 0) dengan p = f = 145.

2.4.2. Coin Cange Problem

Coin change problem adalah proses di mana menukarkan kepala coin yang

muncul dengan tailnya, atau kasus yang lebih mudahnya adalah kasus

penukaran mata uang rupiah ke dollar , dimana jumlah nominal dalam rupiah

akan di kalikan dengan angka(dollar) yang user ingin kan. Dengan adanya

program dynamic programming ini pengguna dapat menyelesaikan suatu

permasalahnya dengan mudah.

2.4.3. Traveling Salesman Problem

TSP atau Traveling Salesman Problem adalah salah satu masalah distribusi

yang cukup lama dibahas dalam kajian optimasi. Masalahnya adalah bagaimana

seorang salesman mengunjungi seluruh kota di suatu daerah dan kembali ke kota

awal keberangkatan dengan aturan bahwa tidak boleh ada kota yang dikunjungi

lebih dari satu kali.

Berikut adalah aturan-aturan yang mengidentifikasikan bahwa

permasalahan tersebut adalah TSP:

1. Perjalanan dimulai dan diakhiri di kota yang sama sebagai kota asal sales.

2. Seluruh kota harus dikunjungi tanpa satupun kota yang terlewatkan.

3. Salesman tidak boleh kembali ke kota asal sebelum seluruh kota

terkunjungi.

4. Tujuan penyelesaian permasalahan ini adalah mencari nilai optimum dengan

meminimumkan jarak total rute yang dikunjungi dengan mengatur urutan

kota.
Perhatikan contoh berikut:

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 tersebut 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. Perhatikan gambar dibawah ini.

 BAB III
ALGORITMA DAN PROGRAM
3.1. Algoritma
3.1.1. Algoritma Knapsack Problem
Procedure knapsack::input(Output n,c:integer; Input i:integer)
Deklarasi :

Algoritma :
Output<<" Knapsack dengan Dynamic programming";
Output<<" Berapabanyak item yang andaperlukan : ";
Input>>n;
Output<<"masukkan kapasitas ";
Input>>c;
Output<<"masukkan "<<n<<" items:";
For(i=1;i<=n;i++)
Output<<"\nitemke-"<<i<<" Berat:";
Input>>w[i];
Output<<"\nmasukkan profit/value"<<i<<" :";
Input>>v[i];
endfor
endprocedure

Procedure knapsack::knap(Input i,n,c,j,d,w:integer)

Kamus :

Algoritma :
For i:= 0 to n do
d[i][0]=0;
For j:= 1 to c do
d[0][j]=0;

For(i=1;i<=n;i++)
{
For(j=1;j<=c;j++)
{
if((j-w[i])<0)
then
d[i][j]=d[i-1][j];
else
d[i][j]=max(d[i-1][j],v[i]+(d[i-1][j-w[i]]));
endif
endfor
endfor
endprocedure
Procedure knapsack::output(Input n,i,j,d,c:integer)
Deklarasi :
Algoritma :
Output<<"Nilaiperhitungantertinggiuntuk "<< n <<" items:"<<endl;
For(i=0;i<=n;i++)
For(j=0;j<=c;j++)
Output<<d[i][j];
endfor
endfor
endprocedure

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

if(a>b)
then
return a;
else
return b;
endfunction
{Algoritma Utama}
Deklarasi :
class knapsack
{
w[20],v[20],d[10][10],n,c,i,j: integer;
public:
Procedure input(Output n,c:integer; Input i:integer );
Procedure knap(Input i,n,c,j,d,w:integer);
Function knapsack::max(a :integer,b :integer ) → integer
Procedure output(Input n,i,j,d,c:integer);
};

Algortima :

knapsack k;
k.input(Output n,c:integer; Input i:integer );
k.knap(Input i,n,c,j,d,w:integer);
k.output(Input n,i,j,d,c:integer);
3.1.2. Algoritma Coin Change Problem

Function CoinChangeDynamic(input jumlah, d[], size, C[], s[] : Integer) →integer

C[0] = 0;
For(int j = 1; j <= jumlah; j++) {
C[j] = INT_MAX;
For(int i = 0; i < size; i++) {
if(j >= d[i] and 1 + C[j-d[i]] < C[j] )
then
C[j] = 1 + C[j-d[i]];
// i-th denomination used For the amount of j
s[j] = i;
endif
endfor
endfor
return C[jumlah];
endfunction

{Algoritma Utama}
Deklarasi :
jumlah ,d,size,ans,k :integer;
s,C:^integer
Function CoinChangeDynamic(input jumlah, d[], size, C[], s[] : Integer) →integer

Algoritma :
d[] = 1, 5, 10, 25, 50, 100,500,1000;
Output<<"Masukan Jumlah Nilai Koin = ";cin>>jumlah;
size = sizeof(d)/sizeof(d[0]);
C^ = new int[jumlah+1];
s^ = new int[jumlah+1];
ans = CoinChangeDynamic(jumlah, d, size, C, s);
Ouput<< "Minimal Koin = " << ans << endl;

Ouput<< "Menggunakan Koin: " ;

k = jumlah;
while(k) {
Ouput<< d[s[k]] << " ";
k = k - d[s[k]];
endwhile
dealloc[] C;
dealloc[] s;
3.1.3. Algoritma Traveling Salesman Problem

Procedure get(output n,a:integer )

Deklarasi :

Algoritma :
Output("Enter No. of Cities: ");
Input(n);
Output("Enter Cost Matrix : ");
For i:= i to n do
Output(" Enter Elements of Row # : ",i+1);
For j:= j to n do
Input(a[i][j]);
visited[i]=0;
endfor
endfor
Output("The cost list is: ");
For( i=0;i<n;i++)
For( j=0;j<n;j++)
Output(a[i][j]);
Endfor
endfor
endprocedure

Function least(input c:integer)→integer

Int i,nc=999;
int min=999,kmin;
For(i=0;i<n;i++)
if((a[c][i]!=0)&&(visited[i]==0))
then
if(a[c][i]<min)
then
min=a[i][0]+a[c][i];
kmin=a[c][i];
nc=i;
endif
endif
if(min!=999)
then
cost+=kmin;
return nc;
endfunction

Procedure mincost(input visited:integer;)

Deklarasi :
city :integer;
i,ncity:integer;
Algoritma :
visited[city]=1;

Output(city+1,"%–>");
ncity= least(city);
if(ncity==999)
then
ncity=0;
Output("%d",ncity+1);
cost+=a[city][ncity];
return;
endif
mincost(ncity);
endprocedure

Procedure put(input cost:integer)

Deklarasi :

Algoritma :
Output("nMinimum cost: ");
Output(cost);
endprocedure

{Algortima utama}
Deklarasi :
a[10][10],visited[10],n,cost=0:integer;
i,j:integer;
Procedure get(output n,a:integer )
Function least(input c:integer)→integer
Procedure mincost(input visited:integer;)
Procedure put(input cost:integer)

Algoritma :
Procedure get(output n,a:integer )
Output("\n\nThe Path is:\n\n");
mincost(0);
put();
3.2. Program
3.2.1. Program Knapsack Problem
#include <iostream>
#include <conio.h>
#include <stdlib.h>

using namespace std;

class knapsack
{
int w[20],v[20],d[10][10],n,c,i,j;
public:
void input( );
void knap( );
int max(int,int);
void output( );
};

void knapsack::input()

{
cout<<"Knapsack dengan Dynamic programming"<< endl;
cout << endl;
cout<<"Berapa banyak item yang anda perlukan : ";
cin>>n;
cout<<"Masukkan kapasitas : ";
cin>>c;
cout<<"Masukkan "<<n<<" items:";
for(i=1;i<=n;i++)
{
cout<<"\nitem ke-"<<i<<" Berat:";
cin>>w[i];
cout<<"\nmasukkan Profit/Value "<<i<<" :";
cin>>v[i];
}
}

void knapsack::knap()
{
for(i=0;i<=n;i++)
d[i][0]=0;
for(j=1;j<=c;j++)
d[0][j]=0;
for(i=1;i<=n;i++)
{
for(j=1;j<=c;j++)
 {
if((j-w[i])<0)
d[i][j]=d[i-1][j];
else
{
d[i][j]=max(d[i-1][j],v[i]+(d[i-1][j-w[i]]));
}
}
}
}

void knapsack::output()
{
cout << endl;
cout<<"Nilai perhitungan tertinggi untuk "<< n <<" items:"<<endl;
for(i=0;i<=n;i++)
{
for(j=0;j<=c;j++)
{
cout<<"\t"<<d[i][j];
}
cout<<endl;
}
}
int knapsack::max(int a,int b)
{
if(a>b)
return a;
else
return b;
}

int main()
{
//system("cls");
knapsack k;
k.input();
k.knap();
k.output();
getch();
}
3.2.2. Program coin Change Problem
#include <iostream>
#include <limits.h>

using namespace std;

int CoinChangeDynamic(int jumlah, int d[], int size, int C[], int s[])
{
C[0] = 0;
for(int j = 1; j <= jumlah; j++) {
C[j] = INT_MAX;
for(int i = 0; i < size; i++) {
if(j >= d[i] && 1 + C[j-d[i]] < C[j] ) {
C[j] = 1 + C[j-d[i]];

// i-th denomination used for the amount of j

s[j] = i;
}
}
}
return C[jumlah];
}

int main()
{
int d[] = {1, 5, 10, 25, 50, 100,500,1000};
int jumlah ;//= 67;
cout <<"Masukan Jumlah Nilai Koin = ";cin >>jumlah;
int size = sizeof(d)/sizeof(d[0]);
int *C = new int[jumlah+1];
int *s = new int[jumlah+1];
int ans = CoinChangeDynamic(jumlah, d, size, C, s);
cout << "Minimal Koin = " << ans << endl;

cout << "Menggunakan Koin: " ;

int k = jumlah;
while(k) {
cout << d[s[k]] << " ";
k = k - d[s[k]];
}

delete[] C;
delete[] s;
return 0;
}
3.2.3. Program Traveling Salesman Problem
#include<stdio.h>
#include <stdlib.h>
#include<conio.h>
using namespace std;
int a[10][10],visited[10],n,cost=0;

void get()
{
int i,j;
printf("Enter No. of Cities: ");
scanf("%d",&n);
printf("\nEnter Cost Matrix: \n");
for( i=0;i<n;i++)
{
printf("\n Enter Elements of Row # : %d\n",i+1);
for( j=0;j<n;j++)
scanf("%d",&a[i][j]);
visited[i]=0;
}
printf("\n\nThe cost list is:\n\n");
for( i=0;i<n;i++)
{
printf("\n\n");
for( j=0;j<n;j++)
printf("\t%d",a[i][j]);
}
}

int least(int c)
{
int i,nc=999;
int min=999,kmin;
for(i=0;i<n;i++)
{
if((a[c][i]!=0)&&(visited[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 mincost(int city)

{
int i,ncity;
visited[city]=1;
printf("%d ->",city+1);
ncity= least(city);
if(ncity==999)
{
ncity=0;
printf("%d",ncity+1);
cost+=a[city][ncity];
return;
}
mincost(ncity);
}
void put()
{
printf("\n\nMinimum cost:");
printf("%d",cost);
}
int main()
{
system("cls");
get();
printf("\n\nThe Path is:\n\n");
mincost(0);
put();
getch();
}
 BAB IV
PENUTUP

4.1. Kesimpulan
Pemrograman dinamis merupakan suatu teknik analisa kuantitatif untuk

membuat tahapan keputusan yang saling berhubungan. Teknik ini menghasilkan

prosedur yang sistematis untuk mencari keputusan dengan kombinasi yang

optimal.

Pemrograman dinamis membagi permasalahan menjadi beberapa tahap

keputusan, dimana hasil keputusan dari satu tahap akan mempengaruhi keputusan

dari tiap-tiap tahapan selanjutnya.

Dynamic programming dapat didefinisikan juga sebagai suatu pendekatan

matematik yang memiliki prosedure sistematis yang dirancang sedemikian rupa

dengan tujuan untuk 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.

4.2. Saran
Menurut penulis, dengan menggunakan metode dynamic programming

sudah sangat membantu untuk menyelesaikan suatu masalah. Dengan

menggunakan metode ini permasalah yang dianggap rumit pun dapat terselesaikan

dengan banyak solusi. Misalkan, solusi knapsack problem, solusi coin change

problem, dan traveling salesman problem. Solusi tersebut sudah sangat membantu

untuk menyelesaikan suatu permasalahan. Dengan meninjau kelebihan dari

dynamic programming kita dapa memecahkan suatu permasalahan yang kompleks

menjadi sub-sub masalah yang lebih kecil dan membuat sumber permasalahan
dalam rangkaian proses masalah tersebut menjadi lebih jelas untuk diketahui.

Dapat menyelesaikan suatu masalah pemrograman matematik, karena Dynamic

Programming cenderung lebih fleksibel dari pada teknik optimasi lain. Prosedur

perhitungan dynamic programming juga memperkenankan bentuk analis

sensitivitas terdapat pada setiap variabel status maupun pada variabel yang ada

pada masing-masing tahap keputusan dan juga dapat menyesuaikan sistematika

perhitungannya menurut ukuran masalah yang tidak selalu tetap dengan

melakukan perhitungan satu per stu secara lengkap dan menyeluruh.

 DAFTAR PUSTAKA

http://mohamadrisalrozakamakali.blogspot.com/2013/05/program-dinamis-dynamic-
programming.html

http://web.unair.ac.id/admin/file/f_12649_paper_dynamic_programming.pdf

http://fileex.blogspot.com/2013/10/skripsi-perancangan-simulasi-dynamic.html

http://repo.eepis-its.edu/718/1/1026.pdf

https://icomit.wordpress.com/2012/06/02/traveling-salesman-problem-tsp-dalam-
definisi/

Dian Perdhana Putra – 13507096, Teknik Informatika ITB. Jl. Ganesha 10 Bandung.
e-mail: if17096@students.if.itb.ac.id