add knapsack DP solution get 30/60

Author: tmp-coder

discrete-optimization/knapsack/Solver.java

@@ -0,0 +1,121 @@
+import java.io.*;
+import java.util.List;
+
+
+import java.util.ArrayList;
+
+/**
+ * The class <code>Solver</code> is an implementation of a greedy algorithm to solve the knapsack problem.
+ *
+ */
+public class Solver {
+    
+    /**
+     * The main class
+     */
+    public static void main(String[] args) {
+        try {
+            solve(args);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+    
+    /**
+     * Read the instance, solve it, and print the solution in the standard output
+     */
+    public static void solve(String[] args) throws IOException {
+        String fileName = null;
+        
+        // get the temp file name
+        for(String arg : args){
+            if(arg.startsWith("-file=")){
+                fileName = arg.substring(6);
+            } 
+        }
+        if(fileName == null)
+            return;
+        
+        // read the lines out of the file
+        List<String> lines = new ArrayList<String>();
+
+        BufferedReader input =  new BufferedReader(new FileReader(fileName));
+        try {
+            String line = null;
+            while (( line = input.readLine()) != null){
+                lines.add(line);
+            }
+        }
+        finally {
+            input.close();
+        }
+        
+        
+        // parse the data in the file
+        String[] firstLine = lines.get(0).split("\\s+");
+        int items = Integer.parseInt(firstLine[0]);
+        int capacity = Integer.parseInt(firstLine[1]);
+
+        int[] values = new int[items];
+        int[] weights = new int[items];
+
+        for(int i=1; i < items+1; i++){
+          String line = lines.get(i);
+          String[] parts = line.split("\\s+");
+
+          values[i-1] = Integer.parseInt(parts[0]);
+          weights[i-1] = Integer.parseInt(parts[1]);
+        }
+
+        // a trivial greedy algorithm for filling the knapsack
+        // it takes items in-order until the knapsack is full
+        
+        KnapsackSolver solver  = new DPSolver();
+        solver.solve(items,capacity,values,weights);
+              
+    }
+    public static void output(int value,int opt,int[] taken) {
+        System.out.println(value+" "+opt);
+        int items = taken.length;
+        for(int i=0; i < items; i++){
+            System.out.print(taken[i]+" ");
+        }
+        System.out.println("");
+    }
+}
+
+
+interface KnapsackSolver{
+    public void solve(int n,int K,int[] values,int[] weights);
+}
+
+class DPSolver implements KnapsackSolver{
+    private static final int MAX_SOLVE_SPACE = 100000000;
+    public void solve(int n,int K,int[] values,int[] weights){
+        if(n * K > MAX_SOLVE_SPACE)
+            System.err.printf("need memory %d, but MAX_SOLVE_SPACE is %d\n",n*K,MAX_SOLVE_SPACE);
+        int maxv;
+        int opt =1;
+        int[] token = new int[n];
+        int[][] dp = new int[K+1][n];
+        for(int k = 1 ; k <= K ; ++k){
+            dp[k][0] = (k >=weights[0]? values[0] : 0); 
+            for(int j = 1 ; j < n ; ++j){
+                dp[k][j] = dp[k][j-1];
+                if(k-weights[j] >=0 && dp[k][j] < dp[k-weights[j]][j-1] + values[j])
+                    dp[k][j] = dp[k-weights[j]][j-1] + values[j];
+            }       
+        }
+        
+        maxv = dp[K][n-1];
+        int k = K;
+        for(int j = n-1 ; j >0 ; --j ){
+            if(k >= weights[j] && dp[k][j] == dp[k-weights[j]][j-1] +values[j]){
+                token[j] =1;
+                k -=weights[j];
+            }
+        }
+        if(dp[k][0] !=0)token[0] =1;
+        Solver.output(maxv, opt, token);
+    }
+}

discrete-optimization/knapsack/_coursera

@@ -0,0 +1,8 @@
+_le-pVv_EeasJA5dVmWj2w
+Knapsack
+awPVV, ./data/ks_30_0, solver.py, Knapsack Problem 1
+hHYWS, ./data/ks_50_0, solver.py, Knapsack Problem 2
+JwWnx, ./data/ks_200_0, solver.py, Knapsack Problem 3
+Z2tMt, ./data/ks_400_0, solver.py, Knapsack Problem 4
+PUIxa, ./data/ks_1000_0, solver.py, Knapsack Problem 5
+AKXWc, ./data/ks_10000_0, solver.py, Knapsack Problem 6

discrete-optimization/knapsack/handout.pdf

@@ -0,0 +1,51 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+from collections import namedtuple
+Item = namedtuple("Item", ['index', 'value', 'weight'])
+
+def solve_it(input_data):
+    # Modify this code to run your optimization algorithm
+
+    # parse the input
+    lines = input_data.split('\n')
+
+    firstLine = lines[0].split()
+    item_count = int(firstLine[0])
+    capacity = int(firstLine[1])
+
+    items = []
+
+    for i in range(1, item_count+1):
+        line = lines[i]
+        parts = line.split()
+        items.append(Item(i-1, int(parts[0]), int(parts[1])))
+
+    # a trivial greedy algorithm for filling the knapsack
+    # it takes items in-order until the knapsack is full
+    value = 0
+    weight = 0
+    taken = [0]*len(items)
+
+    for item in items:
+        if weight + item.weight <= capacity:
+            taken[item.index] = 1
+            value += item.value
+            weight += item.weight
+    
+    # prepare the solution in the specified output format
+    output_data = str(value) + ' ' + str(0) + '\n'
+    output_data += ' '.join(map(str, taken))
+    return output_data
+
+
+if __name__ == '__main__':
+    import sys
+    if len(sys.argv) > 1:
+        file_location = sys.argv[1].strip()
+        with open(file_location, 'r') as input_data_file:
+            input_data = input_data_file.read()
+        print(solve_it(input_data))
+    else:
+        print('This test requires an input file.  Please select one from the data directory. (i.e. python solver.py ./data/ks_4_0)')
+

discrete-optimization/knapsack/solver.py

@@ -0,0 +1,36 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+import os
+from subprocess import Popen, PIPE
+
+def solve_it(input_data):
+
+    # Writes the inputData to a temporay file
+
+    tmp_file_name = 'tmp.data'
+    tmp_file = open(tmp_file_name, 'w')
+    tmp_file.write(input_data)
+    tmp_file.close()
+
+    # Runs the command: java Solver -file=tmp.data
+    os.system("javac .\Solver.java")
+    process = Popen(['java', 'Solver', '-file=' + tmp_file_name], stdout=PIPE)
+    (stdout, stderr) = process.communicate()
+    # removes the temporay file
+    os.remove(tmp_file_name)
+
+    return stdout.strip().decode('utf-8')
+
+
+import sys
+
+if __name__ == '__main__':
+    if len(sys.argv) > 1:
+        file_location = sys.argv[1].strip()
+        with open(file_location, 'r') as input_data_file:
+            input_data = input_data_file.read()
+        print(solve_it(input_data))
+    else:
+        print('This test requires an input file.  Please select one from the data directory. (i.e. python solver.py ./data/ks_4_0)')
+