LAPORAN

DYNAMIC PROGRAMMING

Laporan Ini Disusun Sebagai Tugas Mata Kuliah

Analisis Numerik dan Pemrograman Dinamik

Disusun Oleh:
Devis Styo Nugroho
NRP 6022201042

INSTITUT TEKNOLOGI SEPULUH NOPEMBER

PROGRAM PASCASARJANA TEKNIK ELEKTRO
2020
 DAFTAR ISI

DAFTAR ISI.............................................................................................................................................2
BAB I......................................................................................................................................................4
PENDAHULUAN.....................................................................................................................................4
1.1. Latar Belakang Masalah............................................................................................................4
1.2. Maksud dan Tujuan..................................................................................................................4
1.3. Batasan Masalah.......................................................................................................................4
BAB II.....................................................................................................................................................5
LANDASAN TEORI..................................................................................................................................5
2.1. Definisi Dynamic Programming.................................................................................................5
2.2. Struktur dan Tahapan Dynamic Progamming...........................................................................5
2.3. Kelebihan dan Kekurangan Dynamic Programming..................................................................7
BAB III....................................................................................................................................................8
3.1. Deret Fibonacci.........................................................................................................................8
3.1.1. Algoritma.......................................................................................................................8
3.1.2. Program deret Fibonacci:...............................................................................................9
3.1.3. Output program...........................................................................................................10
3.2. Menghitung Factorial..............................................................................................................11
3.2.1. Algoritma Factorial.......................................................................................................11
3.2.2. Program Faktorial:.......................................................................................................11
3.2.3. Output Program Mencari Nilai Faktorial......................................................................13
3.3. Menghitung Bilangan Pangkat (Power Factor)........................................................................13
3.3.1. Algoritma power factor................................................................................................13
3.3.2. Program menghitung bilangan pangkat.......................................................................14
3.3.3. Output program bilangan pangkat:..............................................................................15
3.4. Greatest Common Divisor (GCD)............................................................................................15
3.4.1. Algoritma GCD.............................................................................................................16
3.4.2. Program GCD...............................................................................................................16
3.4.3. Output program GCD...................................................................................................17
3.5. Binomial Coefficient................................................................................................................17
3.5.1. Algoritma Binomial Coefficient....................................................................................18
3.5.2. Program Binomial Coefficient......................................................................................18
3.5.3. Output Program...........................................................................................................20

Halaman | 2
 3.6. Menara Hanoi.........................................................................................................................20
3.6.1. Algoritma Menara Hanoi..............................................................................................21
3.6.2. Program Menara Hanoi................................................................................................22
3.6.3. Output program Menara Hanoi ketika dijalankan:......................................................24
3.7. Knapsack.................................................................................................................................24
BAB IV..................................................................................................................................................25
PENUTUP.............................................................................................................................................25
DAFTAR PUSTAKA................................................................................................................................26

Halaman | 3
 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
independen, 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) Solusi optimal dari permasalhan didapatkan jika semua tahap sudah terpecahkan.

Halaman | 4
 BAB II
LANDASAN TEORI

2.1. Definisi Dynamic Programming

Dynamic programming merupakan Suatu teknik kuantitatif yang digunakan untuk
membuat suatu rangkaian keputusan yang saling berkaitan. (Hillier & Lieberman ,
Introduction to OR). Sedangkan menurut Hamdy A. Taha dynamic programming adalah
prosedur matematis yang dirancang untuk memperbaiki efisiensi perhitungan masalah
pemrogaman matematis tertentu dengan menguraikannya menjadi bagian masalah-masalah
yang lebih kecil.
Dynamic programming dapat didefinisikan sebagai 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. Metode ini dikembangkan oleh Richard Bellman pada 1950-an dan
telah digunakan di berbagai bidang, mulai dari teknik kedirgantaraan hingga ekonomi.
Pada penyelesaian persoalan dengan metode ini:
 Terdapat sejumlah berhingga pilihan yang mungkin
 Solusi pada setiap tahap dibangun dari hasil solusi tahap sebelumnya
 Kita menggunakan persyaratan optimasi dan kendala untuk membatasi sejumlah
pilihan yang harus dipertimbangkan pada suatu tahap
Pada dynamic programming, rangkaian keputusan yang optimal dibuat dengan
menggunakan Prinsip Optimalitas. Prinsip Optimalitas: 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. Ongkos pada tahap k+1 = (ongkos yang dihasilkan pada tahap k) +
(ongkos dari tahap k ke tahap k+1)

2.2. Struktur dan Tahapan Dynamic Progamming

Ada tiga hal yang penting diketahui tentang dynamic programming :
• STAGE (Tahapan) dari persoalan yang dihadapi dan ingin dicari solusinya
• STATE: (Kondisi) yang menjadi faktor penentu keputusan dari tiap tahapan
• DECISION: (Keputusan) yang harus diambil dari tiap tahap untuk sampai kepada
solusi keseluruhan

Halaman | 5
 Gambar 2.1 Struktur dynamic programming

Prinsip dalam penyelesaian masalah dynamic programming adalah sebagai berikut:

1) 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 yang 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).
2) 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.
3) Prinsip ketiga dalam model Dynamic Programming adalah tentang variabel keputusan.
Variabel keputusan dalam Dynamic Programming dinyatakan 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.
4) 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

Halaman | 6
 Dynamic Programming diformulasikan. Selain itu fingsi transformasi juga menyatakan
tentang hubungan fungsional nilai status pada setiap tahap 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.3. Kelebihan dan Kekurangan Dynamic Programming

Tabel perbandingan kelebihan dan kekurangan dynamic programming:
No Kelebihan Kekurangan
1 Proses pemecahan masalah Penggunaan DP jika tidak dilakukan dengan
kompleks dibagi menjadi sub-sub tepat akan mengakibatkan ketidakefisienan
kecil sehingga rangkaian masalah biaya dan waktu. Karena dalam
jadi lebih jelas untuk diketahui. menggunakan DP diperlukan keahlian,
pengetahuan dan seni untuk merumuskan
suatu masalah yang kompleks.
2 Dapat diaplikasikan untuk berbagai DP tidak memiliki suatu bentuk formulasi
macam masalah pemrograman matematis yang baku untuk digunakan
matematik karena lebih fleksibel secara konsekuen sehingga perhitungan
dibanding teknik optimasi lain. untuk menghasilkan keputusan optimal yang
dilakukan terbatas pada kondisi tertentu.
3 Prosedur perhitungan dynamic Peningkatan omputer keadaan yang
programing juga memperkenankan digunakan dalam perhitungan DP akan
analisis sensitivitas terdapat pada menambah beban omputer serta
setiap omputer status maupun pada menambah lama waktu perhitungan.
tahap keputusan stage.
4 Dapat menyesuaikan sistematika
perhitungannya menurut ukuran
masalah yang tidak selalu tetap
dengan tetap melakukan perhitungan
satu per satu secara lengkap dan
menyeluruh.

BAB III

Halaman | 7
 STUDI KASUS

Berikut ini adalah contoh study kasus penyelesaian masalah dengan menggunakan
pendekatan dynamic programming, ditulis dengan menggunakan Bahasa pemrograman C+
+, compiler gcc dan ide codeblock.

3.1. Deret Fibonacci

Angka Fibonacci adalah angka dalam urutan bilangan bulat berikut.
1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765,
10946…
bilangan fibonacci secara matematika punya state sebagai berikut:
F(n) = F(n-1)+F(n-2) jika n>= 2
F(n) = 0 jika n=0, atau F(0) = 0
F(n) = 1 jika n=1, atau F(1) = 1
dan, F(2) = F(1) + F(0) = 0 + 1 = 1, F(3) = F(2) + F(1) = 1+1 = 2, ….. dan seterusnya
Dalam menyelesaiakan permasalahan deret fibonacci dapat dilakukan pendekatan dynamic
programming. pertama diberi inisialisasi awal bahwa Memo[1] = Memo[2] = 1, (dari rumus
F(1) = 1, dan F(2) = 1), dan mulailah mengconstruct valuenya mulai dari n=3 ke n yang
diinginkan yaitu dengan Memo[n] = Memo[n-1] + Memo[n-2]; saat n=3, maka Memo[3] =
Memo[2] + Memo[1] (karena Memo[1] = Memo[2] = 1) maka Memo[3] = 1 +1 = 2, utk
Memo[4] = Memo[3]+Memo[2] = 2 + 1 = 3 (pada algoritma ini bermain di
array/memorization).

3.1.1. Algoritma
Algoritma deret Fibonacci adalah sebagai berikut:
1. Mulai
2. Deklarasi variabel
3. Membuat fungsi menghitung deret fibonacci
4. Menentukan array (memo) untuk menyimpan hasil perhitungan.
5. Masukkan n, yaitu banyaknya bilangan fibonacci yang diinginkan
6. Jika n = 0 maka memo[0] = 0, jika n = 1 maka memo[1] dan jika n = memo [2] = 0
7. Jika n >= 3 perulangan i = 3 dan menghitung memo[i] = memo[i - 1] + memo[i - 2]
8. Return fungsi
9. Cetak nilai variabel fibonacci(i)

Halaman | 8
 10. Cetak langkah penyelesaian
11. Tanya apakah pengguna masih ingin menampilkan deret fibonacci
12. Bila iya lanjut ke langkah 5
13. Bila tidak, maka program dapat diakhiri
14. Selesai

3.1.2. Program deret Fibonacci:

//Program C++ Menghitung Deret Fibonacci

#include <iostream>
#include <conio.h>

using namespace std;

//deklarasi variabel
char s = 'y';
int z, k, i;

//fungsi menghitung deret fibonacci

double fibo(int n)
{
double memo[n + 2]; // deklarasi array untuk menyimpan perhitungan sebelumnya
memo[0] = 0;
memo[1] = memo[2] = 1;
for (int i = 3; i <= n; i++)
memo[i] = memo[i - 1] + memo[i - 2];
return memo[n];
}

//fungsi langka penyelesaian

int step(int z)
{
for (i = z; i >= 2; i--)
{
cout << "* fibonacci ke-" << i << " = call f(" << i - 1 << ") + f(" << i - 2 << ") => "
<< fibo(i - 1) << " + " << fibo(i - 2) << endl;
}
cout << "* fibonacci ke-" << 1 << " = call f(1) => " << fibo(1) << endl;
cout << "* fibonacci ke-" << 0 << " = call f(0) => ";
return fibo(0);
}

//program utama
int main()
{
/* perulangan */
do
{
system("cls");
switch (s)

Halaman | 9
 {
case 'y':
cout << "Aplikasi menghitung deret Fibonacci\n";
cout << "===================================\n";
cout << " " << endl;
cout << "Masukkan batas deret fibonacci: ";
cin >> k;
cout << "\nDeret fibonacci: ";
for (z = 1; z <= k; z++)
{
cout << " " << fibo(z);
}
cout << "\nfibonacci ke-" << k << " adalah = " << fibo(k) << endl;
cout << " ";
cout << "\nLangkah Penyelesaian: " << endl;
//memanggil fungsi langkah penyelesaian
cout << step(k);

break;
case 'n':
return 0;
}
cout << "\n\nApakah ingin mengulang program? tekan (y/n) " << endl;
z = _getch();
s = char(z);
} while (true);
return 0;
}

3.1.3. Output program

Gambar 3.1 Output program deret Fibonacci ketika dijalankan

3.2. Menghitung Factorial

Faktorial bilangan asli nnn adalah perkalian semua bilangan asli yang kurang atau sama dengan n.
Faktorial dilambangkan dengan tanda !. Jadi jika n!, maka dibaca "n faktorial".

Halaman | 10
Berikut adalah contoh factorial:

3.2.1. Algoritma Factorial

Algoritma dengan pseudocode
Begin
   fact(int n):
      Read the number n
      Initialize
      i = 1, memo[n+2]
      memo[0] = 1
      for i = 1 to n
         memo[i] = i * memo[i - 1];
   Print memo[n]
End

3.2.2. Program Faktorial:

#include <conio.h>
#include <iostream>

using namespace std;

int n, i;
char s = 'y';

//fungsi recursif menghitung factorial

double fact(int n)
{
double memo[n + 2]; //deklarasi array menyimpan perhitungan sebelumnya
if (n >= 0)
{

memo[0] = 1;
for (int i = 1; i <= n; ++i)
{
memo[i] = i * memo[i - 1];
}
}
return memo[n];
}

//fungsi langkah perhitungan

int step(int n)
{
cout << " \nLangkah - langkah :" << endl;
for (i = n; i >= 1; i--)
{
cout << " " << i << " call " << i - 1 << "! --> return " << i << " x " << fact(i - 1) << endl;
}

Halaman | 11
 cout << " " << endl;
cout << "Result=> ";
return n;
}

//program utama
int main()
{
do
{
/* code */
system("cls");
switch (s)
{
case 'y':
cout << "\nAplikasi Mencari Nilai Faktorial" << endl;
cout << "==================================\n"
<< endl;
cout << "Masukkan nilai: ";
cin >> n;
//memanggil fungsi langkah penyelesaian
cout << step(n);

//memanggil fungsi perhitungan factorial

cout << "! = " << fact(n) << endl;
break;
case 'n':
return 0; //keluar program
}
cout << "\nApakah ingin mengulang program? tekan (y/n) " << endl;
n = _getch();
s = char(n);
} while (true);

return (0);
}

3.2.3. Output Program Mencari Nilai Faktorial

Gambar 3.2 Output program faktorial ketika dijalankan

Halaman | 12
3.3. Menghitung Bilangan Pangkat (Power Factor)
Bilangan berpangkat merupakan perkalian berulang suatu bilangan, dimana bilangan dapat
berpangkat bulat positif, nol, maupun bulat negatif. Secara sederhana penulisan bilangan jenis
ini adalah sebagai berikut :
an = a * a n-1
a disebut bilangan pokok atau basis, sedangkan n disebut pangkat atau eksponen.

3.3.1. Algoritma power factor

1. Mulai
2. Deklarasi variabel
3. Membuat fungsi menghitung power factor
4. Menentukan array (memo) untuk menyimpan hasil perhitungan sebelumnya.
5. Masukkan nilai a dan n
6. if n >= 0 maka memo[0] = 1
7. for i=1, pangkat = a*pangkat (a, n-1);
8. Return fungsi memo[n]
9. Cetak hasil
10. Cetak langkah penyelesaian
11. Tanya apakah pengguna masih ingin menampilkan hasil
12. Bila iya lanjut ke langkah 5
13. Bila tidak, maka program dapat diakhiri
14. Selesai

3.3.2. Program menghitung bilangan pangkat

#include <iostream>
#include <conio.h>
#include <fstream>

using namespace std;

int a, n, i;
char s = 'y';

//fungsi menghitung power factor

double pof(int a, int n)
{
double memo[n+2]; //ukuran array untuk menyimpan perhitungan sebelumnya
if (n >= 0)

Halaman | 13
 {
memo[0] = 1;
for (int i = 1; i <= n; i++)
memo[i] = a * memo[a, i - 1];
}
return memo[n];
}

//fungsi langkah perhitungan

int step(int a, int n)
{
for (i = n; i >= 1; i--)
{
cout << a << "^" << i << " => call " << a << "^" << i << " => " << pof(a, i) << endl;
}
cout << a << "^" << 0 << " => call " << a << "^" << 0 << " => ";
return 0;
}

//program utama
int main()
{
ofstream newfile("power_factor.dat", ios::app); //fitur menyimpan log
newfile.is_open();

do
{
system("cls"); //clear terminal
switch (s)
{
case 'y':
cout << "# Aplikasi Menghitung bilangan a pangkat n #" << endl;
newfile << "# Aplikasi Menghitung bilangan a pangkat n #" << endl;

cout << "============================================\n"<< endl;

cout << "Masukkan Nilai a : ";
cin >> a;
newfile << "Nilai a = " << a << endl;
cout << "Masukkan Nilai n : ";
cin >> n;
newfile << "Nilai n = " << n << endl;

//memanggil fungsi pof

cout << "Hasil " << a << " pangkat " << n << " = " << pof(a, n) << endl;
newfile << "Hasil " << a << " pangkat " << n << " = " << pof(a, n) << endl;
cout << "\nLangkah perhitungan : " << endl;
//memanggil fungsi langkah-langkah
cout << step(a, n);
//newfile << step(a, n) << endl;

cout << " " << endl;

break;
case 'n':
return 0; //keluar program
}
cout << "\nApakah ingin mengulang program? tekan (y/n) " << endl;
n = _getch();
s = char(n);
} while (true);
newfile.close();

Halaman | 14
 return (0);
}

3.3.3. Output program bilangan pangkat:

Gambar 3.3 Output program menghitung pangkat ketika dijalankan

3.4. Greatest Common Divisor (GCD)

GCD merupakan singkatan dari greatest common divisor. Artinya bilangan terbesar yang
dapat membagi dua bilangan atau beberapa bilangan.
Contoh: GCD dari bilangan 36 dan 60
36 = 2 x 2 x 3 x 3
60 = 2 x 2 x 3 x 5
GCD dari dua angka tersebut adalah
(36, 60) = 2 x 2 x 2 = 12

3.4.1. Algoritma GCD

1) Mulai
2) Deklarasi variabel int a, b, n
3) Membuat fungsi menghitung gcd
4) Masukkan nilai a dan b, yaitu banyaknya bilangan fibonacci yang diinginkan
5) if n >= 0 maka gcd=b
6) else gcd = gdc (b mod a, a)
7) Return fungsi gcd
8) Cetak nilai hasil
9) Cetak langkah penyelesaian
10) Tanya apakah pengguna masih ingin menampilkan hasil
11) Bila iya lanjut ke langkah 4
12) Bila tidak, maka program dapat diakhiri
13) Selesai

Halaman | 15
3.4.2. Program GCD
#include <iostream>
#include <conio.h>
using namespace std;
char s = 'y';
int a, b, n;

int gcd(int a, int b)

{
if (b == 0) {
return a;
}
else {
return gcd(b, a % b);
}
}

int main()
{
do
{
system("cls"); //clear terminal
switch (s)
{
case 'y':
cout << "=====Aplikasi Menghitung GCD=====" << endl;
cout << " " << endl;
cout << "masukkan bilangan pertama : ";
cin >> a;
cout << "masukkan bilangan kedua : ";
cin >> b;
cout << "Pembagi Terbesar antara " << a << " and " << b << " is " << gcd(a,
b)<<endl;
break;
case 'n':
return 0; //keluar program
}

Halaman | 16
 cout << "\nApakah ingin mengulang program? tekan (y/n) " << endl;
n = _getch();
s = char(n);
} while (true);
return 0;
}

3.4.3. Output program GCD

Gambar 3.4 Output program GCD ketika dijalankan

3.5. Binomial Coefficient

Teorema Binomial adalah suatu cara untuk menjabarkan bentuk pangkat (x+y) n, n bilangan
bulat.Teori Binomial menyatakan:

Koefisien untuk xn-k yk yaitu sukuk e-(k+1) adalah c(n,k). Bilangan C(n,k) disebut Koefisien Binomial

3.5.1. Algoritma Binomial Coefficient

function binomialCoeff(int n, int k);
var integer i, j;
begin
for i = 0 to min (i, j) do
begin
if (j=0) or (i=j) then c[I, j]: 1 else
c[i, j]:=c[i-1, j-1]+c[i-1,j]
end;
end;
binomialCoeff:=c[n,k];
end;

Halaman | 17
3.5.2. Program Binomial Coefficient
Program ini ditulis dengan menggunakan bahas C++.
#include <iostream>
#include <stdio.h>
#include <conio.h>

using namespace std;

int min(int a, int b);
int C[10000][10000];
char s = 'y';
int n, k;

int binomialCoeff(int n, int k)

{
int i, j;

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

{
for (j = 0; j <= min(i, k); j++)
{
if (j == 0 || j == i)
C[i][j] = 1;
else
C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
}
}
return C[n][k];
}

// Fungsi menampilkan tabel binomial

int printbinomial(int max)
{
for (int m = 0; m <= max; m++)
{

int binom = 1;
for (int x = 1; x <= m; x++)
{

// B(m, x) adalah 1 jika m or x adalah 0

if (m != 0 && x != 0)

// menggunakan rekursif
// B(m, x) = B(m, x - 1) * (m - x + 1) / x
binom = binom * (m - x + 1) / x;

printf("%4d", binom);
}
printf("\n");
}
}

int min(int a, int b)

{
return (a < b) ? a : b;
}

int main()
{

Halaman | 18
 do
{
system("cls");
switch (s)
{
case 'y':
cout << "Mencari koefisien Binomial C[n][k]" << endl;
cout << "Masukkan nilai n : ";
cin >> n;
cout << "Masukkan nilai k : ";
cin >> k;
cout << "Nilai dari C[" << n << "][" << k << "] = " << binomialCoeff(n, k) << endl
<< endl;
printbinomial(n);
cout << endl;

break;
case 'n':
return 0; //keluar program
}
cout << "\nApakah ingin mengulang program? tekan (y/n) " << endl;
n = _getch();
s = char(n);
} while (true);

return (0);
}

3.5.3. Output Program

Gambar 3.5 Output Program

Halaman | 19
3.6. Menara Hanoi
Menara Hanoi adalah sebuah permainan matematis atau teka-teki. Teka-teki ini
ditemukan Eduard Lucas, ahli matematika Perancis di tahun 1883.

Gambar 3.6.1 Kondisi awal menara hanoi

Permainan ini terdiri dari tiga tiang dan sejumlah cakram dengan ukuran berbeda-beda
yang bisa dimasukkan ke tiang mana saja.
Permainan Menara Hanoi dimulai dengan cakram-cakram yang tertumpuk rapi dari
cakram paling besar sampai ke cakram paling terkecil dalam salah satu tiang, sehingga
membentuk kerucut.
Objektif dari permainan Menara Hanoi adalah memindahkan tumpukan n buah cakram
berlubang dari tiang asal ke tiang tujuan dengan memanfaatkan sebuah tiang perantara.
Piringan berukuran tidak sama. Jumlah pemindahan dalam n buah cakram adalah sebanyak
2n-1 kali.
Permainan Menara Hanoi memiliki beberapa aturan yang harus dipatuhi untuk
menyelesaikan teka-teki. Dalam melakukan pemindahan cakram harus mengikuti
aturan berikut:
 Hanya satu cakram yang boleh dipindahkan dalam setiap kal perpindahan.
 Setiap perpindahan berupa pengambilan cakram teratas dari satu tiang dan
memasukkannya ke tiang lain, di atas cakram lain yang mungkin sudah ada di tiang
tersebut.
 Tidak boleh meletakkan cakram di atas cakram lain yang lebih kecil.
Permasalahan Menara Hanoi memiliki empat buah parameter dalam penyelesaiannya, H (n,
a, b, c). Sebanyak n buah cakram harus dipindahkan dari tiang a ke tiang c dengan
memakai bantuan tiang b. Permasalahan utama adalah meminimalkan jumlah pemindahan
yang harus dilakukan agar semua cakram bisa dipindahkan dari tiang a ke tiang b dengan
tetap memenuhi aturan dari permainan atau teka-taki Menara Hanoi.
Ide utama dari penyelesaian permainan Menara Hanoi ini adalah memindahkan
cakram terbesar dari tiang awal ke tiang tujuan. Cakram utama dipindahkan dari tiang a ke
tiang b. Hal ini berarti (n-1) cakram sudah di pindahkan satu per satu dari tiang a ke tiang c.

Halaman | 20
Setelah cakram terbesar dipindahkan ke tiang b, maka perlu dipindahkan (n-1) cakram dari
tiang c ke tiang b secara satu per satu.
Dalam pemrograman dinamis, jika ingin mendapatkan solusi yang optimal dalam suatu
masalah maka perlu didapatkan solusi yang optimal pula dalam sub-masalah yang ada.
Begitu pula dengan permainan Menara Hanoi ini. Untuk mendapatkan solusi optimal dalam
permasalahan utama, maka perlu dicari solusi optimal untuk perpindahan (n-1) cakram dari
tiang c ke tiang b. Maka, akan ada fungsi yang menentukan langkah untuk mendapatkan
jumlah perpindahan minimum yang merupakan solusi optimal dari penyelesaian Menara
Hanoi ini. Fungsi rekursif (fmin) yang diperoleh dari penyelesaian Menara Hanoi
 if n = 1, then H(n, a, b, c) = (a dipindahkan ke b)
 if n > 1, then H (n, a, b, c) = H (n – 1, a, c, b)
(a dipindahkan ke b)
H (n - 1; c; b; a)
Fungsi rekursif ini akan memrlukan 2n-1 langkah untuk menyelesaikan permasalahan
Menara Hanoi. Langkah tersebut merupakan solusi optimal dari penyelesaian Menara
Hanoi.

3.6.1. Algoritma Menara Hanoi

Algoritma dengan pseudocode:
Function Hanoi (n:integer, char tiang_asal, char tiang_tujuan, char tiang bantu)
begin
If n = 1
then pindahkan cakram n dari asal ke tujuan;
else
hanoi:=hanoi(n-1, tiang_asal, tiang_tujuan, tiang_bantu;
pindahkan cakram n asal ke tujuan;
hanoi:=hanoi(n-1, tiang_bantu, tiang_asal, tiang_tujuan);
end;
Hanoi:=0; //return value
print hanoi;
end;
if yes;
loop program;
else no:
return 0;//exit program
end;

Halaman | 21
3.6.2. Program Menara Hanoi
Program Hanoi ditulis dengan c++:
// C++ fungsi rekursif untuk menyelesaikan
// menara hanoi
#include <bits/stdc++.h>
#include <conio.h>

using namespace std;

char s = 'y';

void ToH(int n, char tiang_asal,

char tiang_tujuan, char tiang_bantu)
{
if (n == 1)
{
cout << "Pindahkan cakram 1 dari tiang " << tiang_asal << " ke tiang " << tiang_tujuan
<< endl;
return;
}
ToH(n - 1, tiang_asal, tiang_bantu, tiang_tujuan);
cout << "Pindahkan cakram " << n << " dari tiang " << tiang_asal << " ke tiang " <<
tiang_tujuan << endl;
ToH(n - 1, tiang_bantu, tiang_tujuan, tiang_asal);
}

//fungsi menghitung 2^n - 1

int step(int a, int n)
{
int memo[n + 2]; //ukuran array untuk menyimpan perhitungan sebelumnya
if (n >= 0)
{
memo[0] = 1;
for (int i = 1; i <= n; i++)
memo[i] = a * memo[a, i - 1];
}
return memo[n];
}

// Program Utama
int main()
{
int i, a, n; // jumlah cakram
a = 2;
do
{
system("cls"); //clear terminal
switch (s)
{
case 'y':
cout << "Tower Of Hanoi" << endl;
cout << "++++++++++++++" << endl;

Halaman | 22
 cout << "masukkan jumlah cakram: ";
cin >> n;

cout << "\nTerdapat " << step(a, n) - 1 << " langkah penyelesaian\n"
<< endl;

ToH(n, 'A', 'C', 'B'); // A, B dan C adalah nama tiang

break;
case 'n':
return 0; //keluar program
}
cout << "\nApakah ingin mengulang program? tekan (y/n) " << endl;
n = _getch();
s = char(n);
} while (true);

return 0;
}

3.6.3. Output program Menara Hanoi ketika dijalankan:

Gambar 3.6.2 Output program Menara Hanoi

3.7. Knapsack
Knapsack adalah suatu permasalahan dalam menentukan pemilihan objek dari
sekumpulan objek yang masing-masing mempunyai bobot/berat (weight) dan nilai/profit
(value) untuk dimuat dalam sebuah media penyimpanan tanpa melebihi kapasitas media
penyimpanan tersebut sehingga diperoleh hasil yang optimum. Seringkali hasil yang dicari
tersebut merupakan keuntungan maksimum. Contoh kasusnya adalah seorang penjual yang
sedang memilih berbagai macam barang dagangan miliknya untuk dimasukkan ke dalam
tasnya seperti sketsa gambar berikut ini:

Halaman | 23
 Sumber : https://en.wikipedia.org/wiki/Knapsack_problem

Permasalahan pada gambar di atas adalah memilih barang yang akan dimasukkan dalam tas
dengan kapasitas(M) sebesar15 Kg dengan jumlah objek dagangan(n) sebanyak 5 jenis
barang dengan berat masing-masing(Wi) dan keuntungan per barang(Pi) dalam (Wi,Pi)
sebesar : (1,2) , (12,4), (2,2), (1,1) dan (4,10).
Permasalahan knapsack yang dipakai bisa terbagi menjadi dua, yakni 0/1 knapsack dan
fractional knapsack. Persoalan 0/1 knapsack adalah menentukan objek mana saja yang harus
dimuat dan tidak dimuat. Sedangkan dalam fractional knapsack persoalannya adalah
menentukan berapa bagian dari masing-masing objek yang akan dimuat dalam media
penyimpanan.
Terkadang keterbatasan manusia dalam menyelesaikan masalah knapsack tanpa
menggunakan alat bantu merupakan salah satu kendala dalam pencarian solusi optimum.
Apalagi jika dihadapkan dengan jumlah objek yang terlampau banyak. Efisiensi waktu juga
sering menjadi pertimbangan. Oleh karena itu, dibutuhkan suatu metode sekaligus program
aplikasi penerapan metode tersebut yang dapat membantu menyelesaikan masalah knapsack.
Beberapa algoritma atau metode seperti Algoritma Genetik, Algoritma Branch and Bound,
Algoritma Greedy, Algoritma Simpleks, dan Algoritma Program Dinamis dapat dipilih untuk
membantu menyelesaikan permasalahan. Contoh program dari Knapsack dengan
menggunakan C++ sebagai berikut:

//Knapsack rekursif
#include <bits/stdc++.h>
using namespace std;

int max(int a, int b) { return (a > b) ? a : b; }

// Kapasitas wadah knapsack (Kg): W

// Berat masing-masing objek yg akan dimasukkan(Kg) : wt
// Nilai masing-masing objek(rupiah) : val
// Banyaknya objek(buah) : n
int napsack(int W, int wt[], int val[], int n)
{

// Basis
if (n == 0 || W == 0)
return 0;

// solusi optimal
if (wt[n] > W)
return napsack(W, wt, val, n – 1);

Halaman | 24
 // Pengembalian nilai apabila telah maksimum
else
return max(
val[n] + napsack(W – wt[n],
wt, val, n – 1),
napsack(W, wt, val, n – 1));
}

// Nilai inputan ditentukan

int main()
{
int val[] = { 5000, 10000, 12000 };
int wt[] = { 10, 20, 30 };
int W = 50;
int n = sizeof(val) / sizeof(val[0]);
cout << “Nilai paling banyak yang bisa dibawa sebesar: “<< napsack(W, wt, val, n)
<< “ rupiah” << endl;
return 0;
}

Output Program:

Halaman | 25
 BAB IV
PENUTUP

Kesimpulan
Berdasarkan studi kasus sebelumnya, kita dapatkan bahwa penyelesaian masalah
dapat dilakukan dengan pendekatan pemrograman dinamis atau dynamic programming.
Pemrograman Dinamis memiliki strategi penyelesaian dengan cara membagi masalal ke
dalam beberapa submasalah.
Dari masing-masing sub-masalah kemudian didapatkan solusi optimal. Dari masing-masing
sub-solusi kemudian digabungkan untuk menjadi solusi optimal dari permasalahan utama.

Halaman | 26
 DAFTAR PUSTAKA

Sutanto, candra. 2010. Penyelesaian Masalah Menara Hanoi dengan Pemrograman

Dinamis. Institut Teknologi bandung
http://mohamadrisalrozakamakali.blogspot.com/2013/05/program-dinamis-
dynamicprogramming.html (dikunjungi pada 10 November 2020)
http://web.unair.ac.id/admin/file/f_12649_paper_dynamic_programming.pdf (dikunjungi
pada 10 November 2020)
http://fileex.blogspot.com/2013/10/skripsi-perancangan-simulasi-dynamic.html (dikunjungi
pada 10 November 2020)
http://repo.eepis-its.edu/718/1/1026.pdf (dikunjungi pada 10 November 2020)
https://icomit.wordpress.com/2012/06/02/traveling-salesman-problem-tsp-dalamdefinisi/
(dikunjungi pada 10 November 2020)

Halaman | 27