Recorded work from Tuesday.

dynamic-programming/notes.md

@@ -54,35 +54,35 @@ Problem: Subject to an integer weight limit, what choice of items (allowing repe
 ## DAG
 
 *   Edges (actions):
-    *   … or
-    *   …
+    *   Take one of the items or
+    *   Take one kg of nothing.
 *   Vertices (situations):
-    *   …
+    *   How much weight have we put into the backpack so far?
 *   Edge weights:
-    *   …
+    *   The value of the item being taken
 *   Topological order:
-    *   …
+    *   Increasing order : 0 → 1 → … → `weightLimit` (assuming that no items have nonpositive weight)
 *   Goal:
-    *   …
+    *   Find a longest path from 0 to `weightLimit`
 
 ## Backpointer Class
 
 *   Information for the final result:
-    *   …
+    *   What item did we take?
 *   Information to go back:
-    *   …
+    *   What was the weight of the item taken?  (this is redundant with the item taken)
 *   Information to compare quality:
-    *   …
+    *   What is the *total* value of all of the items taken so far?
 
 ## Choosing a Backpointer
 
 *   Exhaustive search:
-    *   Generate ….
-    *   Check that ….
+    *   Generate items from the list or else 1 kg of nothing, but make sure that we don't try to go back to a negative total weight.
+    *   Check that the item maximizes the total value (the previous total value plus the value of the item used to go back).
 
 ## Example
 
-*   Item Z ….
+*   Item Z weighs 1 kg and is worth $0.
 *   Item A weighs 3 kg and is worth $10.
 *   Item B weighs 4 kg and is worth $14.
 
@@ -91,20 +91,20 @@ Problem: Subject to an integer weight limit, what choice of items (allowing repe
     Weight (kg)   Item   Total Value  (Back to Weight)
     -----------  ------  -----------  ----------------
               0  [none]           $0  ⊥
-              1  Item …            …  …
-              2  Item …            …  …
-              3  Item …            …  …
-              4  Item …            …  …
-              5  Item …            …  …
-              6  Item …            …  …
-              7  Item …            …  …
-              8  Item …            …  …
-              9  Item …            …  …
-             10  Item …            …  …
+              1  Item Z            0  0
+              2  Item Z            0  1
+              3  Item A           10  0
+              4  Item B           14  0
+              5  Item Z           14  4
+              6  Item A           20  3
+              7  Item A           24  4
+              8  Item B           28  4
+              9  Item A           30  6
+             10  Item A           34  7
 
     Reversed Path
     ----
-    10 ← (Item …) ← …
+    10 ← (Item A) ← 7 ← (Item A) ← 4 ← (Item B) ← 0
 
 --------------------------------------------------------------------------------
 

dynamic-programming/src/features/knapsack/solver.js

 import { Item } from './items.js';
 
+const KILOGRAM_OF_NOTHING = new Item(1, 0);
+
 class Backpointer {
-  constructor() {
-    // TODO: stub
+  constructor(item, totalValue) {
+    this.item = item;
+    this.totalValue = totalValue;
   }
 }
 
 function chooseBackpointer(items, backpointers) {
   const currentWeight = backpointers.length;
-  // TODO: stub
+  let best = new Backpointer(KILOGRAM_OF_NOTHING, backpointers[currentWeight - 1].totalValue);
+  for (const item of items) {
+    const previousWeight = currentWeight - item.weight;
+    if (previousWeight >= 0) {
+      const candidate = new Backpointer(
+        item,
+        backpointers[previousWeight].totalValue + item.value,
+      );
+      if (candidate.totalValue > best.totalValue) {
+        best = candidate;
+      }
+    }
+  }
+  return best;
 }
 
 export function chooseItems(items, weightLimit) {
   console.assert(Number.isInteger(weightLimit), `Tried to choose items with a noninteger weight limit ${weightLimit}.`);
-  return []; // TODO: stub
+  const backpointers = [new Backpointer(undefined, 0)];
+  while (backpointers.length <= weightLimit) {
+    backpointers.push(chooseBackpointer(items, backpointers));
+  }
+  const reversedPath = [];
+  for (let weight = weightLimit; weight > 0; weight -= backpointers[weight].item.weight) {
+    const item = backpointers[weight].item;
+    if (item !== KILOGRAM_OF_NOTHING) {
+      reversedPath.push(item);
+    }
+  }
+  return reversedPath.reverse();
 }