KNAPSACK PROBLEM
Dalam kehidupan sehari-hari, kita sering dipusingkan dengan media penyimpanan yang terbatas padahal kita diharuskan menyimpan beberapa objek kedalam media tersebut. Bagaimana kita mengatur objek apa saja yang dipilih dan seberapa besar objek tersebut disimpan?
Dari permasalahan tersebut, munculah suatu permasalahan yang dikenal dengan "Permasalahan Knapsack" atau lebih dikenal dengan "Knapsack Problem". Masalah Knapsack merupakan suatu permasalahan bagaimana memilih objek dari sekian banyak dan berapa besar objek tersebut akan disimpan sehingga diperoleh suatu penyimpanan yang optimal dengan memperhatikan objek yang terdiri dari n objek (1,2,3,...) dimana setiap objek memiliki bobot (Wi) dan profit (Pi) dengan memperhatikan juga kapasitas dari media penyimpanan sebesar M dan nilai probabilitas dari setiap objek (Xi).
Metode Greedy merupakan salah satu cara untuk mendapatkan solusi optimal dalam proses penyimpanan. Pada metode ini untuk mendapatkan solusi optimal dari permasalahan yang mempunyai dua kriteria yaitu Fungsi Tujuan/Utama dan Nilai Pembatas (Constrain). Fungsi Tujuan hanya terdiri atas satu fungsi sedangkan Fungsi Pembatas dapat terdiri atas lebih dari satu fungsi.
Proses Kerja Metode Greedy
Menyelesaikan suatu masalah dengan beberapa fungsi pembatas untuk mencapai satu fungsi tujuan. Jadi dalam penyelesaiannya harus ditentukan mana sebagai fungsi pembatas dan mana sebagai fungsi tujuan.
Cara menyelesaikan masalah Knapsack adalah
1. Tentukan Fungsi Tujuan, yaitu mencari nilai maximum dari jumlah hasil perkalian antara nilai profit (Pi) dengan nilai probabilitas (Xi)
Maximum Pi.Xi
2. Tentukan Fungsi Pembatas, yang merupakan hasil penjumlahan dari perkalian antara bobot (Wi) dengan nilai probabilitas (Xi) yang tidak boleh melebihi dari kapasitas media penyimpanan (M)
Wi.Xi M, dimana
0 Xi 1, Pi>0, Wi>0
Dari ke-2 cara di atas berarti kita harus mengetahui :
1. Jumlah objek (n)
2. Bobot setiap objek (Wi)
3. Profit setiap objek (Pi)
4. Probabilitas setiap objek (Xi), dan
5. Kapasitas media penyimpanan (M)
Pembahasan
1. Algortima greedy, yaitu
PROCEDURE GREEDY KNAPSACK (P, W, X, n)
REAL P(1:n), W(1:n), X(1:n), M, isi
INTEGER i, n
X(1:n) = 0
isi = M
FOR i = 1 TO n DO
IF W(i) > isi THEN EXIT ENDIF
X(i) = 1
isi = isi – W(i)
REPEAT
IF i n THEN X(i) = isi/W(i) ENDIF
END GREEDY KNAPSACK
Teknik yang ke-3 ini akan efektif jika objek disusun secara tidak naik (non increasing) berdasarkan nilai Pi/Wi.
Contoh soal :
Diketahui 3 barang yang akan disimpan pada suatu tempat yang memiliki kapasitas maksimal sebesar 20 Kg. Berat masing-masing barang adalah 18 Kg, 15 Kg, dan 10 Kg dimana setiap barang memiliki profit sebesar masing-masing 25, 24, dan 15. Tentukan barang mana saja yang dapat disimpan ke dalam tempat penyimpanan sehingga diperoleh nilai profit yang maksimal.
Jawab
1. Cara algoritma greedy
Teknik ini akan efektif jika objek disusun secara tidak naik (non increasing) berdasarkan nilai Pi/Wi.
Data yang diketahui:
n = 3, (1, 2, 3) objek
M = 20 kapasitas
(W1, W2, W3) = (18, 15, 10)
(P1, P2, P3) = (25, 24, 15)
Nilai probabilitas 0 Xi 1
perbandingan profit dengan bobot
P1/ W1 = 25/18 = 1,39
P2/ W2 = 24/15 = 1,6
P3/ W3 = 15/10 = 1,5
Susun data sesuai kriteria (non increasing):
(P2, P3, P1) = (24, 15, 25) atau
(P1, P2, P3) = (24, 15, 25)
(W2, W3, W1) = (15, 10, 18) atau
(W1, W2, W3) = (15, 10, 18)
Masukkan nilai kriteria di atas ke dalam algoritma greedy
1. PROCEDURE GREEDY KNAPSACK (P, W, X, n) nama prosedur/proses
2. REAL P(1:n), W(1:n), X(1:n), M, isi variabel yang digunakan
3. INTEGER i, n variabel yang digunakan
4. X(1:n) = 0
5. isi = M
6. FOR i = 1 TO n DO
7. IF W(i) > isi THEN EXIT ENDIF
8. X(i) = 1
9. isi = isi – W(i)
10. REPEAT
11. IF i n THEN X(i) = isi/W(i) ENDIF
12. END GREEDY KNAPSACK akhir prosedur/proses
Proses kegiatan dimulai dari langkah ke- 4 sampai dengan 11.
X(1:3) = 0, artinya X(1)=0, X(2)=0, X(3)=0
isi = M = 20
Pengulangan untuk i = 1 sampai dengan 3
Untuk i = 1
Apakah W(1) > isi
Apakah 15 > 20, jawabnya tidak, karena tidak maka perintah dibawah IF dikerjakan.
X(1) = 1 nilai probabilitas untuk objek pada urutan pertama (X1)
isi = 20 – 15 = 5
REPEAT mengulang untuk perulangan FOR
Untuk i = 2
Apakah W(2) > isi
Apakah 15 > 5, jawabnya ya, karena ya maka perintah EXIT dikerjakan, yaitu keluar dari pengulangan/FOR dan mengerjakan perintah di bawah REPEAT.
Apakah 2 3, jawabnya ya, karena ya maka X(2) = 5/10 = ½ nilai probabilitas untuk objek pada urutan kedua (X2).
Selesai (akhir dari prosedur greedy knapsack)
Berarti untuk nilai X(3) = 0 atau X3 = 0, sebab nilai probabilitas untuk objek ke-3 tidak pernah dicari.
Jadi
(P1, P2, P3) = (24, 15, 25)
(W1, W2, W3) = (15, 10, 18)
(X2, X3, X1) = (1, 1/2, 0)
Fungsi Pembatas :
Wi.Xi M
(W1. X1) + (W2. X2) + (W3. X3) M
(15.1) + (10.1/2) + (18.0) 20
20 20
Fungsi Tujuan :
Pi.Xi = (P1. X1) + (P2. X2) + (P3. X3)
= (24.1) + (15.1/2) + (25.0)
= 31,5
SOURCE CODE
Knapsack.java
package knap5;
import java.util.*;
import java.io.*;
import java.lang.*;
public class Knapsack {
static int n = 5, W;
static obj st[];
public static BufferedReader br = new BufferedReader ( new InputStreamReader ( System.in ) );
public static void main ( String args[] ) throws IOException {
int i = 0;
System.out.println ( "Knap Sack Problem\n------------------\n" );
System.out.print ( "Masukkan banyaknya objek : " );
n = Integer.parseInt ( br.readLine() );
System.out.print ( "Masukkan berat maksimum yang dapat dimasukkan ke kantong : " );
W = Integer.parseInt ( br.readLine() );
st = new obj[n];
for ( i = 0; i < n; i++ ) {
st[i] = new obj();
System.out.print ( "Objek #" + ( i + 1 ) + " :-\n\tBerat (Kg) : " );
st[i].weight = Float.parseFloat ( br.readLine() );
System.out.print ( "\tProfit (Rp): " );
st[i].profit = Float.parseFloat ( br.readLine() );
st[i].p_perKg = Round ( st[i].profit / st[i].weight, 2 );
System.out.print ( "\tProfit per Kg: " + st[i].p_perKg + "\n" );
st[i].index = i + 1;
}
bubbleSort();
System.out.print ( "\nSolusi Optimal : " );
fill_sack();
}
public static float Round ( float Rval, int Rpl ) {
float p = ( float ) Math.pow ( 10, Rpl );
Rval = Rval * p;
float tmp = Math.round ( Rval );
return ( float ) tmp / p;
}
static void fill_sack() {
float x[] = new float[n];
float u, tot_profit = 0;
int i;
for ( i = 0; i < n; i++ )
x[i] = 0;
u = W;
for ( i = 0; i < n; i++ ) {
if ( st[i].weight > u )
break;
x[i] = 1;
u -= st[i].weight;
System.out.print ( "\nmemasukkan objek ke " + st[i].index + " ( Rp. " + st[i].profit + " , " + st[i].weight + " Kg) kedalam kantong.\n" );
System.out.print ( "Kantong masih dapat menampung : " + u + "Kg" );
tot_profit += st[i].profit;
}
// if ( i < n ) {
// x[i] = Round ( u / st[i].weight, 2 );
// u -= Round ( st[i].weight * x[i], 2 );
// System.out.print ( "\nAdded " + x[i] + " of object " + st[i].index + " (" + Round ( st[i].profit * x[i], 2 ) + "Rs., " + Round ( st[i].weight * x[i], 2 ) + "Kg) in the bag.\n" );
// System.out.print ( "Bag can still hold : " + u + "Kg" );
// tot_profit += Round ( st[i].profit * x[i], 2 );
// }
System.out.print ( "\n\nTotal Profit earned = Rp." + tot_profit + "/-" );
}
static void bubbleSort() {
for ( int pass = 1; pass < n; pass++ )
for ( int i = 0; i < n - pass; i++ )
if ( st[i].p_perKg < st[i+1].p_perKg ) {
obj temp = new obj();
temp = st[i];
st[i] = st[i+1];
st[i+1] = temp;
}
}
static class obj {
float weight;
float profit;
float p_perKg;
int index;
}
}
ScreenShoot
JOB SCHEDULING
Job shop scheduling secara umum lebih dikenal sebagai shop floor control, yang merupakan kegiatan penyusunan input (memasang yang diperlukan) menjadi input. Proses produksi dengan aliran job shoop berarti proses produksi dengan pola aliran atau rute proses pada tiap mesin yang spesifik untuk setiap pekerjaan dan mungkin berbeda untuk tiap job. Akibat aliran proses yang tidak searah ini, maka setiap job yang akan diproses pada satu mesin dapat merupakan job yang baru atau job dalam proses dan job yang keluar dari suatu mesin dapat merupakan job jadi atau job dalam proses. Dalam job shop tidak semua pkerjaan diasumsikan akan tepat satu kali menerima m operasi, dan untuk beberapa pekerjaan membutuhkan beberapa operasi dalam sebuah mesin.
Aliran Job Shop dimana P (Job) dan M (Machine)
Beberapa kriteria penting dalam masalah penjadwalan job shop adalah
1. Kedatangan job
Masalah job yang ada selama ini adalah masalah statik yang biasa disebut snapshot dari sebuah sistem pada titik dalam waktu dan diproses untuk menyelesaikan masalah berdasarkan nilai yang berlaku walaupun banyak solusi algoritma tetapi perlu dipertimbangkan bahwa sebuah masalah dapat menjadi statik, pada kenyataannya masalah tersebut menjadi dinamik dengan sendirinya.
2. Jumlah dan mesin yang ada.
Job shop harus memiliki tampilan yang unik dengan mengimplementasikan solusi yang diperoleh dari penjadwalan dengan algoritma. Sebagai contoh, asumsi umur dari mesin yang memberikan tipe yang identik. Hal ini tidak sealu menjadi masalah, mesin yang utama dilihat dari berbagai jenis variasi seperti kondisi dari mesin atau kemampuan dati operator.
3. Jumlah Tenaga kerja di lantai produksi.
Jumlah tenaga kerja dan jenis mesin dari lantai produksi ditentukan dari kapasitas yang tersedia. Perencanaan kapasitas adalah aspek yang penting dari perencanaan produksi.
4. Aliran utama produksi.
Solusi diperoleh dari penjadwalan algoritma diperlukan job yang lengkap pada jumlah order yang tetap. Bagaimanapun pengurutan job berdasarkan hasil mesin dalam contoh aliram material dalam sistem.
5. Evaluasi dari alternatif solusi.
Pilihan yang obyektif ditentukan dari kenyamanan dan keefektifan dari aturan pengrutan. Secara umum lebih dari satu objek yang penting srhingga mustahil untuk
menentukan aturan yang optimal.
Job shop scheduling problem merupakan salah satu masalah penjadwalan yang memiliki kendala urutan pemrosesan tugas, dan setiap tugas harus melalui setiap mesin tepat satu kali. Terdapat dua jenis metode yang biasa digunakan untuk menyelesaikan masalah job shop scheduling problem. Metode eksak, seperti pemrograman linier dan pemrograman nonlinier, dapat digunakan untuk ukuran job shop scheduling problem yang kecil. Sedangkan untuk ukuran masalah yang besar, digunakan suatu pendekatan secara aproksimasi, seperti local search, simulated annealing, genetic algorithm, tabu search, dan ant colony optimization.
Di dalam Job shop scheduling problem, diberikan suatu masalah dengan n pekerjaan dan m mesin. Setiap pekerjaan harus diproses tepat satu kali pada setiap mesin sesuai dengan urutannya masing-masing. Karena tugas adalah kombinasi dari pekerjaan dan mesin, maka dua tugas dari suatu pekerjaan tidak boleh dikerjakan pada waktu yang bersamaan, dan setiap mesin hanya dapat memproses paling banyak satu pekerjaan pada satu waktu. Tujuan dari job shop scheduling problem adalah mencari suatu jadwal yang meminimumkan waktu yang dibutuhkan untuk menyelesaikan semua pekerjaan.
SOURCE CODE
Job.java
package job;
import java.io.*;
import java.util.*;
public class job {
public static InputStreamReader input=new InputStreamReader(System.in);
public static BufferedReader br =new BufferedReader(input);
static int job[][], n, maxd = 0;
public static void main(String[] args) throws IOException{
System.out.print("Masukkan jumlah job : ");
n = Integer.parseInt( br.readLine() );
job = new int[n][3];
System.out.println("Inputkan job detailnya : ");
for(int i =0; i
System.out.print("job #"+(i+1)+" :-\n\tKeuntungan : ");
job[i][0]=Integer.parseInt( br.readLine() );
do{
System.out.print("\tDead Line: ");
job[i][1]=Integer.parseInt( br.readLine() );
if(job[i][1] <= 0)
{
System.out.print("\tDeadline Keliru!\nInputkan lagi\n");
continue;
}
else if(maxd < job[i][1])
{
maxd = job[i][1];
}
break;
}while(true);
job[i][2]=i+1;
}
bubble_sort();
JobSeq();
int profit = 0;
System.out.print("\nThe optimal solution is J = {" );
for(int i=1; i<=k; i++)
{
System.out.print((job[J[i]-1][2])+", ");
profit += job[J[i]-1][0];
}
System.out.print("\b\b } with a profit of "+ profit + ".");
}
public static void bubble_sort(){
int i, j, t[][];
t = new int[1][3];
for(i = 0; i < n; i++)
for(j = 1; j < (n-i); j++)
if(job[j-1][0] < job[j][0])
{
t[0] = job[j-1];
job[j-1]=job[j];
job[j]=t[0];
}
}
static int J[], k;
static void JobSeq(){
J = new int[maxd+1];
int temjob[] = new int[n+1];
int r;
for(int i=1; i<=n; i++)
temjob[i] = job[i-1][1];
for(int i=0; i<=maxd; i++)
J[i]=0;
temjob[0] = J[0] = 0;
J[1] = 1;
k=1;
for(int i=2; i<=n; i++)
{
r=k;
while((temjob[J[r]] > temjob[i]) && (temjob[J[r]] != r))
r--;
if((temjob[J[r]] <= temjob[i]) && (temjob[i] > r) )
{
for(int q = k; q>= r+1; q--)
J[q+1] = J[q];
J[r+1] = i; k++;
}
}
return;
}
}
ScreenShoot
MINIMUM SPANNING TREE
MINIMUM SPANNING TREE
Minimum spanning tree adalah suatu pohon yang dapat didefinisikan dengan sebuah graf. Graf berarah dan graf tidak berarah adalah subgraf yang setiap node/simpulnya terkoneksi satu sama lain. Sebuah graf, dapat memberikan pohon rentang yang berbeda. Pada setiap ruas/edge, kita dapat memberikan suatu bobot untuk menentukan suatu nilai. Setiap bobot tersebut akan dibandingkan dengan bobot yang lain yang mengarah pada simpul berikutnya, selanjutnya akan dipilih bobot yang terkecil. Hal ini akan terus dilakukan sampai menuju simpul tujuan. Ini yang disebut dengan minimum spanning tree.
Algoritma pertama untuk mencari pohon rentang minimum dikembangkan oleh ilmuwan Ceko Otakar Borůvka pada tahun 1926 (lihat algoritma Borůvka's). Tujuannya adalah cakupan listrik efisien Moravia. Sekarang ada dua algoritma yang umum digunakan, algoritma Prim dan algoritma Kruskal's. Ketiga adalah algoritma greedy yang dijalankan dalam waktu polynomial. Algoritma greedy lainnya tidak umum digunakan adalah algoritma reverse-delete, yang merupakan kebalikan dari algoritma Kruskal's. Algoritma minimumspanning tree tercepat sampai saat ini dikembangkan oleh Bernard Chazelle, dengan running time adalah O (m α (m, n)), di mana m adalah jumlah ruas, n adalah jumlah simpul dan α adalah kebalikan fungsional klasik dari fungsi Ackermann. Fungsi ini tumbuh sangat lambat.
Baru-baru ini, penelitian telah difokuskan pada pemecahan masalah minimum spanning tree dengan cara yang sangat parallelized. Dengan jumlah prosesor linier yang mungkin untuk memecahkan masalah dalam O (logn) kali. Sebuah penulisan pada tahun 2003 "Fast Shared-Memory Algorithms for Computing the Minimum Spanning Forest of Sparse Graphs" oleh David A. Bader dan Guojing Cong mendemonstrasikan algoritma pragmatic yang dapat mengkomputasi MST 5 kali lebih cepat didalam 8 prosesor daripada algorima optimized sequential.
Algoritma khusus lainnya telah dirancang untuk komputasi pohon rentang minimum dari suatu graf begitu besar sehingga sebagian besar harus disimpan pada disk setiap saat. Algoritma penyimpanan eksternal ini, misalnya seperti yang dijelaskan dalam "Rekayasa sebuah Memori Eksternal Minimum Spanning Tree Algoritma" oleh Romawi Dementie dapat beroperasi setidaknya 2 sampai 5 kali lebih lambat dari algoritma tradisional di memori. mereka mengklaim bahwa "minimum spanning tree masalah besar mengisi beberapa hard disk dapat diatasi semalam di PC." Mereka mengandalkan efisien algoritma pengurutan penyimpanan eksternal dan teknik grafik kontraksi untuk mengurangi ukuran grafik secara efisien.
Pseudocode Algoritma Kruskal yang merupakan salah satu metode pencari MST
Pseudocode Algoritma Prim
Contoh permasalahan tentang Minimum Spanning Tree
Suatu Graf G :
Ini adalah graf berbobot awal. Graf ini bukan pohon karena ada sirkuit. Nama yang lebih tepat untuk diagram ini adalah Graf atau Network.Angka-angka dekat garis penghubung/ruas adalah bobotnya. Nilai bobot dari Graf tesebut adalah : 86
Kita akan mencari MST dengan menggunakan Algoritma Solin dan Kruskal untuk Graf G diatas.
Penyeselaian :
ALGORITMA SOLIN :
1. Urutkan Ruas Graf (G) menurut bobotnya dari bobot yang terbesar sampai bobot yang terkecil.
Lakukan penghapusan masing-masing ruas yang tidak menyebabkan graf menjadi tidak terhubung atau membentuk sirkuit. Kita mulai melakukan tahapan penghapusan dengan ruas dengan nilai bobot terbesar sampai bobot terkecil :
Ruas D,E tidak dihapus karena ruas tersebut menghubungkan D dan E
Ruas B,D dan E,F tidak dihapus karena kedua ruas tersebut menyebabkan graf terhubung
Ruas B,C dan F,G tidak dihapus.
Ruas B,E dihapus, karena membentuk sirkuit (B,D,E,B)
Ruas A,D tidak dihapus.
Ruas C,E dihapus, karena membentuk sirkuit (D,B,C,E,D)
Ruas A,B dan E,G dihapus.
karena membentuk sirkuit (A,B,D,A) dan (E,F,G,E)
Ruas D,F dihapus.
karena membentuk sirkuit (D,E,F,D)
Tahap Penghapusan Selesai, Gambar 6 adalah Minimun Spanning Tree dari Graf G dengan Nilai Bobot : 56
SOURCE CODE
Prim.java
