BAB I

PENDAHULUAN

1.1 Latar Belakang

Masalah knapsack muncul pada tahun 1957 yang dikemukakan oleh Dantzig.
Munculnya permasalahan ini adalah dari seorang tentara yang akan berangkat ke medan
tempur. Ia membawa sebuah ransel yang mempunyai kapasitas volume tertentu. Ransel
tersebut akan diisi berbagai perlengkapan yaitu senjata, pakaian, makanan, obat-obatan dan
lain-lain. Masing-masing perlengkapan memberikan suatu nilai yang berarti baginya. Tentara
tersebut akan memilih perlengkapan apa saja yang akan dimasukkan ke dalam ransel tanpa
melanggar kapasitas volume tetapi jumlahan nilai yang diberikan maksimum.
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. Sering kali hasil tersebut berupa
keuntungan maksumun.
Permasalahan knapsack 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 telampau banyak. Efesiensi waktu juga
sering menjadi pertimbangan. Oleh karena itu, dibutuhkan suatu metode sekaligus program
aplikasi penerapan tersebut yang dapat membantu menyelesaikan masalah knapsack.
Beberapa algoritma atau metode seperti algoritma genetic, algoritma branch and bound,
algoritma greedy, algoritma simpleks, algoritma simpleks direvisi dan algoritma program
dinamis dapat dipilih untuk menyelesaikan permasalahan knapsack. Namun, secara umum
masing-masing algoritma tersebut hanya mampu menyelesaikan masalah 0/1 knapsack atau
fractional knapsack saja.
Pada tugas uts ini permasalahan yang dikaji adalah 0/1 knapsack,nantinya akan
membahas tentang tentang permasalahan 0/1 knapsack. Selain pemabahasa tersebut akan
dibahas beberapa metode yang digunakan untuk penyelesaian masalah 0/1 knapsack. Pada

tugas uts ini yang digunakan sebagai contoh dari study kasus yaitu dengan menggunakan
algoritma program dinamis untuk menyelesaikan permasalahan 0/1 knapsack.

1.2.

Rumusan Masalah

Berdasarkan latar belakang di atas maka masalah yang akan diselesaikan dalam penelitian ini
adalah:
1.

Apa yang dimaksud dengan knapsack?

2.

Penjalasan algoritma yang dapat menyelesaikan permasalahan knapsack?

3.

Penjelasan Studi kasus yang dipilih?

4.

Membuat program pada proses studi kasus tersebut?

1.3.

Tujuan

Tujuan dati tugas uts ini sebagai berikut:

1.

Mengetahiu teori dasar tetang knapsack

2.

Mengetahui metode-metode algoritma penyelesaian knapsack

3.

Menyelesaikan studi kasus yang diplijh

4.

Mampu membuat program untuk menyelesaikan studi kasus yang dipilih.

BAB II
PEMBAHASAN

2.1 Tinjauan Umum Knapsack

Knapsack adalah tas atau karung yang digunakan untuk memasukkan sesuatu.
Tapi tidak semua barang bisa ditampung ke dalam karung tersebut. Karung tersebut hanya
dapat menyimpan beberapa objek dengan total ukurannya (weight) lebih kecil atau sama
dengan ukuran kapasitas karung.
Knapsack problem merupakan masalah di mana orang dihadapkan pada persoalan optimasi
pada pemilihan benda yang dapat dimasukkan ke dalam sebuah wadah yang memiliki
keterbatasan ruang atau daya tampung. Dengan adanya optimasi dalam pemilihan benda
yang

akan

dimasukkan

ke

dalam

wadah

tersebut diharapkan dapat menghasilkan

keuntungan yang maksimum.

Benda-benda yang akan dimasukkan ini masing-masing memiliki berat dan sebuah
nilai yang digunakan untuk menentukan prioritasnya dalam pemilihan tersebut. Nilainya dapat
berupa tingkat kepentingan, harga barang, nilai sejarah, atau yang lainnya.

Wadah yang

dimaksud di sini juga memiliki nilai konstanta yang merupakan nilai pembatas untuk
benda-benda yang akan dimasukkan ke dalam wadah tersebut sehingga harus diambil
sebuah cara memasukkan benda-benda tersebut ke dalam wadah sehingga menghasilkan
hasil optimum tetapi tidak melebihi kemampuan wadah untuk menampungnya. Terdapat
beberapa variasi Knapsack problem:
A. 0/1 Knapsack problem
Setiap barang hanya tersedia 1 unit, take it or leave it.
B. Fractional Knapsack problem
Barang boleh dibawa sebagian saja (unit dalam pecahan). Versi problem ini menjadi
masuk akal apabila barang yang tersedia dapat dibagi-bagi misalnya gula, tepung, dan
sebagainya.
C. Bounded Knapsack problem
Setiap barang tersedia sebanyak N unit (jumlahnya terbatas).
D. Unbounded Knapsack problem
Setiap barang tersedia lebih dari 1 unit, jumlahnya tidak terbatas.

2.1 Algoritma Penyelesaian Knapsack

Banyak metode algoritma yang dapat digunakan untuk menyelesaikan permasalahan
knapsack. Berikut diantaranya metode-metode yang dapat digunakan untuk menyelesaikan
knapsack.
a. Brute Force
Brute force adalah pendekatan straightforward untuk menyelesaikan masalah,
umumnya sangat bergantung pada pernyataan masalah dan definisi dari konsep.
Jika terdapat n item untuk dipilih, maka akan ada 2

kemungkinan kombinasi dari

item-item tersebut untuk ditempatkan di Knapsack. Sebuah item dapat terpilih atau
tidak dalam kombinasi tersebut. Angka 0 dan 1 akan dibangkitkan sepanjang n.
Jika I

menunjukkan 0 maka item tersebut tidak terpilih dan jika 1 maka item

tersebut dipilih.
b. Algoritma Greedy
Teknik pemrograman dengan menggunakan Greedy sering digunakan untuk
permasalahan optimasi. Secara umum teknik ini menggunakan heuristic untuk
mencari solusi suboptimum sehingga diharapkan solusi optimum.
Pada Greedy Algorithm ada beberapa strategi yang digunakan untuk memilih objek
yang akan dimasukkan ke dalam knapsack:
1. Greedy by profit
Pada setiap langkah, knapsack diisi dengan objek yang mempunyai keuntungan
terbesar. Strategi ini mencoba memaksimumkan keuntungan dengan memilih objek
yang paling menguntungkan terlebih dahulu. Pertama kali yang dilakukan adalah
mengurutkan secara menurun objek-objek berdasarkan profit-nya.
Kemudian baru diambil satu-persatu objek yang dapat ditampung oleh knapsack
sampai knapsack penuh atau sudah tidak ada objek lagi yang bisa dimasukkan.
2. Greedy by weight
Pada setiap langkah, knapsack diisi dengan objek yang mempunyai berat
paling ringan. Strategi ini mencoba memaksimumkan keuntungan dengan
memasukkan sebanyak mungkin objek ke dalam knapsack. Pertama kali yang
dilakukan adalah mengurutkan secara menaik objek-objek berdasarkan weight-nya.
Kemudian baru diambil satu-persatu objek yang dapat ditampung oleh knapsack
sampai knapsack penuh atau sudah tidak ada objek lagi yang bisa dimasukkan.

3. Greedy by density
Pada setiap langkah, knapsack diisi dengan objek yang mempunyai densitas
terbesar. Strategi ini mencoba memaksimumkan keuntungan dengan memilih
objek yang mempunyai keuntungan per unit berat terbesar. Pertama kali yang
dilakukan adalah mencari nilai profit per unit (density) dari tiap-tiap objek.
Kemudian objek-objek tersebut diurutkan berdasarkan densitynya. Kemudian baru
diambil satu-persatu objek yang dapat ditampung oleh knapsack sampai knapsack
penuh atau sudah tidak ada objek lagi yang bisa dimasukkan.
Setelah tiga strategi tersebut diterapkan dan diuji, maka didapat hasil terbaik
dating dari aturan ketiga, yaitu memilih item bernilai tinggi dari rasio bobot
terhadap berat.
Pemilihan objek berdasarkan salah satu dari ketiga strategi di atas tidak
menjamin akan memberikan solusi optimal. Berbeda dengan strategi brute
force

yang

selalu

dapat memberikan hasil yang optimal. Tetapi greedy

mengurangi jumlah langkah (kompleksitas) pencarian.

c. Algoritma Genetika
Algoritma genetika adalah algoritma komputasi yang diinspirasi oleh teori
evolusi yang kemudian diadopsi menjadi algoritma komputasi untuk mencari solusi
suatu permasalahan dengan cara yang alamiah. Algoritma ini dikembangkan oleh
Goldberg yang terinspirasi dari teori evolusi Darwin yang menyatakan bahwa
kelangsungan hidup suatu makhluk dipengaruhi oleh aturan yang kuat adalah yang
menang. Darwin juga mengatakan bahwa kelangsungan hidup suatu makhluk dapat
dipertahankan melalui proses reduksi, crossover, dan mutasi.
Sebuah solusi yang dibangkitkan dalan Algoritma Genetika disebut sebagai
kromosom, sedangkan kumpulan kromosom-kromosom tersebut disebut sebagai
populasi. Sebuah kromosom dibentuk dari komponen-komponen penyusun yang
disebuat sebagai gen dan nilainya dapat berupa bilangan numerik, biner, simbol atau
pun karakter tergantung dari permasalahan yang ingin diselesaikan. Kromosomkromosom tersebut akan berevolusi secara berkelanjutan yang disebut dengan generasi.
Dalam tiap generasi, kromosom-kromosom tersebut dievaluasi tingkat keberhasilan
nilai solusinya terhadap masalah yang ingin diselesaikan (fungsi_objektif)
menggunakan ukuran yang disebut fitness.

Untuk memilih kromosom yang tetap dipertahankan untuk generasi selanjutnya,

dilakukanlah proses seleksi. Kromosom dengan nilai fitness tinggi akan memiliki
peluang lebih besar untuk terpilih lagi pada generasi selanjutnya.
Offspring merupakan kromosom-kromosom baru yang dibentuk dengan cara
melakukan perkawinan antar kromosom dalam satu generasi, atau sering disebut
sebagai proses crossover. Jumlah kromosom yang mengalami crossover ditentukan
oleh parameter Pcrossover. Mekanisme perubahan susunan unsur penyusun makhluk
hidup akibat adanya faktor alam disebut dengan mutasi. Jadi, mutasi direpresentasikan
sebagai suatu proses berubahnya satu atau leih nilai gen dalam kromosom dengan suatu
nilai acak. Jumlah gen dalam populasi yang mengalami mutasi ditentukan oleh
parameter Pmutasi. Setelah beberapa generasi akan dihasilkan kromosom-kromosom
yang nilai gennya konvergen ke suatu nilai tertentu yang merupakan solusi terbaik yang
dihasilkan oleh Algoritma Genetika terhadap permasalahan yang ingin diselesaikan.
Algoritma Genetika sangat cocok untuk menyelesaikan masalah optimasi
dengan ruang lingkup yang besar, karena Algoritma Genetika selalu bergerak dengan
mencari sejumlah solusi sekaligus, selama solusi tersebut masih bersifat feasible (tidak
melanggar constraint). Dengan seting parameter yang tepat, diharapkan salah satu dari
sekian banyak solusi yang dibangkitkan oleh Algoritma Genetika merupakan solusi
optimum global.
Akan tetapi, Algoritma Genetika ini juga masih memiliki kelemahan yaitu
ketidakpastian untuk menghasilkan solusi optimum global, karena sebagian besar dari
algoritma ini berhubungan dengan bilangan random yang bersifat probabilistik.
Peranan programer disini adalah memaksimalkan probabilitas dalam menghasilkan
solusi optimum global dengan cara membuat suatu skema pengolahan input argumen
(fungsi fitness) dan setting parameter yang tepat.Algoritma genetik merupakan
algoritma komputer yang mencari suatu solusi-solusi baik dalam permasalah yang
memiliki sejumlah besar kemungkinan pemecahan yang ada. Semua algoritmaalgoritma

genetik

dimulai

dengan kumpulan solusi ( yang diwakili oleh

kromosom) yang biasa disebut populasi. Suatu populasi baru diciptakan dari solusisolusi yang ada dalam suatu populasi tua diharapan dapat menjadi suatu populasi
lebih baik. Solusi-solusi yang telah dipilih dalam membentuk solusi baru
(anak/offspings) akan diseleksi menurut fitness mereka. Semakin solusi-solusinya
tersebut cocok maka akan lebih banyak kesempatan mereka dalam produksi kembali.
Proses ini diulangi sampai kondisi yang diinginkan didapat.

d. Programan Dinamis
Metode ini merupakan metode yang sering digunakan untuk menyelesaikan
masalah knapsack baku. Algoritmanya sesuai untuk menyelesaikan kasus di mana
volume total atau V tidak terlalu besar. Metode ini menangani masalah knapsack
dengan menyelesaikan persamaan fungsi dari suatu masalah. Pemrograman dinamik
(PD) merupakan teknik matematika untuk menentukan penyelesaian optimal suatu
fungsi keuntungan pada masalah optimasi dengan n variabel yang dapat dikomposisi
menjadi n submasalah melalui n tahapan. Pada setiap tahapan dimasukkan satu variabel
kedalam sub masalah. Prinsip dasar pemrograman dinamik

adalah optimalitas,

perhitungannnya dikerjakan secara rekursif dengan pengertian bahwa penyelesaian

optimum pada satu submasalah digunakan sebagai input untuk sub masalah berikutnya
(Taha,1998)
Rekursi dalam program dinamik ada 2, yaitu rekursi maju dan rekursi mundur.
Penghitungan pada rekursi maju dimulai dari tahan 1 ke tahapan n, sedangkan rekursi
mundur dimulai dari tahapan n ke tahapan 1. Kedua jenis rekursi memberikan
penyelesaian optimal yang sama. Perbedaan pokok kedua rekursi ini adalah terletak
dalam cara mendefinisikan state Dalam pemrograman dinamik ada tiga elemen dasar
yaitu alternatif variabel keputusan, fungsi keuntungan yangbersesuaian, dan keadaan
(state) pada masing-masing tahapan. Variabel yang memberikan penyelesaian optimal
diperoleh dengan menelusuri keadaan tahapan n sampai tahapan 1.

BAB III
STUDI KASUS
3.1 Studi Kasus
Pada studi kasus diambil yaitu pada permasalahan 0/1 knapsack, dimana pada studi
kasus ini yaitu kita mempunyai sebuah tas yang memiliki batasan kapasitas yang dimilikan,
yang akan dimasukin oleh benda-benda yang memiliki berat yang beragam-ragam. Dari tiap
benda tersebut memiliki sebuah protif/valuenya. Pada kasus ini diupayakan yaitu bagaimana
memasukan benda-benda tersebut kedalam sebuah tas yang memiliki kapasitas maksimum
berat yang dapat ditampung, sehingga mendapatkan benda yang pas sesuai dengan kapasitas
yang ada dan memiliki profit/value yang besar pada akhir penghitungannya. Pada proses ini
yang digunakan adalah algoritma programan dinamis.

3.2 0/1 Knapsack dengan programan dinamis

Pada persoalan ini knapsack memiliki kapasitas tas yang bisanya disebut dengan W.
Selain kapasitas tersebut terdapat benda-benda yang akan dimasukan kedalam tas tersebut.
Benda tersebut memiliki berat masing-masing (Wbenda) dan value/harga dari benda. Ada pula
tahap yang merupakan proses memasukan barang ke dalam tas. Dalam logika ini mempunyai
rumus permasalahan yaitu

Dimana apabila berat benda lebih besar dari berat kapasitas maka nilai dari knapsack
adalah Knapsack(k-1,w), sedangkan sebalikan akan mendapatkan nilai maksimal dari
diperoleh

dari

knapsack

yaitu

max(Knapsack(k-1,w),

Knapsack(k-1,w-

WeighBenda[k])+value(k)). Sehingga pada studi kasus ini, pada program akan memiliki 3 buah
4 buah inputan yan dimana inputan yang dimasukan speerti dbawah ini:
a. Kapasitas Tas
b. Jumlah benda
c. Berat benda
d. Value Benda
Dari inputan tersebut maka akan dicari value profit keuntungan yang akan dicari
semaksimal mungkin dengan menggunakan metodi programan dimanis tersebut.

BAB IV
PROGRAM

4.1 Program
Pada tugas uts ini saya membuat 2 program dimana program yang dibuat
menggunakan compiler Microsoft Visual C++, program pertama saya membuat dengan
menggunakan outputan text yang dimana untuk memudahkan saya dalah memindahkan
program yang saya buat nantinya ke dalam form windows application. Program yang terdapat
pada win32 nantinya sama persis dengan program pada formnya.

4.2 Program win32

Berikut adalah program yang terdapat pada win32 atau dari outputan text yang
digunakan untuk menyelesaikan permasalahan knapsack ini.
#include <stdio.h>
#include <conio.h>
#define MAX 20
void knapsackDP(int,int);
int max(int,int);
void backtracking();
int weight[MAX],value[MAX],W,no,*x;
int v[MAX][MAX];
void main()
{
int i,j;
printf("\n Masukan Jumlah benda:");
scanf("%d",&no);
printf("\n Masukan weight and values pada benda tersebut");;
for(i=1;i<=no;i++)
{
printf("\n Masukan Weight and Value dari Object %d:",i);
scanf("%d %d",&weight[i],&value[i]);
}
printf("\n Masukan Kapasitas Tas:");
scanf("%d",&W);
knapsackDP(no,W);
backtracking()
getch();
}
void knapsackDP(int no,int W)
{ Berikut adalah program dari void main, dimana pada program ini terdapat perintah
int i,j;
perintah yangfor(i=0;i<=
digunakan untuk
memasukan inputan dari nilai-nilai yang akan digunakan dalam
W ;i++)
v[0][i]=0;
penyelesaian knapsack
ini. Inputan ini terdiri dari jumlah benda yang diinginkan, berat dan
for(i=0;i<= no;i++)
value setiap benda,v[i][0]=0;
dan kapasitas dari tas yang akan dimasukan. Terdapat fungsi
for(i=1;i<= no;i++)
{
knapsack(no,W)
yang dimana nanti akan diperlihatkan isi program dari fungsi tersebut.
for(j=1;j<= W;j++)
{
if((j-weight[i])< 0)
v[i][j]=v[i-1][j];
else
v[i][j]=max(v[i-1][j],v[i-1][j-weight[i]]+value[i]);
}
}

Terdapat pula backtracking() yaitu dimana fungsi ini akan berfungsi sebagai menampilkan dari
benda apa saja yang akan dimasukan kedalam tas.

void knapsackDP(int no,int W)

{
int i,j;
for(i=0;i<= W ;i++)
v[0][i]=0;
for(i=0;i<= no;i++)
v[i][0]=0;
for(i=1;i<= no;i++)
{
for(j=1;j<= W;j++)
{
if((j-weight[i])< 0)
v[i][j]=v[i-1][j];
else
v[i][j]=max(v[i-1][j],v[i-1][j-weight[i]]+value[i]);
}
}
printf("\n \t
");
for(i=0;i<= W;i++)
printf("%2d ",i);
printf("\n----------------------------------------------------------");
for(i=0;i<=no;i++)
{
printf("\n w%d=%2d v%d=%2d |",i,weight[i],i,value[i]);
for(j=0;j<= W;j++)
printf("%2d ",v[i][j]);
}
printf("\n-----------------------------------------------------------------");
printf("\n Maximum value dari knapsack is:%2d",v[no][W]);
printf("\n-----------------------------------------------------------------");
}
int max(int a,int b)
{
return (a >b)?a:b;
}
void backtracking()
{
int j1,i;
Berikut
j1=W; adalah program dari fungsi knapsack, pada bagian ini sudah dijelaskan pada
printf("\nMasukan Benda \t weight \t value");
terori diatas
bahwa apa bila if((j-weight[i])< 0) maka nilai dari knapsack adalah v[i][j]=v[iprintf("\n----------------------------------------------------------------------------");
1][j];.
Sedangkan apaliba sebaliknya maka nilai dari knapsack adalah v[i][j]=max(v[i-1][j],v[ifor(i=no;i >=0;i--)
{
1][j-weight[i]]+value[i]);
fungsi max sendiri berisi return (a >b)?a:b;. Pada program ini
if(v[i][j1]!=v[i-1][j1] && (v[i][j1]==v[i-1][j1-weight[i]]+value[i]))
{ penampung v[Max][Max] dimana sebenarnya untuk memudahkan melakukan
digunakan
printf("\n%2d \t\t\t %2d
\t\t %2d",i,weight[i],value[i]);
pemanggilan supaya
akan menghasilkan deret untuk melihat penghitungan dari nilai knapsack
j1=j1-weight[i];
}
yang
} akan kita cari.
}

void backtracking()
{
int j1,i;
j1=W;
printf("\nMasukan Benda \t weight \t value");
printf("\n-----------------------------------------------------------------");
for(i=no;i >=0;i--)
{
if(v[i][j1]!=v[i-1][j1] && (v[i][j1]==v[i-1][j1-weight[i]]+value[i]))
{
printf("\n%2d \t\t\t %2d
\t\t %2d",i,weight[i],value[i]);
j1=j1-weight[i];
}
}
}

Berikut adalah program dari fungsi backtracking yang berisi informasi yang digunakan
program untuk memanggi benda apa saja yang bisa masuk dalam tas. Sehingga dengan
program ini selain mengetahui kapasitas maksimun value yang didapat, akan dilihatkan juga
benda-benda apa saja yang termasuk didalamnya.
Pada percobaan yang kita buat untuk melihat hasil dari program diatas kita masukan
nilai-nilai seperti berikut:
a. Jumlah benda yang dimasukan = 6
b. Kapasitas tas adalah = 10
c. Berikut susan berar dan value dari tiap benda:
1. Berat 6, Value 10
2. Berat 1, Value 5
3. Berat 2, Value 7
4. Berat 5, Value 12
5. Berat 4, Value 8
6. Berat 3, Value 6

Berikut adalah hasil dari percobaan yang berdasarkan data diatas:

Dapat dilihat bahwa maksimum value yang didapatkan dari pengisian tas yang
memiliki kapasita 10, tersebut adalah 26.
4.3 Program Form Windows Application
Pada program ini hampir sama dengan program diatas tapi pada program ini hanya
berubah yaitu penampilan dari cara menampilkan pada textbox atau listbox. Berikut adalah
tampilan awal dari program windows form application yang dibuat.

Pada program ini masukan benda hanya ada 6 buah. Dan kapasitas benda kita inputkan
sendiri. Juga terdapat kolom textbox yang akan menampilakn hasil dari keuntungan maksimal
dari benda. Ada juga item yang diambil pada listbox2. Pada listbox1 adalah deretan dari
inputan benda yang dimasukan dari benda yang pertama sampai terakhir yang dimana terdapat
berat dan value benda.
Berikut yaitu melakukan percobaan dengan data yang sama dengan pada percobaan
win32 dimana:
a.

Jumlah benda yang dimasukan = 6

b.

Kapasitas tas adalah = 10

c.

Berikut susan berar dan value dari tiap benda:

1.

Berat 6, Value 10

2.

Berat 1, Value 5

3.

Berat 2, Value 7

4.

Berat 5, Value 12

5.

Berat 4, Value 8

6.

Berat 3, Value 6

Berikut adalah hasil dari percobaan yang berdasarkan data diatas:

Dari percobaan diatas makan keuntungan maksimal dari proses memasukan benda
kedala tas yang memiliki kapasitas 10 adalah 26. Dan item yang diambil dapat dilihat dari
gambar diatas. Data nilai dari percobaan win32 dan form sama dikarena fungsinya sama.

BAB V
KESIMPULAN

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. Sering kali hasil tersebut berupa
keuntungan maksumun. Banyak metode alogritma yang digunakan untuk menyelesaikan
permasalahan knapsack diantara lain: greedy, algoritma genetic dan alogritma programan
dinamis.